diff --git a/Gopkg.lock b/Gopkg.lock
index c35eff924..573ad4168 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -10,7 +10,19 @@
   revision = "2a6c4f48b49f0d5dbfe621589da4c5405157d7c9"
 
 [[projects]]
-  digest = "1:98c3ff6d81ebc7de2cd494efa9147f790ed11374ab26509d3554561bdb4aa678"
+  branch = "master"
+  digest = "1:4cf11742b199ab3aacf26b00187e72f7ff8ba2145f363b74f295d54f098f79e4"
+  name = "github.com/agl/ed25519"
+  packages = [
+    ".",
+    "edwards25519",
+    "extra25519",
+  ]
+  pruneopts = "NUT"
+  revision = "5312a61534124124185d41f09206b9fef1d88403"
+
+[[projects]]
+  digest = "1:f5322546f652db78b7a8efd35047a61d1e492abca2263e1c647eca49e1c8a354"
   name = "github.com/aristanetworks/goarista"
   packages = ["monotime"]
   pruneopts = "NUT"
@@ -25,7 +37,7 @@
   version = "v0.2.0"
 
 [[projects]]
-  digest = "1:d7dda50f3893b5951cb0baf66a2d2a208847b0d151a30a843f5b6d5fa62c4876"
+  digest = "1:c6909083dcb35cf8556dfa9ef3aaccdcac0e1ebd40efa178d5d5337814b12d86"
   name = "github.com/btcsuite/btcd"
   packages = [
     "btcec",
@@ -37,7 +49,7 @@
   revision = "d06c0bb181529331be8f8d9350288c420d9e60e4"
 
 [[projects]]
-  digest = "1:629af7b2050d356a12211412b83f200aa0174bbe3434a0505d04b0b3c20ea0ed"
+  digest = "1:d42138ae1355a0ded51bc531ed9533f3e7c278ca84c4f7d73dcae3476c0de778"
   name = "github.com/btcsuite/btcutil"
   packages = [
     ".",
@@ -46,6 +58,14 @@
   pruneopts = "NUT"
   revision = "dcd4997b0664bcfd6ef48e4ae9da8396e08b1cd9"
 
+[[projects]]
+  digest = "1:0ef770954bca104ee99b3b6b7f9b240605ac03517d9f98cbc1893daa03f3c038"
+  name = "github.com/coreos/go-semver"
+  packages = ["semver"]
+  pruneopts = "NUT"
+  revision = "8ab6407b697782a06568d4b7f1db25550ec2e4c6"
+  version = "v0.2.0"
+
 [[projects]]
   digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
   name = "github.com/davecgh/go-spew"
@@ -61,7 +81,7 @@
   revision = "935e0e8a636ca4ba70b713f3e38a19e1b77739e8"
 
 [[projects]]
-  digest = "1:24ae9f4a9d6e2bed9aca667af245834c9a80c39d5ae32e3fc99a2ace91287047"
+  digest = "1:3238a0c355a81640974751f7d3bab21bf91035165f75c2c457959425c0422a4b"
   name = "github.com/ethereum/go-ethereum"
   packages = [
     ".",
@@ -119,6 +139,7 @@
     "p2p",
     "p2p/discover",
     "p2p/discv5",
+    "p2p/enr",
     "p2p/nat",
     "p2p/netutil",
     "params",
@@ -131,9 +152,17 @@
   revision = "dea1ce052a10cd7d401a5c04f83f371a06fe293c"
   version = "v1.8.11"
 
+[[projects]]
+  digest = "1:5ac7ecd476a2355a5201229081df2e5f57333ecf703e1f69dde699ae34169c1b"
+  name = "github.com/fd/go-nat"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "bad65a492f32121a87197f4a085905c35e2a367e"
+  version = "v1.0.0"
+
 [[projects]]
   branch = "master"
-  digest = "1:3ba17c20b2ca1a065683aeb7451b9ce35e1a70887241fc038c6914031e5df7f8"
+  digest = "1:3589601135d1e1a969f04643c4517d8a1b416564bbdb0b853e94f96faf2922c6"
   name = "github.com/fjl/memsize"
   packages = [
     ".",
@@ -143,7 +172,7 @@
   revision = "f6d5545993d68e9e42df43eb57958f898dea3623"
 
 [[projects]]
-  digest = "1:686cb116208fb5d47a0fd4cabf5569265e52ba98a231b6c06927c72c8d01d4a2"
+  digest = "1:672bdbde3b59017aba3b328d0ec42dc30e0ab80ff48681947596785738c00ff1"
   name = "github.com/go-playground/locales"
   packages = [
     ".",
@@ -168,6 +197,17 @@
   pruneopts = "NUT"
   revision = "54be5f394ed2c3e19dac9134a40a95ba5a017f7b"
 
+[[projects]]
+  digest = "1:f5c8165321274b23a2fc9210cd15a75ecbc62cac1fe9ee7320bd7b55146f8060"
+  name = "github.com/gogo/protobuf"
+  packages = [
+    "io",
+    "proto",
+  ]
+  pruneopts = "NUT"
+  revision = "1adfc126b41513cc696b209667c8656ea7aac67c"
+  version = "v1.0.0"
+
 [[projects]]
   digest = "1:a62049a8fa554d688c8db4845c65ddcd5986b75f3a851e4fb563c6893d292e38"
   name = "github.com/golang/mock"
@@ -177,7 +217,7 @@
   version = "v1.0.0"
 
 [[projects]]
-  digest = "1:102b542ac6937d65d70e093477d8f12b1ce1a4912552d6aa26c28a76280ddf5f"
+  digest = "1:cc9139958eb44c66d156bc76bde34a8202c6a4b837cc569299d916fa2f9290d5"
   name = "github.com/golang/protobuf"
   packages = [
     "proto",
@@ -193,6 +233,38 @@
   pruneopts = "NUT"
   revision = "553a641470496b2327abcac10b36396bd98e45c9"
 
+[[projects]]
+  digest = "1:3b708ebf63bfa9ba3313bedb8526bc0bb284e51474e65e958481476a9d4a12aa"
+  name = "github.com/gorilla/websocket"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:cb7e1d7ed4e663366eabc30a739a7c5cba439b7dbe39ede548f6ba0adc7fbe55"
+  name = "github.com/gxed/GoEndian"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "0f5c6873267e5abf306ffcdfcfa4bf77517ef4a7"
+
+[[projects]]
+  branch = "master"
+  digest = "1:72398b35192e5b9822e70ac5ee589c89c625728cd7e8e4333b33540edebfcb0b"
+  name = "github.com/gxed/eventfd"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "80a92cca79a8041496ccc9dd773fcb52a57ec6f9"
+
+[[projects]]
+  branch = "master"
+  digest = "1:148fd43daa0987df14b2d1105f86d8ba1d8a2b1f3c45ac81932edc4055739e1c"
+  name = "github.com/gxed/hashland"
+  packages = ["keccakpg"]
+  pruneopts = "NUT"
+  revision = "d9f6b97f8db22dd1e090fd0bbbe98f09cc7dd0a8"
+
 [[projects]]
   digest = "1:892e13370cbfcda090d8f7676ef67b50cb2ead5460b72f3a1c2bb1c19e9a57de"
   name = "github.com/hashicorp/golang-lru"
@@ -204,7 +276,7 @@
   revision = "0a025b7e63adc15a622f29b0b2c4c3848243bbf6"
 
 [[projects]]
-  digest = "1:281b5a580bd68a441fee561f9a7fd8805cafff2d03a69c435f1d4afcc9b7431b"
+  digest = "1:5865614642103a30fb7982202e14dcd6c9fb5cc3b47e5ec513de5e21123e8708"
   name = "github.com/huin/goupnp"
   packages = [
     ".",
@@ -218,6 +290,27 @@
   pruneopts = "NUT"
   revision = "679507af18f3c7ba2bcc7905392ce23e148661c3"
 
+[[projects]]
+  digest = "1:435513ca709dcb504e14fb2db3d91650c3e253b38940d6d1e23c2e8521666f69"
+  name = "github.com/ipfs/go-log"
+  packages = [
+    ".",
+    "tracer",
+    "tracer/wire",
+    "writer",
+  ]
+  pruneopts = "NUT"
+  revision = "5dc2060baaf8db344f31dafd852340b93811d03f"
+  version = "v1.5.3"
+
+[[projects]]
+  digest = "1:a27ae5d24391a7fd37f1987493ffb57801c7777d214b616fe02b5bb8e002bbd8"
+  name = "github.com/jackpal/gateway"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3e333950771011fed13be63e62b9f473c5e0d9bf"
+  version = "v1.0.4"
+
 [[projects]]
   digest = "1:23aa2b05a7e06cf3d789120cf974958759314ebd856de425fa24493bcb49e97b"
   name = "github.com/jackpal/go-nat-pmp"
@@ -226,12 +319,292 @@
   revision = "1fa385a6f45828c83361136b45b1a21a12139493"
 
 [[projects]]
-  digest = "1:23f1d358dec6d130b72874d1a280c3ed836c27664b9373b5f0c299df1c4f286c"
+  branch = "master"
+  digest = "1:c32c7a628507cc6d2e61cfc09f2671bef4a04491ca2ec0cda1e8689f9c00611f"
+  name = "github.com/jbenet/go-temp-err-catcher"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "aac704a3f4f27190b4ccc05f303a4931fd1241ff"
+
+[[projects]]
+  branch = "master"
+  digest = "1:af36a5dd3adea2a316125b04745b86e14e3600b930d61f4eefc0daa030feca74"
+  name = "github.com/jbenet/goprocess"
+  packages = [
+    ".",
+    "context",
+    "periodic",
+    "ratelimit",
+  ]
+  pruneopts = "NUT"
+  revision = "b497e2f366b8624394fb2e89c10ab607bebdde0b"
+
+[[projects]]
+  digest = "1:cdf2acbea0cf5514bc9a548836d007e379a42b4224813649ed9d98757c527172"
   name = "github.com/karalabe/hid"
   packages = ["."]
   pruneopts = "T"
   revision = "f00545f9f3748e591590be3732d913c77525b10f"
 
+[[projects]]
+  digest = "1:7f9d01bc5289296160042e42e146052ae9fb8fdb92be6dd11b0e5d4916784f6d"
+  name = "github.com/libp2p/go-addr-util"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "1c62fe93a4d85d6357ac65db3d08d22d011018a7"
+  version = "v2.0.3"
+
+[[projects]]
+  digest = "1:e6c117e1851ee7957111f72c3af90a0869f67f8f37ce2109b17c5855a3cb880e"
+  name = "github.com/libp2p/go-conn-security"
+  packages = [
+    ".",
+    "insecure",
+  ]
+  pruneopts = "NUT"
+  revision = "c2f2dd888803f4a703054084eb8d946d2281b7c4"
+  version = "v0.1.4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:16c1e843e58abb9821f93dfff5b462be0c39f366734dbda720e500cee3daec22"
+  name = "github.com/libp2p/go-conn-security-multistream"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "df26ef91ad66a626a4b7147fd95d18962395a20e"
+
+[[projects]]
+  digest = "1:a0ffb7231c41f54863d44f23cb7c6d1273fb66db6ccfe68a55b63050217fbafb"
+  name = "github.com/libp2p/go-flow-metrics"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "cc546389dcf06b4bcbf6b8594069588e5c8a1451"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:10da72efc65b13624d56559e26ff63c36adf010103133b4fbbe3bb45cb6f35d3"
+  name = "github.com/libp2p/go-libp2p"
+  packages = [
+    ".",
+    "config",
+    "p2p/host/basic",
+    "p2p/protocol/identify",
+    "p2p/protocol/identify/pb",
+  ]
+  pruneopts = "NUT"
+  revision = "a08d9e63dbf006c905a532d5f645a2bf6fae3bd1"
+
+[[projects]]
+  digest = "1:b0c28e3ac52ad20f1634c7bca2ec080513b5d1cb18f9d59ad39cac37a3ab61cc"
+  name = "github.com/libp2p/go-libp2p-circuit"
+  packages = [
+    ".",
+    "pb",
+  ]
+  pruneopts = "NUT"
+  revision = "dc62c804d879c9e706365f003a8143385bd34609"
+  version = "v2.1.4"
+
+[[projects]]
+  digest = "1:bbc5fc51426225288282e18dc070718dd34c472f6d8dba3c72df9919b0d7e652"
+  name = "github.com/libp2p/go-libp2p-crypto"
+  packages = [
+    ".",
+    "pb",
+  ]
+  pruneopts = "NUT"
+  revision = "50487e0f0b4842e9e657317e689fbb8209fab2dc"
+  version = "v1.6.2"
+
+[[projects]]
+  digest = "1:42e77b450df52dfaae5671aa2d7c60157462c11bfd4a9f12c7de64f7fe8210f3"
+  name = "github.com/libp2p/go-libp2p-host"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "726ec3240b7f9f3863f8c1cf16a311b8a2809321"
+  version = "v3.0.3"
+
+[[projects]]
+  digest = "1:7c1788589c33a2eb00c71f4e7e66af79329926a8e1e6e3ad191fb013f9af9ce8"
+  name = "github.com/libp2p/go-libp2p-interface-connmgr"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "073ebd06efc4cf6eb29b848686acf3e3bf4523e1"
+  version = "v0.0.10"
+
+[[projects]]
+  digest = "1:a8fdf63c574a7ab597869d573d8e4679df8bf15b5a3c0f8c2d8d94aaa77c3c04"
+  name = "github.com/libp2p/go-libp2p-interface-pnet"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3eda0a328422c06235501df5be481e4b51edc7cf"
+  version = "v3.0.0"
+
+[[projects]]
+  digest = "1:b7efd5fc79c4655f23c29a11f4fb9456361ec48b7fcf5b94b961c46849600b8d"
+  name = "github.com/libp2p/go-libp2p-loggables"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "face65f3d61355a5eb23ae2d470248fcf8739441"
+  version = "v1.1.17"
+
+[[projects]]
+  digest = "1:e924c683b1b344db26a7cdf7f78ba524fb7f800bfc7890d416993389e297367c"
+  name = "github.com/libp2p/go-libp2p-metrics"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "0d2c484aa7741e26eca0ea3da4957c8d3201de21"
+  version = "v2.1.2"
+
+[[projects]]
+  digest = "1:48ac35c23bfa58876cb904e2c5f26f1566dd6aeaf0683f892a40267f70b6b04a"
+  name = "github.com/libp2p/go-libp2p-nat"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "23f316f5e97e16e8926c66a848cbb06ca984760d"
+  version = "v0.8.3"
+
+[[projects]]
+  digest = "1:27ab07702dca6bb1063d287e8c027e2a965c4bd8161dee5410e0f695e5557e5b"
+  name = "github.com/libp2p/go-libp2p-net"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5833724d4c3273cba339482989a318396775b912"
+  version = "v3.0.4"
+
+[[projects]]
+  digest = "1:b5563eecdf54048763034ce7edb71b9303bc1fa1dbdd8a3b6ef63626e54e47a4"
+  name = "github.com/libp2p/go-libp2p-peer"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "a26c4b782bfe3b2570c539f69dc7777a45117a90"
+  version = "v2.3.5"
+
+[[projects]]
+  digest = "1:6d946c30b64bb521afcf0ba84c47265ce148a9a6d23cda6ab6a924c496d5bdef"
+  name = "github.com/libp2p/go-libp2p-peerstore"
+  packages = [
+    ".",
+    "addr",
+  ]
+  pruneopts = "NUT"
+  revision = "ccd2a0abe391ea27dac60308485adaa93a514cae"
+  version = "v1.4.21"
+
+[[projects]]
+  digest = "1:b8ddff56e9a25cdb2afe2daf04f9314deb52a651882043026da6603199c94266"
+  name = "github.com/libp2p/go-libp2p-protocol"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "e34f0d7468b3519bf9bf4e43c1d028ce651eab51"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:8a3205970742ff0c98673196c48ce1cdfe4689d5f8fbfddebf2a1eaa7038d3ea"
+  name = "github.com/libp2p/go-libp2p-secio"
+  packages = [
+    ".",
+    "pb",
+  ]
+  pruneopts = "NUT"
+  revision = "e4910f5adf3debfcd76f64efea6d1e3dd96756d4"
+  version = "v2.0.3"
+
+[[projects]]
+  digest = "1:ad45c74938c564aae0cd47fcc366a9333ff59f935c41b9a845ad372ff00cd3dc"
+  name = "github.com/libp2p/go-libp2p-swarm"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "f13bb386643a7e3a3777cf912ffa937eb97ac786"
+  version = "v3.0.4"
+
+[[projects]]
+  digest = "1:6650eb4c04054f1b7160815430667f7f9b9eee78a9bf517bd93bd2c6c55eaf87"
+  name = "github.com/libp2p/go-libp2p-transport"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3a76e545b272018a49ffece9e16b2c7bbb2ca55f"
+  version = "v3.0.4"
+
+[[projects]]
+  digest = "1:4e52545e938ae9b1369133ab0ec8d19e16ed41f76196852f97baea2bfe85405d"
+  name = "github.com/libp2p/go-libp2p-transport-upgrader"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "2616b5b8f5d02551b4f3f884e0b9b1a86aa05cf7"
+  version = "v0.1.3"
+
+[[projects]]
+  digest = "1:990bcec287ecc7484381356129585df572677d6201085687d3b137f838bd24a0"
+  name = "github.com/libp2p/go-maddr-filter"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "42d77c66758d30044bc76ce97d99d26ae22ffb73"
+  version = "v1.1.8"
+
+[[projects]]
+  digest = "1:73069a93eca496cfc3358ea26bf8ef991b48524493c841bc2c1670922a4e4bf2"
+  name = "github.com/libp2p/go-msgio"
+  packages = [
+    ".",
+    "mpool",
+  ]
+  pruneopts = "NUT"
+  revision = "fa984f54d57f20970aac9309a89a7ea40821f67c"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:5e6bdf53c9abb296dc7da21fc614860705f8521194df933a7aa1f75df1191f7a"
+  name = "github.com/libp2p/go-reuseport"
+  packages = [
+    ".",
+    "poll",
+    "singlepoll",
+  ]
+  pruneopts = "NUT"
+  revision = "2b9dda1feae6520af5cbfd0f8175569e5da925c7"
+  version = "v0.1.15"
+
+[[projects]]
+  digest = "1:592a6cc0401ddbec0f12605eddc1816247bfa4cbed0f96a1e08e845337f1e80b"
+  name = "github.com/libp2p/go-reuseport-transport"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "062d864ee432aa5158f91a4d13e75d319b062095"
+  version = "v0.1.7"
+
+[[projects]]
+  digest = "1:96eca00555fddc36f6d1dc6d5d47435005bf8a950e700afcd76508bde723bc0e"
+  name = "github.com/libp2p/go-sockaddr"
+  packages = ["net"]
+  pruneopts = "NUT"
+  revision = "5c3ac7e71ec1941a0c2ed4271535d9427feb829c"
+  version = "v1.0.3"
+
+[[projects]]
+  digest = "1:20ae4f4822b0320116c6eead75bafe87716617868cbb4f06cf223e495056f8c7"
+  name = "github.com/libp2p/go-stream-muxer"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "2ba231669cdd8d310277307dec6ced95a190c495"
+  version = "v3.0.1"
+
+[[projects]]
+  digest = "1:e606f57a9d6bddec54e0046f239e8605e395b0ffe11c3babb14d8d161b8c0ffe"
+  name = "github.com/libp2p/go-tcp-transport"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "b3201c58dfe88671fd1e93311776326337a21608"
+  version = "v2.0.3"
+
+[[projects]]
+  digest = "1:6c600ac5c29fc9b618eb0bea5df54c56076fefdc6c2675ab9687139e43c0fab5"
+  name = "github.com/libp2p/go-ws-transport"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "cfc76e292a6c80902669ff97a683c85562bed43a"
+  version = "v2.0.3"
+
 [[projects]]
   digest = "1:4953945f4fdc12cb7aa0263710534fb64b35a85e4047570fdf1cb03284055f0d"
   name = "github.com/mattn/go-colorable"
@@ -246,6 +619,80 @@
   pruneopts = "NUT"
   revision = "281032e84ae07510239465db46bf442aa44b953a"
 
+[[projects]]
+  branch = "master"
+  digest = "1:98484fb2302322e215bb28a39d44d74e0091a972517aa44b8525e329be15529d"
+  name = "github.com/minio/blake2b-simd"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3f5f724cb5b182a5c278d6d3d55b40e7f8c2efb4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:cf04232ab92b4e6344c71e8141fd843024a95295993a4dd2e04ef8e4baba2d0b"
+  name = "github.com/minio/sha256-simd"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "ad98a36ba0da87206e3378c556abbfeaeaa98668"
+
+[[projects]]
+  branch = "master"
+  digest = "1:b9b9f43a8a410d633e6547f89e830926741070941f2243d4d3a0bb154f565c9e"
+  name = "github.com/mr-tron/base58"
+  packages = ["base58"]
+  pruneopts = "NUT"
+  revision = "4df4dc6e86a912614d09719d10cad427b087cbfb"
+
+[[projects]]
+  digest = "1:24146ace1d6b7bddf7058273907d7c5b250d442059c704b34dea536b8120f387"
+  name = "github.com/multiformats/go-multiaddr"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "f36800afeb9c141e1adb7da099e6f010dfd4c419"
+
+[[projects]]
+  digest = "1:0cc11f5c48012da0af72f88c9e60ad48641cf1e6449a8159a3735550e8efb168"
+  name = "github.com/multiformats/go-multiaddr-dns"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "4c36f46414bba59a19ffe5154841f76d4a55b780"
+  version = "v0.2.3"
+
+[[projects]]
+  digest = "1:86512c9978e28c0fd20daa4273d526188ccc9c330b3f8c7d98eb40dce49b0896"
+  name = "github.com/multiformats/go-multiaddr-net"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "4d4b901d1729f55ee20cc0c8d8021aa58eb5ebe3"
+  version = "v1.6.2"
+
+[[projects]]
+  digest = "1:1b7b4b29b6d4928bfe5b11f2dde41d85458449584647d053d746f5fa2debcb77"
+  name = "github.com/multiformats/go-multihash"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "8be2a682ab9f254311de1375145a2f78a809b07d"
+
+[[projects]]
+  digest = "1:d43bc0dc998e3b8e6e15d79ef5974b1765aa20bb6a4a66cd7787eef859cbffda"
+  name = "github.com/multiformats/go-multistream"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "2b032632ecab1e1b98c8d2391a4f6ab9a6c9e140"
+  version = "v0.3.7"
+
+[[projects]]
+  digest = "1:7da29c22bcc5c2ffb308324377dc00b5084650348c2799e573ed226d8cc9faf0"
+  name = "github.com/opentracing/opentracing-go"
+  packages = [
+    ".",
+    "ext",
+    "log",
+  ]
+  pruneopts = "NUT"
+  revision = "1949ddbfd147afd4d964a9f00b24eb291e0e7c38"
+  version = "v1.0.2"
+
 [[projects]]
   digest = "1:cce3a18fb0b96b5015cd8ca03a57d20a662679de03c4dc4b6ff5f17ea2050fa6"
   name = "github.com/pborman/uuid"
@@ -289,7 +736,42 @@
   revision = "ed27b6fd65218132ee50cd95f38474a3d8a2cd12"
 
 [[projects]]
-  digest = "1:4af54ea5146ed59dbc4161a41044e396c1df4786eabe07858d2017e201348a8d"
+  digest = "1:8737b20e873c7cad069dfafd6382659b4cdf9e80359cdc159b8ec464893c932e"
+  name = "github.com/satori/go.uuid"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e"
+
+[[projects]]
+  digest = "1:96ea40e8fab1400b769ff9669dd7f7de613c3a1943dd7f451c4ccbb05115bcaa"
+  name = "github.com/spaolacci/murmur3"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9f5d223c60793748f04a9d5b4b4eacddfc1f755d"
+  version = "v1.1"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5d3c51d0f96ff0b228582e5e36295a33da8e16d106cd9dc31538096bd35dce1e"
+  name = "github.com/status-im/go-multiaddr-ethv4"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "17cb1ad76379d65e802eacc786d8f67eebd7cd6d"
+
+[[projects]]
+  branch = "master"
+  digest = "1:0a0848f018c29e4db5d941c2a8dbbbcaf1ea74f294c4759b69e8664b0a242040"
+  name = "github.com/status-im/rendezvous"
+  packages = [
+    ".",
+    "protocol",
+    "server",
+  ]
+  pruneopts = "NUT"
+  revision = "444e3eda4a281ca36d61df8a2a0832265d09511d"
+
+[[projects]]
+  digest = "1:572c783a763db6383aca3179976eb80e4c900f52eba56cba8bb2e3cea7ce720e"
   name = "github.com/stretchr/testify"
   packages = [
     "assert",
@@ -300,7 +782,7 @@
   revision = "890a5c3458b43e6104ff5da8dfa139d013d77544"
 
 [[projects]]
-  digest = "1:a86b5a41ef591cc6feb2f4f857776ad29d2ed6860e58865328ffd019021edeb9"
+  digest = "1:b18d044774f6ba5930c3fbf9958b2a9256c21f31dc50ecfa0622fe2a46608974"
   name = "github.com/syndtr/goleveldb"
   packages = [
     "leveldb",
@@ -321,12 +803,87 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:0110ddb0116668de78de6eb25f813bd0f39d21c14067e7d81dfe8653699599cf"
+  digest = "1:9237bfe664b67a1bc5787df18e48516b77442cb988912259b811865d654baafc"
+  name = "github.com/whyrusleeping/go-logging"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "0457bb6b88fc1973573aaf6b5145d8d3ae972390"
+
+[[projects]]
+  digest = "1:b5f5db18d8552caf68c36e19acd7f5b215e9e9ede195ff864d1787f2e1fbacf2"
+  name = "github.com/whyrusleeping/go-multiplex"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "efc13ba1d477b33bc316288f5d946fbad1afa8c2"
+  version = "v0.2.23"
+
+[[projects]]
+  branch = "master"
+  digest = "1:00ceb1bc58ee33818960b132008495b996aa093d49a734798fea4aa424c6b787"
+  name = "github.com/whyrusleeping/go-notifier"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "097c5d47330ff6a823f67e3515faa13566a62c6f"
+
+[[projects]]
+  digest = "1:ec33b10493e6f9ef9efeb0cb8cbb0a3e4acd5ebc53038010040f22f35f76762d"
+  name = "github.com/whyrusleeping/go-smux-multiplex"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "6c9914bb78b80e4e5947a43d27781b8863e19062"
+  version = "v3.0.10"
+
+[[projects]]
+  branch = "master"
+  digest = "1:034974ede3f03ded434d94543c753c7410b44f8232e0e7c4356c3d81d03d0feb"
+  name = "github.com/whyrusleeping/go-smux-multistream"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "c707bf3c25fa380b20b54907790efde288775938"
+
+[[projects]]
+  branch = "master"
+  digest = "1:90bc4b9a674e44590070d5469362b83ec64005d4454a1340b0c96b47c9e306a8"
+  name = "github.com/whyrusleeping/go-smux-yamux"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "eac25f3e2d47aae211e457e7664b52634c95eea8"
+
+[[projects]]
+  branch = "master"
+  digest = "1:f007f0475a929f645ed0c0ec392bad39f74931c79b2d905c994b3f4b8f0ccd86"
+  name = "github.com/whyrusleeping/mafmt"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "1dc32401ee9fdd3f6cdb3405ec984d5dae877b2a"
+
+[[projects]]
+  branch = "master"
+  digest = "1:7b014e573e2f4e3cf7bca9fa6e58629b957e5ea86d2a811126b60c6949ac7280"
+  name = "github.com/whyrusleeping/multiaddr-filter"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "e903e4adabd70b78bc9293b6ee4f359afb3f9f59"
+
+[[projects]]
+  branch = "master"
+  digest = "1:48348786b4372fd3a62b3c404d3359b619efb284bb7ff4a03ef3ad7222312ff1"
+  name = "github.com/whyrusleeping/yamux"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "35d045d4429ecf19430a2b94efc590bc40f2f7af"
+
+[[projects]]
+  branch = "master"
+  digest = "1:79bdbbb437f8640442f7d785772ac901fb546c4487f6b822bde082b52152f5c1"
   name = "golang.org/x/crypto"
   packages = [
+    "blake2s",
+    "blowfish",
     "pbkdf2",
     "ripemd160",
     "scrypt",
+    "sha3",
     "ssh/terminal",
   ]
   pruneopts = "NUT"
@@ -334,7 +891,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:e2a2c638c483e1a0091a1e547e930ce7ae4cf6cf2e39bd5003c61fd4bb5baf86"
+  digest = "1:b8f880e5062932f7b2ae4d4747d1dc1de12818156e3df80f7476f102dda15381"
   name = "golang.org/x/net"
   packages = [
     "bpf",
@@ -360,7 +917,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:a7802d6e6e6bd054706e5fe515a7469a4cb9a6465eb21252abfd84fc81a7f7c5"
+  digest = "1:13e050f402d48dc1e296490a9b354c78ab283e0f287531286ec08d33ad604067"
   name = "golang.org/x/sys"
   packages = [
     "unix",
@@ -371,7 +928,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:aab681e0af7f70e8a09f9778d182bac9fba9b88bc3920a0440583b6df0c9d709"
+  digest = "1:90acd68908852e1e1e68bfaed10bdf357252b041e619f6be6f159f6a015d1404"
   name = "golang.org/x/text"
   packages = [
     "encoding",
@@ -400,7 +957,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:b622ec8798492f8225ad6b03f942844c8aea43cf7748a3415763dd79332274c7"
+  digest = "1:95f24cc9a9a50da8aa144484a7c625c2e30dcbddf8e3bc336d2d92108b8c769e"
   name = "golang.org/x/tools"
   packages = [
     "go/ast/astutil",
@@ -490,13 +1047,18 @@
     "github.com/ethereum/go-ethereum/p2p",
     "github.com/ethereum/go-ethereum/p2p/discover",
     "github.com/ethereum/go-ethereum/p2p/discv5",
+    "github.com/ethereum/go-ethereum/p2p/enr",
     "github.com/ethereum/go-ethereum/p2p/nat",
     "github.com/ethereum/go-ethereum/params",
     "github.com/ethereum/go-ethereum/rlp",
     "github.com/ethereum/go-ethereum/rpc",
     "github.com/ethereum/go-ethereum/whisper/whisperv6",
     "github.com/golang/mock/gomock",
+    "github.com/libp2p/go-libp2p-crypto",
+    "github.com/multiformats/go-multiaddr",
     "github.com/pborman/uuid",
+    "github.com/status-im/rendezvous",
+    "github.com/status-im/rendezvous/server",
     "github.com/stretchr/testify/assert",
     "github.com/stretchr/testify/require",
     "github.com/stretchr/testify/suite",
diff --git a/Gopkg.toml b/Gopkg.toml
index 99451061f..157c1d481 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -134,3 +134,20 @@ ignored = [ "github.com/ethereum/go-ethereum/ethapi" ]
 [[constraint]]
   name = "github.com/beevik/ntp"
   version = "0.2.0"
+
+[[override]]
+  name = "github.com/multiformats/go-multiaddr"
+  revision = "f36800afeb9c141e1adb7da099e6f010dfd4c419"
+
+# 1.0.8
+[[override]]
+  name = "github.com/multiformats/go-multihash"
+  revision = "8be2a682ab9f254311de1375145a2f78a809b07d"
+
+[[override]]
+  name = "github.com/satori/go.uuid"
+  revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/status-im/rendezvous"
diff --git a/cmd/statusd/flags.go b/cmd/statusd/flags.go
new file mode 100644
index 000000000..3a6870d1b
--- /dev/null
+++ b/cmd/statusd/flags.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrorEmpty returned when value is empty.
+var ErrorEmpty = errors.New("empty value not allowed")
+
+// StringSlice is a type of flag that allows setting multiple string values.
+type StringSlice []string
+
+func (s *StringSlice) String() string {
+	return "string slice"
+}
+
+// Set trims space from string and stores it.
+func (s *StringSlice) Set(value string) error {
+	trimmed := strings.TrimSpace(value)
+	if len(trimmed) == 0 {
+		return ErrorEmpty
+	}
+	*s = append(*s, trimmed)
+	return nil
+}
diff --git a/cmd/statusd/main.go b/cmd/statusd/main.go
index ede00b5b6..da54e0b71 100644
--- a/cmd/statusd/main.go
+++ b/cmd/statusd/main.go
@@ -61,10 +61,12 @@ var (
 	logWithoutColors  = flag.Bool("log-without-color", false, "Disables log colors")
 	version           = flag.Bool("version", false, "Print version")
 
-	listenAddr = flag.String("listenaddr", ":30303", "IP address and port of this node (e.g. 127.0.0.1:30303)")
-	standalone = flag.Bool("standalone", true, "Don't actively connect to peers, wait for incoming connections")
-	bootnodes  = flag.String("bootnodes", "", "A list of bootnodes separated by comma")
-	discovery  = flag.Bool("discovery", false, "Enable discovery protocol")
+	listenAddr      = flag.String("listenaddr", ":30303", "IP address and port of this node (e.g. 127.0.0.1:30303)")
+	standalone      = flag.Bool("standalone", true, "Don't actively connect to peers, wait for incoming connections")
+	bootnodes       = flag.String("bootnodes", "", "A list of bootnodes separated by comma")
+	discoveryFlag   = flag.Bool("discovery", false, "Enable discovery protocol")
+	rendezvous      = flag.Bool("rendezvous", false, "Enable rendezvous protocol")
+	rendezvousNodes = StringSlice{}
 
 	// don't change the name of this flag, https://github.com/ethereum/go-ethereum/blob/master/metrics/metrics.go#L41
 	metrics = flag.Bool("metrics", false, "Expose ethereum metrics with debug_metrics jsonrpc call.")
@@ -95,6 +97,7 @@ var logger = log.New("package", "status-go/cmd/statusd")
 func main() {
 	flag.Var(&searchTopics, "topic.search", "Topic that will be searched in discovery v5, e.g (mailserver=1,1)")
 	flag.Var(&registerTopics, "topic.register", "Topic that will be registered using discovery v5.")
+	flag.Var(&rendezvousNodes, "rendezvous-node", "Rendezvous server.")
 
 	flag.Usage = printUsage
 	flag.Parse()
@@ -251,7 +254,9 @@ func makeNodeConfig() (*params.NodeConfig, error) {
 		nodeConfig.ClusterConfig.BootNodes = nil
 	}
 
-	nodeConfig.NoDiscovery = !(*discovery)
+	nodeConfig.ClusterConfig.RendezvousNodes = []string(rendezvousNodes)
+	nodeConfig.NoDiscovery = !(*discoveryFlag)
+	nodeConfig.Rendezvous = *rendezvous
 	nodeConfig.RequireTopics = map[discv5.Topic]params.Limits(searchTopics)
 	nodeConfig.RegisterTopics = []discv5.Topic(registerTopics)
 
diff --git a/discovery/discovery.go b/discovery/discovery.go
new file mode 100644
index 000000000..5110e3dc4
--- /dev/null
+++ b/discovery/discovery.go
@@ -0,0 +1,23 @@
+package discovery
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/p2p/discv5"
+)
+
+const (
+	// EthereumV5 is kademlia-based discovery from go-ethereum repository.
+	EthereumV5 = "ethv5"
+	// RendezvousV1 is req/rep based discovery that uses ENR for records.
+	RendezvousV1 = "ethvousv1"
+)
+
+// Discovery is an abstract interface for using different discovery providers.
+type Discovery interface {
+	Running() bool
+	Start() error
+	Stop() error
+	Register(topic string, stop chan struct{}) error
+	Discover(topic string, period <-chan time.Duration, found chan<- *discv5.Node, lookup chan<- bool) error
+}
diff --git a/peers/discv5.go b/discovery/discv5.go
similarity index 86%
rename from peers/discv5.go
rename to discovery/discv5.go
index 36ae159a4..6ffe1fa89 100644
--- a/peers/discv5.go
+++ b/discovery/discv5.go
@@ -1,4 +1,4 @@
-package peers
+package discovery
 
 import (
 	"crypto/ecdsa"
@@ -10,15 +10,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 )
 
-// Discovery is an abstract interface for using different discovery providers.
-type Discovery interface {
-	Running() bool
-	Start() error
-	Stop() error
-	Register(topic string, stop chan struct{}) error
-	Discover(topic string, period <-chan time.Duration, found chan<- *discv5.Node, lookup chan<- bool) error
-}
-
 // NewDiscV5 creates instances of discovery v5 facade.
 func NewDiscV5(prv *ecdsa.PrivateKey, laddr string, bootnodes []*discv5.Node) *DiscV5 {
 	return &DiscV5{
diff --git a/discovery/rendezvous.go b/discovery/rendezvous.go
new file mode 100644
index 000000000..9cb5dab82
--- /dev/null
+++ b/discovery/rendezvous.go
@@ -0,0 +1,160 @@
+package discovery
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"math/rand"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/p2p/discv5"
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/status-im/rendezvous"
+)
+
+const (
+	registrationPeriod = 10 * time.Second
+	bucketSize         = 10
+)
+
+func NewRendezvous(servers []ma.Multiaddr, identity *ecdsa.PrivateKey, node *discover.Node) (*Rendezvous, error) {
+	r := new(Rendezvous)
+	r.servers = servers
+	r.registrationPeriod = registrationPeriod
+	r.bucketSize = bucketSize
+
+	r.record = enr.Record{}
+	r.record.Set(enr.IP(node.IP))
+	r.record.Set(enr.TCP(node.TCP))
+	r.record.Set(enr.UDP(node.UDP))
+	// public key is added to ENR when ENR is signed
+	if err := enr.SignV4(&r.record, identity); err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+// Rendezvous is an implementation of discovery interface that uses
+// rendezvous client.
+type Rendezvous struct {
+	mu     sync.RWMutex
+	client *rendezvous.Client
+
+	servers            []ma.Multiaddr
+	registrationPeriod time.Duration
+	bucketSize         int
+	record             enr.Record
+}
+
+func (r *Rendezvous) Running() bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.client != nil
+}
+
+// Start creates client with ephemeral identity.
+func (r *Rendezvous) Start() error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	client, err := rendezvous.NewTemporary()
+	if err != nil {
+		return err
+	}
+	r.client = &client
+	return nil
+}
+
+// Stop removes client reference.
+func (r *Rendezvous) Stop() error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.client = nil
+	return nil
+}
+
+func (r *Rendezvous) register(topic string) {
+	srv := r.servers[rand.Intn(len(r.servers))]
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	defer cancel()
+	if err := r.client.Register(ctx, srv, topic, r.record); err != nil {
+		log.Debug("error registering", "topic", topic, "rendevous server", srv, "err", err)
+	}
+}
+
+// Register renews registration in the specified server.
+func (r *Rendezvous) Register(topic string, stop chan struct{}) error {
+	ticker := time.NewTicker(r.registrationPeriod)
+	defer ticker.Stop()
+	r.register(topic)
+	for {
+		select {
+		case <-stop:
+			return nil
+		case <-ticker.C:
+			r.register(topic)
+		}
+	}
+}
+
+// Discover will search for new records every time period fetched from period channel.
+func (r *Rendezvous) Discover(
+	topic string, period <-chan time.Duration,
+	found chan<- *discv5.Node, lookup chan<- bool) error {
+	ticker := time.NewTicker(<-period)
+	for {
+		select {
+		case newPeriod, ok := <-period:
+			ticker.Stop()
+			if !ok {
+				return nil
+			}
+			ticker = time.NewTicker(newPeriod)
+		case <-ticker.C:
+			srv := r.servers[rand.Intn(len(r.servers))]
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			r.mu.RLock()
+			records, err := r.client.Discover(ctx, srv, topic, r.bucketSize)
+			r.mu.RUnlock()
+			cancel()
+			if err != nil {
+				log.Debug("error fetching records", "topic", topic, "rendezvous server", srv, "err", err)
+				continue
+			}
+			for i := range records {
+				n, err := enrToNode(records[i])
+				if err != nil {
+					log.Warn("error converting enr record to node", "err", err)
+				}
+				found <- n
+			}
+		}
+	}
+}
+
+func enrToNode(record enr.Record) (*discv5.Node, error) {
+	var (
+		key   enr.Secp256k1
+		ip    enr.IP
+		tport enr.TCP
+		uport enr.UDP
+	)
+	if err := record.Load(&key); err != nil {
+		return nil, err
+	}
+	if err := record.Load(&ip); err != nil {
+		return nil, err
+	}
+	if err := record.Load(&tport); err != nil {
+		return nil, err
+	}
+	// ignore absence of udp port, as it is optional
+	_ = record.Load(&uport)
+	ecdsaKey := ecdsa.PublicKey(key)
+	return discv5.NewNode(discv5.PubkeyID(&ecdsaKey), net.IP(ip), uint16(uport), uint16(tport)), nil
+}
diff --git a/discovery/rendezvous_test.go b/discovery/rendezvous_test.go
new file mode 100644
index 000000000..c0a9bf54a
--- /dev/null
+++ b/discovery/rendezvous_test.go
@@ -0,0 +1,58 @@
+package discovery
+
+import (
+	"fmt"
+	"net"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/p2p/discv5"
+	lcrypto "github.com/libp2p/go-libp2p-crypto"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/status-im/rendezvous/server"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+)
+
+func TestRendezvousDiscovery(t *testing.T) {
+	priv, _, err := lcrypto.GenerateKeyPair(lcrypto.Secp256k1, 0)
+	require.NoError(t, err)
+	laddr, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/7777"))
+	require.NoError(t, err)
+	db, err := leveldb.Open(storage.NewMemStorage(), nil)
+	require.NoError(t, err)
+	srv := server.NewServer(laddr, priv, server.NewStorage(db))
+	require.NoError(t, srv.Start())
+
+	identity, err := crypto.GenerateKey()
+	require.NoError(t, err)
+	node := discover.NewNode(discover.PubkeyID(&identity.PublicKey), net.IP{10, 10, 10, 10}, 10, 20)
+	c, err := NewRendezvous([]ma.Multiaddr{srv.Addr()}, identity, node)
+	require.NoError(t, err)
+	require.NoError(t, c.Start())
+	require.True(t, c.Running())
+
+	topic := "test"
+	stop := make(chan struct{})
+	go func() { assert.NoError(t, c.Register(topic, stop)) }()
+
+	period := make(chan time.Duration, 1)
+	period <- 100 * time.Millisecond
+	found := make(chan *discv5.Node, 1)
+	lookup := make(chan bool)
+	go func() { assert.NoError(t, c.Discover(topic, period, found, lookup)) }()
+
+	select {
+	case n := <-found:
+		assert.Equal(t, discv5.PubkeyID(&identity.PublicKey), n.ID)
+	case <-time.After(10 * time.Second):
+		assert.Fail(t, "failed waiting to discover a node")
+	}
+	close(stop)
+	close(period)
+
+}
diff --git a/node/status_node.go b/node/status_node.go
index 242192ca1..d64e13c7d 100644
--- a/node/status_node.go
+++ b/node/status_node.go
@@ -17,9 +17,11 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
+	ma "github.com/multiformats/go-multiaddr"
 	"github.com/syndtr/goleveldb/leveldb"
 
 	"github.com/status-im/status-go/db"
+	"github.com/status-im/status-go/discovery"
 	"github.com/status-im/status-go/params"
 	"github.com/status-im/status-go/peers"
 	"github.com/status-im/status-go/rpc"
@@ -49,7 +51,7 @@ type StatusNode struct {
 	rpcClient        *rpc.Client        // reference to public RPC client
 	rpcPrivateClient *rpc.Client        // reference to private RPC client (can call private APIs)
 
-	discovery peers.Discovery
+	discovery discovery.Discovery
 	register  *peers.Register
 	peerPool  *peers.PeerPool
 	db        *leveldb.DB // used as a cache for PeerPool
@@ -179,14 +181,44 @@ func (n *StatusNode) setupRPCClient() (err error) {
 }
 
 func (n *StatusNode) discoveryEnabled() bool {
-	return n.config != nil && !n.config.NoDiscovery && n.config.ClusterConfig != nil
+	return n.config != nil && (!n.config.NoDiscovery || n.config.Rendezvous) && n.config.ClusterConfig != nil
+}
+
+func (n *StatusNode) startRendezvous() error {
+	if !n.config.Rendezvous {
+		return errors.New("rendezvous is not enabled")
+	}
+	if len(n.config.ClusterConfig.RendezvousNodes) == 0 {
+		return errors.New("rendezvous node must be provided if rendezvous discovery is enabled")
+	}
+	maddrs := make([]ma.Multiaddr, len(n.config.ClusterConfig.RendezvousNodes))
+	for i, addr := range n.config.ClusterConfig.RendezvousNodes {
+		var err error
+		maddrs[i], err = ma.NewMultiaddr(addr)
+		if err != nil {
+			return fmt.Errorf("failed to parse rendezvous node %s: %v", n.config.ClusterConfig.RendezvousNodes[0], err)
+		}
+	}
+	srv := n.gethNode.Server()
+	var err error
+	n.discovery, err = discovery.NewRendezvous(maddrs, srv.PrivateKey, srv.Self())
+	return err
 }
 
 func (n *StatusNode) startDiscovery() error {
-	n.discovery = peers.NewDiscV5(
-		n.gethNode.Server().PrivateKey,
-		n.config.ListenAddr,
-		parseNodesV5(n.config.ClusterConfig.BootNodes))
+	if !n.config.NoDiscovery && n.config.Rendezvous {
+		return errors.New("only one discovery can be used (will be allowed to use more in next change)")
+	}
+	if !n.config.NoDiscovery {
+		n.discovery = discovery.NewDiscV5(
+			n.gethNode.Server().PrivateKey,
+			n.config.ListenAddr,
+			parseNodesV5(n.config.ClusterConfig.BootNodes))
+	} else if n.config.Rendezvous {
+		if err := n.startRendezvous(); err != nil {
+			return err
+		}
+	}
 	n.register = peers.NewRegister(n.discovery, n.config.RegisterTopics...)
 	options := peers.NewDefaultOptions()
 	// TODO(dshulyak) consider adding a flag to define this behaviour
diff --git a/node/status_node_test.go b/node/status_node_test.go
index 243e8f12d..a6284f0ab 100644
--- a/node/status_node_test.go
+++ b/node/status_node_test.go
@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 
+	"github.com/status-im/status-go/discovery"
 	"github.com/status-im/status-go/params"
 	"github.com/status-im/status-go/t/helpers"
 	"github.com/stretchr/testify/require"
@@ -265,3 +266,20 @@ func isPeerConnected(node *StatusNode, peerURL string) (bool, error) {
 
 	return false, nil
 }
+
+func TestStatusNodeRendezvousDiscovery(t *testing.T) {
+	config := params.NodeConfig{
+		Rendezvous:  true,
+		NoDiscovery: true,
+		ClusterConfig: &params.ClusterConfig{
+			Enabled: true,
+			// not necessarily with id, just valid multiaddr
+			RendezvousNodes: []string{"/ip4/127.0.0.1/tcp/34012", "/ip4/127.0.0.1/tcp/34011"},
+		},
+	}
+	n := New()
+	require.NoError(t, n.Start(&config))
+	require.NotNil(t, n.discovery)
+	require.True(t, n.discovery.Running())
+	require.IsType(t, &discovery.Rendezvous{}, n.discovery)
+}
diff --git a/params/config.go b/params/config.go
index 1e53d5b64..c3499b7b9 100644
--- a/params/config.go
+++ b/params/config.go
@@ -196,6 +196,9 @@ type ClusterConfig struct {
 	// BootNodes list of cluster peer nodes for a given network (Mainnet, Ropsten, Rinkeby, Homestead),
 	// for a given mode (production vs development)
 	BootNodes []string
+
+	// RendezvousNodes is a rendezvous discovery server.
+	RendezvousNodes []string
 }
 
 // String dumps config object as nicely indented JSON
@@ -255,6 +258,9 @@ type NodeConfig struct {
 	// NoDiscovery set to true will disable discovery protocol.
 	NoDiscovery bool
 
+	// Rendezvous enables discovery protocol.
+	Rendezvous bool
+
 	// ListenAddr is an IP address and port of this node (e.g. 127.0.0.1:30303).
 	ListenAddr string
 
diff --git a/peers/cotopicpool_test.go b/peers/cotopicpool_test.go
index acb331c6b..a318f7df6 100644
--- a/peers/cotopicpool_test.go
+++ b/peers/cotopicpool_test.go
@@ -41,7 +41,7 @@ func (s *CacheOnlyTopicPoolSuite) SetupTest() {
 	limits := params.NewLimits(1, 2)
 	cache, err := newInMemoryCache()
 	s.Require().NoError(err)
-	t := newTopicPool(&DiscV5{}, MailServerDiscoveryTopic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
+	t := newTopicPool(nil, MailServerDiscoveryTopic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
 	s.topicPool = newCacheOnlyTopicPool(t)
 	s.topicPool.running = 1
 	// This is a buffered channel to simplify testing.
diff --git a/peers/peerpool.go b/peers/peerpool.go
index ff337ed2d..a4406e93c 100644
--- a/peers/peerpool.go
+++ b/peers/peerpool.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 
+	"github.com/status-im/status-go/discovery"
 	"github.com/status-im/status-go/params"
 	"github.com/status-im/status-go/signal"
 )
@@ -78,7 +79,7 @@ type peerInfo struct {
 type PeerPool struct {
 	opts *Options
 
-	discovery Discovery
+	discovery discovery.Discovery
 
 	// config can be set only once per pool life cycle
 	config map[discv5.Topic]params.Limits
@@ -95,7 +96,7 @@ type PeerPool struct {
 }
 
 // NewPeerPool creates instance of PeerPool
-func NewPeerPool(discovery Discovery, config map[discv5.Topic]params.Limits, cache *Cache, options *Options) *PeerPool {
+func NewPeerPool(discovery discovery.Discovery, config map[discv5.Topic]params.Limits, cache *Cache, options *Options) *PeerPool {
 	return &PeerPool{
 		opts:      options,
 		discovery: discovery,
diff --git a/peers/peerpool_test.go b/peers/peerpool_test.go
index 69d16e5db..c2c538074 100644
--- a/peers/peerpool_test.go
+++ b/peers/peerpool_test.go
@@ -14,10 +14,16 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 	"github.com/ethereum/go-ethereum/whisper/whisperv6"
+	lcrypto "github.com/libp2p/go-libp2p-crypto"
+	ma "github.com/multiformats/go-multiaddr"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/storage"
 
+	"github.com/status-im/rendezvous/server"
+	"github.com/status-im/status-go/discovery"
 	"github.com/status-im/status-go/params"
 	"github.com/status-im/status-go/signal"
 
@@ -28,10 +34,11 @@ import (
 type PeerPoolSimulationSuite struct {
 	suite.Suite
 
-	bootnode  *p2p.Server
-	peers     []*p2p.Server
-	discovery []Discovery
-	port      uint16
+	bootnode         *p2p.Server
+	peers            []*p2p.Server
+	discovery        []discovery.Discovery
+	port             uint16
+	rendezvousServer *server.Server
 }
 
 func TestPeerPoolSimulationSuite(t *testing.T) {
@@ -65,7 +72,7 @@ func (s *PeerPoolSimulationSuite) SetupTest() {
 
 	// 1 peer to initiate connection, 1 peer as a first candidate, 1 peer - for failover
 	s.peers = make([]*p2p.Server, 3)
-	s.discovery = make([]Discovery, 3)
+	s.discovery = make([]discovery.Discovery, 3)
 	for i := range s.peers {
 		key, _ := crypto.GenerateKey()
 		whisper := whisperv6.New(nil)
@@ -82,7 +89,31 @@ func (s *PeerPoolSimulationSuite) SetupTest() {
 		}
 		s.NoError(peer.Start())
 		s.peers[i] = peer
-		d := NewDiscV5(key, peer.ListenAddr, peer.BootstrapNodesV5)
+	}
+}
+
+func (s *PeerPoolSimulationSuite) setupEthV5() {
+	for i := range s.peers {
+		peer := s.peers[i]
+		d := discovery.NewDiscV5(peer.PrivateKey, peer.ListenAddr, peer.BootstrapNodesV5)
+		s.NoError(d.Start())
+		s.discovery[i] = d
+	}
+}
+
+func (s *PeerPoolSimulationSuite) setupRendezvous() {
+	priv, _, err := lcrypto.GenerateKeyPair(lcrypto.Secp256k1, 0)
+	s.Require().NoError(err)
+	laddr, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/7777"))
+	s.Require().NoError(err)
+	db, err := leveldb.Open(storage.NewMemStorage(), nil)
+	s.Require().NoError(err)
+	s.rendezvousServer = server.NewServer(laddr, priv, server.NewStorage(db))
+	s.Require().NoError(s.rendezvousServer.Start())
+	for i := range s.peers {
+		peer := s.peers[i]
+		d, err := discovery.NewRendezvous([]ma.Multiaddr{s.rendezvousServer.Addr()}, peer.PrivateKey, peer.Self())
+		s.NoError(err)
 		s.NoError(d.Start())
 		s.discovery[i] = d
 	}
@@ -94,6 +125,9 @@ func (s *PeerPoolSimulationSuite) TearDown() {
 		s.peers[i].Stop()
 		s.NoError(s.discovery[i].Stop())
 	}
+	if s.rendezvousServer != nil {
+		s.rendezvousServer.Stop()
+	}
 }
 
 func (s *PeerPoolSimulationSuite) getPeerFromEvent(events <-chan *p2p.PeerEvent, etype p2p.PeerEventType) (nodeID discover.NodeID) {
@@ -120,7 +154,8 @@ func (s *PeerPoolSimulationSuite) getPoolEvent(events <-chan string) string {
 	}
 }
 
-func (s *PeerPoolSimulationSuite) TestPeerPoolCache() {
+func (s *PeerPoolSimulationSuite) TestPeerPoolCacheEthV5() {
+	s.setupEthV5()
 	var err error
 
 	topic := discv5.Topic("cap=test")
@@ -143,11 +178,19 @@ func (s *PeerPoolSimulationSuite) TestPeerPoolCache() {
 	}
 }
 
-func (s *PeerPoolSimulationSuite) TestSingleTopicDiscoveryWithFailover() {
+func (s *PeerPoolSimulationSuite) TestSingleTopicDiscoveryWithFailoverEthV5() {
 	s.T().Skip("Skipping due to being flaky")
+	s.setupEthV5()
+	s.singleTopicDiscoveryWithFailover()
+}
 
+func (s *PeerPoolSimulationSuite) TestSingleTopicDiscoveryWithFailoverRendezvous() {
+	s.setupRendezvous()
+	s.singleTopicDiscoveryWithFailover()
+}
+
+func (s *PeerPoolSimulationSuite) singleTopicDiscoveryWithFailover() {
 	var err error
-
 	// Buffered channels must be used because we expect the events
 	// to be in the same order. Use a buffer length greater than
 	// the expected number of events to avoid deadlock.
@@ -254,7 +297,7 @@ func TestPeerPoolMaxPeersOverflow(t *testing.T) {
 	}
 	require.NoError(t, peer.Start())
 	defer peer.Stop()
-	discovery := NewDiscV5(key, peer.ListenAddr, nil)
+	discovery := discovery.NewDiscV5(key, peer.ListenAddr, nil)
 	require.NoError(t, discovery.Start())
 	defer func() { assert.NoError(t, discovery.Stop()) }()
 	require.True(t, discovery.Running())
@@ -306,7 +349,7 @@ func TestPeerPoolDiscV5Timeout(t *testing.T) {
 	require.NoError(t, server.Start())
 	defer server.Stop()
 
-	discovery := NewDiscV5(key, server.ListenAddr, nil)
+	discovery := discovery.NewDiscV5(key, server.ListenAddr, nil)
 	require.NoError(t, discovery.Start())
 	defer func() { assert.NoError(t, discovery.Stop()) }()
 	require.True(t, discovery.Running())
@@ -353,7 +396,7 @@ func TestPeerPoolNotAllowedStopping(t *testing.T) {
 	require.NoError(t, server.Start())
 	defer server.Stop()
 
-	discovery := NewDiscV5(key, server.ListenAddr, nil)
+	discovery := discovery.NewDiscV5(key, server.ListenAddr, nil)
 	require.NoError(t, discovery.Start())
 	defer func() { assert.NoError(t, discovery.Stop()) }()
 	require.True(t, discovery.Running())
@@ -369,6 +412,7 @@ func TestPeerPoolNotAllowedStopping(t *testing.T) {
 }
 
 func (s *PeerPoolSimulationSuite) TestUpdateTopicLimits() {
+	s.setupEthV5()
 	var err error
 
 	topic := discv5.Topic("cap=test")
diff --git a/peers/topic_register.go b/peers/topic_register.go
index 06c0ee1fc..cceb610d3 100644
--- a/peers/topic_register.go
+++ b/peers/topic_register.go
@@ -5,11 +5,12 @@ import (
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
+	"github.com/status-im/status-go/discovery"
 )
 
 // Register manages register topic queries
 type Register struct {
-	discovery Discovery
+	discovery discovery.Discovery
 	topics    []discv5.Topic
 
 	wg   sync.WaitGroup
@@ -17,7 +18,7 @@ type Register struct {
 }
 
 // NewRegister creates instance of topic register
-func NewRegister(discovery Discovery, topics ...discv5.Topic) *Register {
+func NewRegister(discovery discovery.Discovery, topics ...discv5.Topic) *Register {
 	return &Register{discovery: discovery, topics: topics}
 }
 
diff --git a/peers/topicpool.go b/peers/topicpool.go
index ea6b6b20f..11e9c7431 100644
--- a/peers/topicpool.go
+++ b/peers/topicpool.go
@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
+	"github.com/status-im/status-go/discovery"
 	"github.com/status-im/status-go/params"
 )
 
@@ -41,7 +42,7 @@ type TopicPoolInterface interface {
 }
 
 // newTopicPool returns instance of TopicPool.
-func newTopicPool(discovery Discovery, topic discv5.Topic, limits params.Limits, slowMode, fastMode time.Duration, cache *Cache) *TopicPool {
+func newTopicPool(discovery discovery.Discovery, topic discv5.Topic, limits params.Limits, slowMode, fastMode time.Duration, cache *Cache) *TopicPool {
 	pool := TopicPool{
 		discovery:            discovery,
 		topic:                topic,
@@ -62,7 +63,7 @@ func newTopicPool(discovery Discovery, topic discv5.Topic, limits params.Limits,
 
 // TopicPool manages peers for topic.
 type TopicPool struct {
-	discovery Discovery
+	discovery discovery.Discovery
 
 	// configuration
 	topic           discv5.Topic
diff --git a/peers/topicpool_test.go b/peers/topicpool_test.go
index 3b2470c23..aaa56ea98 100644
--- a/peers/topicpool_test.go
+++ b/peers/topicpool_test.go
@@ -42,7 +42,7 @@ func (s *TopicPoolSuite) SetupTest() {
 	limits := params.NewLimits(1, 2)
 	cache, err := newInMemoryCache()
 	s.Require().NoError(err)
-	s.topicPool = newTopicPool(&DiscV5{}, topic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
+	s.topicPool = newTopicPool(nil, topic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
 	s.topicPool.running = 1
 	// This is a buffered channel to simplify testing.
 	// If your test generates more than 10 mode changes,
@@ -321,10 +321,10 @@ func (s *TopicPoolSuite) TestNewTopicPoolInterface() {
 	s.Require().NoError(err)
 
 	topic := discv5.Topic("cap=cap1")
-	t := newTopicPool(&DiscV5{}, topic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
+	t := newTopicPool(nil, topic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
 	s.IsType(&TopicPool{}, t)
 
-	tp := newTopicPool(&DiscV5{}, MailServerDiscoveryTopic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
+	tp := newTopicPool(nil, MailServerDiscoveryTopic, limits, 100*time.Millisecond, 200*time.Millisecond, cache)
 	cacheTP := newCacheOnlyTopicPool(tp)
 	s.IsType(&cacheOnlyTopicPool{}, cacheTP)
 }
diff --git a/vendor/github.com/agl/ed25519/LICENSE b/vendor/github.com/agl/ed25519/LICENSE
new file mode 100644
index 000000000..744875676
--- /dev/null
+++ b/vendor/github.com/agl/ed25519/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/agl/ed25519/ed25519.go b/vendor/github.com/agl/ed25519/ed25519.go
new file mode 100644
index 000000000..e5f873f52
--- /dev/null
+++ b/vendor/github.com/agl/ed25519/ed25519.go
@@ -0,0 +1,127 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package ed25519 implements the Ed25519 signature algorithm. See
+// http://ed25519.cr.yp.to/.
+package ed25519
+
+// This code is a port of the public domain, "ref10" implementation of ed25519
+// from SUPERCOP.
+
+import (
+	"crypto/sha512"
+	"crypto/subtle"
+	"io"
+
+	"github.com/agl/ed25519/edwards25519"
+)
+
+const (
+	PublicKeySize  = 32
+	PrivateKeySize = 64
+	SignatureSize  = 64
+)
+
+// GenerateKey generates a public/private key pair using randomness from rand.
+func GenerateKey(rand io.Reader) (publicKey *[PublicKeySize]byte, privateKey *[PrivateKeySize]byte, err error) {
+	privateKey = new([64]byte)
+	publicKey = new([32]byte)
+	_, err = io.ReadFull(rand, privateKey[:32])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := sha512.New()
+	h.Write(privateKey[:32])
+	digest := h.Sum(nil)
+
+	digest[0] &= 248
+	digest[31] &= 127
+	digest[31] |= 64
+
+	var A edwards25519.ExtendedGroupElement
+	var hBytes [32]byte
+	copy(hBytes[:], digest)
+	edwards25519.GeScalarMultBase(&A, &hBytes)
+	A.ToBytes(publicKey)
+
+	copy(privateKey[32:], publicKey[:])
+	return
+}
+
+// Sign signs the message with privateKey and returns a signature.
+func Sign(privateKey *[PrivateKeySize]byte, message []byte) *[SignatureSize]byte {
+	h := sha512.New()
+	h.Write(privateKey[:32])
+
+	var digest1, messageDigest, hramDigest [64]byte
+	var expandedSecretKey [32]byte
+	h.Sum(digest1[:0])
+	copy(expandedSecretKey[:], digest1[:])
+	expandedSecretKey[0] &= 248
+	expandedSecretKey[31] &= 63
+	expandedSecretKey[31] |= 64
+
+	h.Reset()
+	h.Write(digest1[32:])
+	h.Write(message)
+	h.Sum(messageDigest[:0])
+
+	var messageDigestReduced [32]byte
+	edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
+	var R edwards25519.ExtendedGroupElement
+	edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
+
+	var encodedR [32]byte
+	R.ToBytes(&encodedR)
+
+	h.Reset()
+	h.Write(encodedR[:])
+	h.Write(privateKey[32:])
+	h.Write(message)
+	h.Sum(hramDigest[:0])
+	var hramDigestReduced [32]byte
+	edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
+
+	var s [32]byte
+	edwards25519.ScMulAdd(&s, &hramDigestReduced, &expandedSecretKey, &messageDigestReduced)
+
+	signature := new([64]byte)
+	copy(signature[:], encodedR[:])
+	copy(signature[32:], s[:])
+	return signature
+}
+
+// Verify returns true iff sig is a valid signature of message by publicKey.
+func Verify(publicKey *[PublicKeySize]byte, message []byte, sig *[SignatureSize]byte) bool {
+	if sig[63]&224 != 0 {
+		return false
+	}
+
+	var A edwards25519.ExtendedGroupElement
+	if !A.FromBytes(publicKey) {
+		return false
+	}
+	edwards25519.FeNeg(&A.X, &A.X)
+	edwards25519.FeNeg(&A.T, &A.T)
+
+	h := sha512.New()
+	h.Write(sig[:32])
+	h.Write(publicKey[:])
+	h.Write(message)
+	var digest [64]byte
+	h.Sum(digest[:0])
+
+	var hReduced [32]byte
+	edwards25519.ScReduce(&hReduced, &digest)
+
+	var R edwards25519.ProjectiveGroupElement
+	var b [32]byte
+	copy(b[:], sig[32:])
+	edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &b)
+
+	var checkR [32]byte
+	R.ToBytes(&checkR)
+	return subtle.ConstantTimeCompare(sig[:32], checkR[:]) == 1
+}
diff --git a/vendor/github.com/agl/ed25519/edwards25519/const.go b/vendor/github.com/agl/ed25519/edwards25519/const.go
new file mode 100644
index 000000000..ea5b77a71
--- /dev/null
+++ b/vendor/github.com/agl/ed25519/edwards25519/const.go
@@ -0,0 +1,1411 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package edwards25519
+
+var d = FieldElement{
+	-10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116,
+}
+
+var d2 = FieldElement{
+	-21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199,
+}
+
+var SqrtM1 = FieldElement{
+	-32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
+}
+
+var A = FieldElement{
+	486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+}
+
+var bi = [8]PreComputedGroupElement{
+	{
+		FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+		FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+		FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+	},
+	{
+		FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+		FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+		FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+	},
+	{
+		FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+		FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+		FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+	},
+	{
+		FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+		FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+		FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+	},
+	{
+		FieldElement{-22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877},
+		FieldElement{-6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951},
+		FieldElement{4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784},
+	},
+	{
+		FieldElement{-25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436},
+		FieldElement{25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918},
+		FieldElement{23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877},
+	},
+	{
+		FieldElement{-33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800},
+		FieldElement{-25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305},
+		FieldElement{-13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300},
+	},
+	{
+		FieldElement{-3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876},
+		FieldElement{-24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619},
+		FieldElement{-3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683},
+	},
+}
+
+var base = [32][8]PreComputedGroupElement{
+	{
+		{
+			FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
+			FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
+			FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
+		},
+		{
+			FieldElement{-12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303},
+			FieldElement{-21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081},
+			FieldElement{26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697},
+		},
+		{
+			FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
+			FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
+			FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
+		},
+		{
+			FieldElement{-17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540},
+			FieldElement{23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397},
+			FieldElement{7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325},
+		},
+		{
+			FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
+			FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
+			FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
+		},
+		{
+			FieldElement{-15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777},
+			FieldElement{-8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737},
+			FieldElement{-18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652},
+		},
+		{
+			FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
+			FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
+			FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
+		},
+		{
+			FieldElement{14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726},
+			FieldElement{-7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955},
+			FieldElement{27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425},
+		},
+	},
+	{
+		{
+			FieldElement{-13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171},
+			FieldElement{27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510},
+			FieldElement{17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660},
+		},
+		{
+			FieldElement{-10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639},
+			FieldElement{29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963},
+			FieldElement{5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950},
+		},
+		{
+			FieldElement{-27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568},
+			FieldElement{12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335},
+			FieldElement{25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628},
+		},
+		{
+			FieldElement{-26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007},
+			FieldElement{-2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772},
+			FieldElement{-22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653},
+		},
+		{
+			FieldElement{2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567},
+			FieldElement{13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686},
+			FieldElement{21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372},
+		},
+		{
+			FieldElement{-13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887},
+			FieldElement{-23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954},
+			FieldElement{-29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953},
+		},
+		{
+			FieldElement{24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833},
+			FieldElement{-16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532},
+			FieldElement{-22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876},
+		},
+		{
+			FieldElement{2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268},
+			FieldElement{33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214},
+			FieldElement{1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038},
+		},
+	},
+	{
+		{
+			FieldElement{6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800},
+			FieldElement{4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645},
+			FieldElement{-4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664},
+		},
+		{
+			FieldElement{1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933},
+			FieldElement{-25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182},
+			FieldElement{-17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222},
+		},
+		{
+			FieldElement{-18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991},
+			FieldElement{20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880},
+			FieldElement{9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092},
+		},
+		{
+			FieldElement{-16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295},
+			FieldElement{19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788},
+			FieldElement{8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553},
+		},
+		{
+			FieldElement{-15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026},
+			FieldElement{11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347},
+			FieldElement{-18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033},
+		},
+		{
+			FieldElement{-23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395},
+			FieldElement{-27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278},
+			FieldElement{1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890},
+		},
+		{
+			FieldElement{32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995},
+			FieldElement{-30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596},
+			FieldElement{-11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891},
+		},
+		{
+			FieldElement{31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060},
+			FieldElement{11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608},
+			FieldElement{-20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606},
+		},
+	},
+	{
+		{
+			FieldElement{7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389},
+			FieldElement{-19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016},
+			FieldElement{-11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341},
+		},
+		{
+			FieldElement{-22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505},
+			FieldElement{14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553},
+			FieldElement{-28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655},
+		},
+		{
+			FieldElement{15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220},
+			FieldElement{12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631},
+			FieldElement{-4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099},
+		},
+		{
+			FieldElement{26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556},
+			FieldElement{14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749},
+			FieldElement{236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930},
+		},
+		{
+			FieldElement{1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391},
+			FieldElement{5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253},
+			FieldElement{20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066},
+		},
+		{
+			FieldElement{24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958},
+			FieldElement{-11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082},
+			FieldElement{-28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383},
+		},
+		{
+			FieldElement{-30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521},
+			FieldElement{-11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807},
+			FieldElement{23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948},
+		},
+		{
+			FieldElement{9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134},
+			FieldElement{-32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455},
+			FieldElement{27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629},
+		},
+	},
+	{
+		{
+			FieldElement{-8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069},
+			FieldElement{-32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746},
+			FieldElement{24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919},
+		},
+		{
+			FieldElement{11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837},
+			FieldElement{8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906},
+			FieldElement{-28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771},
+		},
+		{
+			FieldElement{-25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817},
+			FieldElement{10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098},
+			FieldElement{10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409},
+		},
+		{
+			FieldElement{-12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504},
+			FieldElement{-26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727},
+			FieldElement{28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420},
+		},
+		{
+			FieldElement{-32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003},
+			FieldElement{-1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605},
+			FieldElement{-30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384},
+		},
+		{
+			FieldElement{-26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701},
+			FieldElement{-23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683},
+			FieldElement{29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708},
+		},
+		{
+			FieldElement{-3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563},
+			FieldElement{-19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260},
+			FieldElement{-5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387},
+		},
+		{
+			FieldElement{-19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672},
+			FieldElement{23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686},
+			FieldElement{-24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665},
+		},
+	},
+	{
+		{
+			FieldElement{11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182},
+			FieldElement{-31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277},
+			FieldElement{14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628},
+		},
+		{
+			FieldElement{-4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474},
+			FieldElement{-26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539},
+			FieldElement{-25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822},
+		},
+		{
+			FieldElement{-10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970},
+			FieldElement{19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756},
+			FieldElement{-24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508},
+		},
+		{
+			FieldElement{-26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683},
+			FieldElement{-10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655},
+			FieldElement{-20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158},
+		},
+		{
+			FieldElement{-4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125},
+			FieldElement{-15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839},
+			FieldElement{-20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664},
+		},
+		{
+			FieldElement{27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294},
+			FieldElement{-18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899},
+			FieldElement{-11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070},
+		},
+		{
+			FieldElement{3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294},
+			FieldElement{-15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949},
+			FieldElement{-21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083},
+		},
+		{
+			FieldElement{31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420},
+			FieldElement{-5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940},
+			FieldElement{29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396},
+		},
+	},
+	{
+		{
+			FieldElement{-12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567},
+			FieldElement{20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127},
+			FieldElement{-16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294},
+		},
+		{
+			FieldElement{-12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887},
+			FieldElement{22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964},
+			FieldElement{16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195},
+		},
+		{
+			FieldElement{9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244},
+			FieldElement{24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999},
+			FieldElement{-1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762},
+		},
+		{
+			FieldElement{-18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274},
+			FieldElement{-33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236},
+			FieldElement{-16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605},
+		},
+		{
+			FieldElement{-13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761},
+			FieldElement{-22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884},
+			FieldElement{-6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482},
+		},
+		{
+			FieldElement{-24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638},
+			FieldElement{-11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490},
+			FieldElement{-32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170},
+		},
+		{
+			FieldElement{5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736},
+			FieldElement{10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124},
+			FieldElement{-17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392},
+		},
+		{
+			FieldElement{8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029},
+			FieldElement{6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048},
+			FieldElement{28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958},
+		},
+	},
+	{
+		{
+			FieldElement{24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593},
+			FieldElement{26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071},
+			FieldElement{-11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692},
+		},
+		{
+			FieldElement{11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687},
+			FieldElement{-160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441},
+			FieldElement{-20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001},
+		},
+		{
+			FieldElement{-938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460},
+			FieldElement{-19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007},
+			FieldElement{-21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762},
+		},
+		{
+			FieldElement{15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005},
+			FieldElement{-9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674},
+			FieldElement{4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035},
+		},
+		{
+			FieldElement{7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590},
+			FieldElement{-2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957},
+			FieldElement{-30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812},
+		},
+		{
+			FieldElement{33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740},
+			FieldElement{-18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122},
+			FieldElement{-27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158},
+		},
+		{
+			FieldElement{8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885},
+			FieldElement{26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140},
+			FieldElement{19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857},
+		},
+		{
+			FieldElement{801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155},
+			FieldElement{19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260},
+			FieldElement{19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483},
+		},
+	},
+	{
+		{
+			FieldElement{-3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677},
+			FieldElement{32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815},
+			FieldElement{22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751},
+		},
+		{
+			FieldElement{-16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203},
+			FieldElement{-11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208},
+			FieldElement{1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230},
+		},
+		{
+			FieldElement{16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850},
+			FieldElement{-21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389},
+			FieldElement{-9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968},
+		},
+		{
+			FieldElement{-11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689},
+			FieldElement{14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880},
+			FieldElement{5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304},
+		},
+		{
+			FieldElement{30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632},
+			FieldElement{-3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412},
+			FieldElement{20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566},
+		},
+		{
+			FieldElement{-20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038},
+			FieldElement{-26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232},
+			FieldElement{-1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943},
+		},
+		{
+			FieldElement{17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856},
+			FieldElement{23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738},
+			FieldElement{15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971},
+		},
+		{
+			FieldElement{-27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718},
+			FieldElement{-13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697},
+			FieldElement{-11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883},
+		},
+	},
+	{
+		{
+			FieldElement{5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912},
+			FieldElement{-26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358},
+			FieldElement{3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849},
+		},
+		{
+			FieldElement{29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307},
+			FieldElement{-14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977},
+			FieldElement{-6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335},
+		},
+		{
+			FieldElement{-29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644},
+			FieldElement{-22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616},
+			FieldElement{-27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735},
+		},
+		{
+			FieldElement{-21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099},
+			FieldElement{29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341},
+			FieldElement{-936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336},
+		},
+		{
+			FieldElement{-23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646},
+			FieldElement{31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425},
+			FieldElement{-17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388},
+		},
+		{
+			FieldElement{-31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743},
+			FieldElement{-16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822},
+			FieldElement{-8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462},
+		},
+		{
+			FieldElement{18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985},
+			FieldElement{9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702},
+			FieldElement{-22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797},
+		},
+		{
+			FieldElement{21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293},
+			FieldElement{27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100},
+			FieldElement{19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688},
+		},
+	},
+	{
+		{
+			FieldElement{12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186},
+			FieldElement{2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610},
+			FieldElement{-2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707},
+		},
+		{
+			FieldElement{7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220},
+			FieldElement{915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025},
+			FieldElement{32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044},
+		},
+		{
+			FieldElement{32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992},
+			FieldElement{-4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027},
+			FieldElement{21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197},
+		},
+		{
+			FieldElement{8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901},
+			FieldElement{31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952},
+			FieldElement{19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878},
+		},
+		{
+			FieldElement{-28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390},
+			FieldElement{32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730},
+			FieldElement{2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730},
+		},
+		{
+			FieldElement{-19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180},
+			FieldElement{-30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272},
+			FieldElement{-15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715},
+		},
+		{
+			FieldElement{-22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970},
+			FieldElement{-31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772},
+			FieldElement{-17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865},
+		},
+		{
+			FieldElement{15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750},
+			FieldElement{20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373},
+			FieldElement{32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348},
+		},
+	},
+	{
+		{
+			FieldElement{9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144},
+			FieldElement{-22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195},
+			FieldElement{5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086},
+		},
+		{
+			FieldElement{-13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684},
+			FieldElement{-8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518},
+			FieldElement{-2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233},
+		},
+		{
+			FieldElement{-5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793},
+			FieldElement{-2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794},
+			FieldElement{580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435},
+		},
+		{
+			FieldElement{23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921},
+			FieldElement{13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518},
+			FieldElement{2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563},
+		},
+		{
+			FieldElement{14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278},
+			FieldElement{-27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024},
+			FieldElement{4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030},
+		},
+		{
+			FieldElement{10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783},
+			FieldElement{27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717},
+			FieldElement{6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844},
+		},
+		{
+			FieldElement{14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333},
+			FieldElement{16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048},
+			FieldElement{22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760},
+		},
+		{
+			FieldElement{-4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760},
+			FieldElement{-15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757},
+			FieldElement{-2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112},
+		},
+	},
+	{
+		{
+			FieldElement{-19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468},
+			FieldElement{3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184},
+			FieldElement{10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289},
+		},
+		{
+			FieldElement{15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066},
+			FieldElement{24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882},
+			FieldElement{13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226},
+		},
+		{
+			FieldElement{16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101},
+			FieldElement{29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279},
+			FieldElement{-6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811},
+		},
+		{
+			FieldElement{27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709},
+			FieldElement{20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714},
+			FieldElement{-2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121},
+		},
+		{
+			FieldElement{9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464},
+			FieldElement{12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847},
+			FieldElement{13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400},
+		},
+		{
+			FieldElement{4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414},
+			FieldElement{-15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158},
+			FieldElement{17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045},
+		},
+		{
+			FieldElement{-461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415},
+			FieldElement{-5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459},
+			FieldElement{-31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079},
+		},
+		{
+			FieldElement{21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412},
+			FieldElement{-20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743},
+			FieldElement{-14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836},
+		},
+	},
+	{
+		{
+			FieldElement{12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022},
+			FieldElement{18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429},
+			FieldElement{-6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065},
+		},
+		{
+			FieldElement{30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861},
+			FieldElement{10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000},
+			FieldElement{-33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101},
+		},
+		{
+			FieldElement{32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815},
+			FieldElement{29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642},
+			FieldElement{10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966},
+		},
+		{
+			FieldElement{25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574},
+			FieldElement{-21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742},
+			FieldElement{-18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689},
+		},
+		{
+			FieldElement{12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020},
+			FieldElement{-10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772},
+			FieldElement{3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982},
+		},
+		{
+			FieldElement{-14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953},
+			FieldElement{-16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218},
+			FieldElement{-17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265},
+		},
+		{
+			FieldElement{29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073},
+			FieldElement{-3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325},
+			FieldElement{-11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798},
+		},
+		{
+			FieldElement{-4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870},
+			FieldElement{-7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863},
+			FieldElement{-13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927},
+		},
+	},
+	{
+		{
+			FieldElement{-2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267},
+			FieldElement{-9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663},
+			FieldElement{22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862},
+		},
+		{
+			FieldElement{-25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673},
+			FieldElement{15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943},
+			FieldElement{15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020},
+		},
+		{
+			FieldElement{-4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238},
+			FieldElement{11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064},
+			FieldElement{14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795},
+		},
+		{
+			FieldElement{15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052},
+			FieldElement{-10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904},
+			FieldElement{29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531},
+		},
+		{
+			FieldElement{-13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979},
+			FieldElement{-5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841},
+			FieldElement{10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431},
+		},
+		{
+			FieldElement{10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324},
+			FieldElement{-31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940},
+			FieldElement{10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320},
+		},
+		{
+			FieldElement{-15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184},
+			FieldElement{14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114},
+			FieldElement{30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878},
+		},
+		{
+			FieldElement{12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784},
+			FieldElement{-2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091},
+			FieldElement{-16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585},
+		},
+	},
+	{
+		{
+			FieldElement{-8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208},
+			FieldElement{10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864},
+			FieldElement{17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661},
+		},
+		{
+			FieldElement{7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233},
+			FieldElement{26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212},
+			FieldElement{-12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525},
+		},
+		{
+			FieldElement{-24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068},
+			FieldElement{9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397},
+			FieldElement{-8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988},
+		},
+		{
+			FieldElement{5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889},
+			FieldElement{32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038},
+			FieldElement{14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697},
+		},
+		{
+			FieldElement{20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875},
+			FieldElement{-25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905},
+			FieldElement{-25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656},
+		},
+		{
+			FieldElement{11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818},
+			FieldElement{27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714},
+			FieldElement{10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203},
+		},
+		{
+			FieldElement{20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931},
+			FieldElement{-30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024},
+			FieldElement{-23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084},
+		},
+		{
+			FieldElement{-1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204},
+			FieldElement{20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817},
+			FieldElement{27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667},
+		},
+	},
+	{
+		{
+			FieldElement{11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504},
+			FieldElement{-12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768},
+			FieldElement{-19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255},
+		},
+		{
+			FieldElement{6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790},
+			FieldElement{1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438},
+			FieldElement{-22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333},
+		},
+		{
+			FieldElement{17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971},
+			FieldElement{31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905},
+			FieldElement{29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409},
+		},
+		{
+			FieldElement{12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409},
+			FieldElement{6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499},
+			FieldElement{-8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363},
+		},
+		{
+			FieldElement{28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664},
+			FieldElement{-11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324},
+			FieldElement{-21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940},
+		},
+		{
+			FieldElement{13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990},
+			FieldElement{-17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914},
+			FieldElement{-25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290},
+		},
+		{
+			FieldElement{24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257},
+			FieldElement{-6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433},
+			FieldElement{-16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236},
+		},
+		{
+			FieldElement{-12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045},
+			FieldElement{11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093},
+			FieldElement{-1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347},
+		},
+	},
+	{
+		{
+			FieldElement{-28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191},
+			FieldElement{-15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507},
+			FieldElement{-12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906},
+		},
+		{
+			FieldElement{3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018},
+			FieldElement{-16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109},
+			FieldElement{-23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926},
+		},
+		{
+			FieldElement{-24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528},
+			FieldElement{8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625},
+			FieldElement{-32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286},
+		},
+		{
+			FieldElement{2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033},
+			FieldElement{27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866},
+			FieldElement{21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896},
+		},
+		{
+			FieldElement{30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075},
+			FieldElement{26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347},
+			FieldElement{-22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437},
+		},
+		{
+			FieldElement{-5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165},
+			FieldElement{-18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588},
+			FieldElement{-32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193},
+		},
+		{
+			FieldElement{-19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017},
+			FieldElement{-28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883},
+			FieldElement{21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961},
+		},
+		{
+			FieldElement{8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043},
+			FieldElement{29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663},
+			FieldElement{-20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362},
+		},
+	},
+	{
+		{
+			FieldElement{-33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860},
+			FieldElement{2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466},
+			FieldElement{-24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063},
+		},
+		{
+			FieldElement{-26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997},
+			FieldElement{-1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295},
+			FieldElement{-13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369},
+		},
+		{
+			FieldElement{9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385},
+			FieldElement{18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109},
+			FieldElement{2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906},
+		},
+		{
+			FieldElement{4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424},
+			FieldElement{-19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185},
+			FieldElement{7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962},
+		},
+		{
+			FieldElement{-7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325},
+			FieldElement{10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593},
+			FieldElement{696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404},
+		},
+		{
+			FieldElement{-11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644},
+			FieldElement{17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801},
+			FieldElement{26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804},
+		},
+		{
+			FieldElement{-31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884},
+			FieldElement{-586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577},
+			FieldElement{-9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849},
+		},
+		{
+			FieldElement{32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473},
+			FieldElement{-8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644},
+			FieldElement{-2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319},
+		},
+	},
+	{
+		{
+			FieldElement{-11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599},
+			FieldElement{-9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768},
+			FieldElement{-27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084},
+		},
+		{
+			FieldElement{-27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328},
+			FieldElement{-15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369},
+			FieldElement{20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920},
+		},
+		{
+			FieldElement{12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815},
+			FieldElement{-32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025},
+			FieldElement{-21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397},
+		},
+		{
+			FieldElement{-20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448},
+			FieldElement{6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981},
+			FieldElement{30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165},
+		},
+		{
+			FieldElement{32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501},
+			FieldElement{17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073},
+			FieldElement{-1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861},
+		},
+		{
+			FieldElement{14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845},
+			FieldElement{-1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211},
+			FieldElement{18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870},
+		},
+		{
+			FieldElement{10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096},
+			FieldElement{33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803},
+			FieldElement{-32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168},
+		},
+		{
+			FieldElement{30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965},
+			FieldElement{-14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505},
+			FieldElement{18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598},
+		},
+	},
+	{
+		{
+			FieldElement{5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782},
+			FieldElement{5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900},
+			FieldElement{-31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479},
+		},
+		{
+			FieldElement{-12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208},
+			FieldElement{8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232},
+			FieldElement{17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719},
+		},
+		{
+			FieldElement{16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271},
+			FieldElement{-4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326},
+			FieldElement{-8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132},
+		},
+		{
+			FieldElement{14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300},
+			FieldElement{8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570},
+			FieldElement{15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670},
+		},
+		{
+			FieldElement{-2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994},
+			FieldElement{-12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913},
+			FieldElement{31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317},
+		},
+		{
+			FieldElement{-25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730},
+			FieldElement{842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096},
+			FieldElement{-4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078},
+		},
+		{
+			FieldElement{-15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411},
+			FieldElement{-19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905},
+			FieldElement{-9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654},
+		},
+		{
+			FieldElement{-28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870},
+			FieldElement{-23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498},
+			FieldElement{12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579},
+		},
+	},
+	{
+		{
+			FieldElement{14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677},
+			FieldElement{10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647},
+			FieldElement{-2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743},
+		},
+		{
+			FieldElement{-25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468},
+			FieldElement{21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375},
+			FieldElement{-25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155},
+		},
+		{
+			FieldElement{6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725},
+			FieldElement{-12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612},
+			FieldElement{-10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943},
+		},
+		{
+			FieldElement{-30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944},
+			FieldElement{30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928},
+			FieldElement{9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406},
+		},
+		{
+			FieldElement{22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139},
+			FieldElement{-8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963},
+			FieldElement{-31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693},
+		},
+		{
+			FieldElement{1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734},
+			FieldElement{-448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680},
+			FieldElement{-24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410},
+		},
+		{
+			FieldElement{-9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931},
+			FieldElement{-16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654},
+			FieldElement{22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710},
+		},
+		{
+			FieldElement{29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180},
+			FieldElement{-26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684},
+			FieldElement{-10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895},
+		},
+	},
+	{
+		{
+			FieldElement{22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501},
+			FieldElement{-11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413},
+			FieldElement{6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880},
+		},
+		{
+			FieldElement{-8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874},
+			FieldElement{22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962},
+			FieldElement{-7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899},
+		},
+		{
+			FieldElement{21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152},
+			FieldElement{9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063},
+			FieldElement{7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080},
+		},
+		{
+			FieldElement{-9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146},
+			FieldElement{-17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183},
+			FieldElement{-19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133},
+		},
+		{
+			FieldElement{-32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421},
+			FieldElement{-3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622},
+			FieldElement{-4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197},
+		},
+		{
+			FieldElement{2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663},
+			FieldElement{31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753},
+			FieldElement{4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755},
+		},
+		{
+			FieldElement{-9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862},
+			FieldElement{-26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118},
+			FieldElement{26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171},
+		},
+		{
+			FieldElement{15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380},
+			FieldElement{16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824},
+			FieldElement{28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270},
+		},
+	},
+	{
+		{
+			FieldElement{-817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438},
+			FieldElement{-31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584},
+			FieldElement{-594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562},
+		},
+		{
+			FieldElement{30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471},
+			FieldElement{18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610},
+			FieldElement{19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269},
+		},
+		{
+			FieldElement{-30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650},
+			FieldElement{14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369},
+			FieldElement{19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461},
+		},
+		{
+			FieldElement{30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462},
+			FieldElement{-5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793},
+			FieldElement{-2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218},
+		},
+		{
+			FieldElement{-24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226},
+			FieldElement{18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019},
+			FieldElement{-15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037},
+		},
+		{
+			FieldElement{31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171},
+			FieldElement{-17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132},
+			FieldElement{-28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841},
+		},
+		{
+			FieldElement{21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181},
+			FieldElement{-33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210},
+			FieldElement{-1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040},
+		},
+		{
+			FieldElement{3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935},
+			FieldElement{24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105},
+			FieldElement{-28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814},
+		},
+	},
+	{
+		{
+			FieldElement{793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852},
+			FieldElement{5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581},
+			FieldElement{-4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646},
+		},
+		{
+			FieldElement{10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844},
+			FieldElement{10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025},
+			FieldElement{27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453},
+		},
+		{
+			FieldElement{-23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068},
+			FieldElement{4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192},
+			FieldElement{-17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921},
+		},
+		{
+			FieldElement{-9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259},
+			FieldElement{-12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426},
+			FieldElement{-5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072},
+		},
+		{
+			FieldElement{-17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305},
+			FieldElement{13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832},
+			FieldElement{28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943},
+		},
+		{
+			FieldElement{-16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011},
+			FieldElement{24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447},
+			FieldElement{17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494},
+		},
+		{
+			FieldElement{-28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245},
+			FieldElement{-20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859},
+			FieldElement{28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915},
+		},
+		{
+			FieldElement{16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707},
+			FieldElement{10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848},
+			FieldElement{-11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224},
+		},
+	},
+	{
+		{
+			FieldElement{-25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391},
+			FieldElement{15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215},
+			FieldElement{-23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101},
+		},
+		{
+			FieldElement{23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713},
+			FieldElement{21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849},
+			FieldElement{-7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930},
+		},
+		{
+			FieldElement{-29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940},
+			FieldElement{-21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031},
+			FieldElement{-17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404},
+		},
+		{
+			FieldElement{-25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243},
+			FieldElement{-23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116},
+			FieldElement{-24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525},
+		},
+		{
+			FieldElement{-23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509},
+			FieldElement{-10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883},
+			FieldElement{15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865},
+		},
+		{
+			FieldElement{-3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660},
+			FieldElement{4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273},
+			FieldElement{-28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138},
+		},
+		{
+			FieldElement{-25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560},
+			FieldElement{-10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135},
+			FieldElement{2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941},
+		},
+		{
+			FieldElement{-4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739},
+			FieldElement{18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756},
+			FieldElement{-30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819},
+		},
+	},
+	{
+		{
+			FieldElement{-6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347},
+			FieldElement{-27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028},
+			FieldElement{21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075},
+		},
+		{
+			FieldElement{16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799},
+			FieldElement{-2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609},
+			FieldElement{-25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817},
+		},
+		{
+			FieldElement{-23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989},
+			FieldElement{-30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523},
+			FieldElement{4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278},
+		},
+		{
+			FieldElement{31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045},
+			FieldElement{19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377},
+			FieldElement{24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480},
+		},
+		{
+			FieldElement{17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016},
+			FieldElement{510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426},
+			FieldElement{18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525},
+		},
+		{
+			FieldElement{13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396},
+			FieldElement{9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080},
+			FieldElement{12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892},
+		},
+		{
+			FieldElement{15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275},
+			FieldElement{11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074},
+			FieldElement{20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140},
+		},
+		{
+			FieldElement{-16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717},
+			FieldElement{-1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101},
+			FieldElement{24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127},
+		},
+	},
+	{
+		{
+			FieldElement{-12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632},
+			FieldElement{-26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415},
+			FieldElement{-31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160},
+		},
+		{
+			FieldElement{31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876},
+			FieldElement{22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625},
+			FieldElement{-15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478},
+		},
+		{
+			FieldElement{27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164},
+			FieldElement{26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595},
+			FieldElement{-7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248},
+		},
+		{
+			FieldElement{-16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858},
+			FieldElement{15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193},
+			FieldElement{8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184},
+		},
+		{
+			FieldElement{-18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942},
+			FieldElement{-1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635},
+			FieldElement{21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948},
+		},
+		{
+			FieldElement{11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935},
+			FieldElement{-25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415},
+			FieldElement{-15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416},
+		},
+		{
+			FieldElement{-7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018},
+			FieldElement{4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778},
+			FieldElement{366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659},
+		},
+		{
+			FieldElement{-24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385},
+			FieldElement{18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503},
+			FieldElement{476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329},
+		},
+	},
+	{
+		{
+			FieldElement{20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056},
+			FieldElement{-13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838},
+			FieldElement{24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948},
+		},
+		{
+			FieldElement{-3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691},
+			FieldElement{-15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118},
+			FieldElement{-23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517},
+		},
+		{
+			FieldElement{-20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269},
+			FieldElement{-6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904},
+			FieldElement{-23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589},
+		},
+		{
+			FieldElement{-28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193},
+			FieldElement{-7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910},
+			FieldElement{-30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930},
+		},
+		{
+			FieldElement{-7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667},
+			FieldElement{25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481},
+			FieldElement{-9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876},
+		},
+		{
+			FieldElement{22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640},
+			FieldElement{-8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278},
+			FieldElement{-21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112},
+		},
+		{
+			FieldElement{26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272},
+			FieldElement{17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012},
+			FieldElement{-10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221},
+		},
+		{
+			FieldElement{30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046},
+			FieldElement{13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345},
+			FieldElement{-19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310},
+		},
+	},
+	{
+		{
+			FieldElement{19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937},
+			FieldElement{31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636},
+			FieldElement{-9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008},
+		},
+		{
+			FieldElement{-2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429},
+			FieldElement{-15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576},
+			FieldElement{31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066},
+		},
+		{
+			FieldElement{-9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490},
+			FieldElement{-12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104},
+			FieldElement{33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053},
+		},
+		{
+			FieldElement{31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275},
+			FieldElement{-20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511},
+			FieldElement{22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095},
+		},
+		{
+			FieldElement{-28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439},
+			FieldElement{23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939},
+			FieldElement{-23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424},
+		},
+		{
+			FieldElement{2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310},
+			FieldElement{3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608},
+			FieldElement{-32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079},
+		},
+		{
+			FieldElement{-23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101},
+			FieldElement{21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418},
+			FieldElement{18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576},
+		},
+		{
+			FieldElement{30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356},
+			FieldElement{9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996},
+			FieldElement{-26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099},
+		},
+	},
+	{
+		{
+			FieldElement{-26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728},
+			FieldElement{-13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658},
+			FieldElement{-10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242},
+		},
+		{
+			FieldElement{-21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001},
+			FieldElement{-4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766},
+			FieldElement{18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373},
+		},
+		{
+			FieldElement{26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458},
+			FieldElement{-17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628},
+			FieldElement{-13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657},
+		},
+		{
+			FieldElement{-23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062},
+			FieldElement{25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616},
+			FieldElement{31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014},
+		},
+		{
+			FieldElement{24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383},
+			FieldElement{-25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814},
+			FieldElement{-20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718},
+		},
+		{
+			FieldElement{30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417},
+			FieldElement{2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222},
+			FieldElement{33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444},
+		},
+		{
+			FieldElement{-20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597},
+			FieldElement{23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970},
+			FieldElement{1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799},
+		},
+		{
+			FieldElement{-5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647},
+			FieldElement{13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511},
+			FieldElement{-29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032},
+		},
+	},
+	{
+		{
+			FieldElement{9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834},
+			FieldElement{-23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461},
+			FieldElement{29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062},
+		},
+		{
+			FieldElement{-25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516},
+			FieldElement{-20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547},
+			FieldElement{-24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240},
+		},
+		{
+			FieldElement{-17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038},
+			FieldElement{-33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741},
+			FieldElement{16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103},
+		},
+		{
+			FieldElement{-19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747},
+			FieldElement{-1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323},
+			FieldElement{31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016},
+		},
+		{
+			FieldElement{-14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373},
+			FieldElement{15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228},
+			FieldElement{-2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141},
+		},
+		{
+			FieldElement{16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399},
+			FieldElement{11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831},
+			FieldElement{-185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376},
+		},
+		{
+			FieldElement{-32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313},
+			FieldElement{-18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958},
+			FieldElement{-6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577},
+		},
+		{
+			FieldElement{-22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743},
+			FieldElement{29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684},
+			FieldElement{-20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476},
+		},
+	},
+}
diff --git a/vendor/github.com/agl/ed25519/edwards25519/edwards25519.go b/vendor/github.com/agl/ed25519/edwards25519/edwards25519.go
new file mode 100644
index 000000000..907981855
--- /dev/null
+++ b/vendor/github.com/agl/ed25519/edwards25519/edwards25519.go
@@ -0,0 +1,1773 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package edwards25519 implements operations in GF(2**255-19) and on an
+// Edwards curve that is isomorphic to curve25519. See
+// http://ed25519.cr.yp.to/.
+package edwards25519
+
+// This code is a port of the public domain, "ref10" implementation of ed25519
+// from SUPERCOP.
+
+// FieldElement represents an element of the field GF(2^255 - 19).  An element
+// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
+// t[3]+2^102 t[4]+...+2^230 t[9].  Bounds on each t[i] vary depending on
+// context.
+type FieldElement [10]int32
+
+var zero FieldElement
+
+func FeZero(fe *FieldElement) {
+	copy(fe[:], zero[:])
+}
+
+func FeOne(fe *FieldElement) {
+	FeZero(fe)
+	fe[0] = 1
+}
+
+func FeAdd(dst, a, b *FieldElement) {
+	dst[0] = a[0] + b[0]
+	dst[1] = a[1] + b[1]
+	dst[2] = a[2] + b[2]
+	dst[3] = a[3] + b[3]
+	dst[4] = a[4] + b[4]
+	dst[5] = a[5] + b[5]
+	dst[6] = a[6] + b[6]
+	dst[7] = a[7] + b[7]
+	dst[8] = a[8] + b[8]
+	dst[9] = a[9] + b[9]
+}
+
+func FeSub(dst, a, b *FieldElement) {
+	dst[0] = a[0] - b[0]
+	dst[1] = a[1] - b[1]
+	dst[2] = a[2] - b[2]
+	dst[3] = a[3] - b[3]
+	dst[4] = a[4] - b[4]
+	dst[5] = a[5] - b[5]
+	dst[6] = a[6] - b[6]
+	dst[7] = a[7] - b[7]
+	dst[8] = a[8] - b[8]
+	dst[9] = a[9] - b[9]
+}
+
+func FeCopy(dst, src *FieldElement) {
+	copy(dst[:], src[:])
+}
+
+// Replace (f,g) with (g,g) if b == 1;
+// replace (f,g) with (f,g) if b == 0.
+//
+// Preconditions: b in {0,1}.
+func FeCMove(f, g *FieldElement, b int32) {
+	b = -b
+	f[0] ^= b & (f[0] ^ g[0])
+	f[1] ^= b & (f[1] ^ g[1])
+	f[2] ^= b & (f[2] ^ g[2])
+	f[3] ^= b & (f[3] ^ g[3])
+	f[4] ^= b & (f[4] ^ g[4])
+	f[5] ^= b & (f[5] ^ g[5])
+	f[6] ^= b & (f[6] ^ g[6])
+	f[7] ^= b & (f[7] ^ g[7])
+	f[8] ^= b & (f[8] ^ g[8])
+	f[9] ^= b & (f[9] ^ g[9])
+}
+
+func load3(in []byte) int64 {
+	var r int64
+	r = int64(in[0])
+	r |= int64(in[1]) << 8
+	r |= int64(in[2]) << 16
+	return r
+}
+
+func load4(in []byte) int64 {
+	var r int64
+	r = int64(in[0])
+	r |= int64(in[1]) << 8
+	r |= int64(in[2]) << 16
+	r |= int64(in[3]) << 24
+	return r
+}
+
+func FeFromBytes(dst *FieldElement, src *[32]byte) {
+	h0 := load4(src[:])
+	h1 := load3(src[4:]) << 6
+	h2 := load3(src[7:]) << 5
+	h3 := load3(src[10:]) << 3
+	h4 := load3(src[13:]) << 2
+	h5 := load4(src[16:])
+	h6 := load3(src[20:]) << 7
+	h7 := load3(src[23:]) << 5
+	h8 := load3(src[26:]) << 4
+	h9 := (load3(src[29:]) & 8388607) << 2
+
+	FeCombine(dst, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+}
+
+// FeToBytes marshals h to s.
+// Preconditions:
+//   |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Write p=2^255-19; q=floor(h/p).
+// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
+//
+// Proof:
+//   Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
+//   Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
+//
+//   Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
+//   Then 0<y<1.
+//
+//   Write r=h-pq.
+//   Have 0<=r<=p-1=2^255-20.
+//   Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
+//
+//   Write x=r+19(2^-255)r+y.
+//   Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
+//
+//   Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
+//   so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
+func FeToBytes(s *[32]byte, h *FieldElement) {
+	var carry [10]int32
+
+	q := (19*h[9] + (1 << 24)) >> 25
+	q = (h[0] + q) >> 26
+	q = (h[1] + q) >> 25
+	q = (h[2] + q) >> 26
+	q = (h[3] + q) >> 25
+	q = (h[4] + q) >> 26
+	q = (h[5] + q) >> 25
+	q = (h[6] + q) >> 26
+	q = (h[7] + q) >> 25
+	q = (h[8] + q) >> 26
+	q = (h[9] + q) >> 25
+
+	// Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
+	h[0] += 19 * q
+	// Goal: Output h-2^255 q, which is between 0 and 2^255-20.
+
+	carry[0] = h[0] >> 26
+	h[1] += carry[0]
+	h[0] -= carry[0] << 26
+	carry[1] = h[1] >> 25
+	h[2] += carry[1]
+	h[1] -= carry[1] << 25
+	carry[2] = h[2] >> 26
+	h[3] += carry[2]
+	h[2] -= carry[2] << 26
+	carry[3] = h[3] >> 25
+	h[4] += carry[3]
+	h[3] -= carry[3] << 25
+	carry[4] = h[4] >> 26
+	h[5] += carry[4]
+	h[4] -= carry[4] << 26
+	carry[5] = h[5] >> 25
+	h[6] += carry[5]
+	h[5] -= carry[5] << 25
+	carry[6] = h[6] >> 26
+	h[7] += carry[6]
+	h[6] -= carry[6] << 26
+	carry[7] = h[7] >> 25
+	h[8] += carry[7]
+	h[7] -= carry[7] << 25
+	carry[8] = h[8] >> 26
+	h[9] += carry[8]
+	h[8] -= carry[8] << 26
+	carry[9] = h[9] >> 25
+	h[9] -= carry[9] << 25
+	// h10 = carry9
+
+	// Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
+	// Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
+	// evidently 2^255 h10-2^255 q = 0.
+	// Goal: Output h[0]+...+2^230 h[9].
+
+	s[0] = byte(h[0] >> 0)
+	s[1] = byte(h[0] >> 8)
+	s[2] = byte(h[0] >> 16)
+	s[3] = byte((h[0] >> 24) | (h[1] << 2))
+	s[4] = byte(h[1] >> 6)
+	s[5] = byte(h[1] >> 14)
+	s[6] = byte((h[1] >> 22) | (h[2] << 3))
+	s[7] = byte(h[2] >> 5)
+	s[8] = byte(h[2] >> 13)
+	s[9] = byte((h[2] >> 21) | (h[3] << 5))
+	s[10] = byte(h[3] >> 3)
+	s[11] = byte(h[3] >> 11)
+	s[12] = byte((h[3] >> 19) | (h[4] << 6))
+	s[13] = byte(h[4] >> 2)
+	s[14] = byte(h[4] >> 10)
+	s[15] = byte(h[4] >> 18)
+	s[16] = byte(h[5] >> 0)
+	s[17] = byte(h[5] >> 8)
+	s[18] = byte(h[5] >> 16)
+	s[19] = byte((h[5] >> 24) | (h[6] << 1))
+	s[20] = byte(h[6] >> 7)
+	s[21] = byte(h[6] >> 15)
+	s[22] = byte((h[6] >> 23) | (h[7] << 3))
+	s[23] = byte(h[7] >> 5)
+	s[24] = byte(h[7] >> 13)
+	s[25] = byte((h[7] >> 21) | (h[8] << 4))
+	s[26] = byte(h[8] >> 4)
+	s[27] = byte(h[8] >> 12)
+	s[28] = byte((h[8] >> 20) | (h[9] << 6))
+	s[29] = byte(h[9] >> 2)
+	s[30] = byte(h[9] >> 10)
+	s[31] = byte(h[9] >> 18)
+}
+
+func FeIsNegative(f *FieldElement) byte {
+	var s [32]byte
+	FeToBytes(&s, f)
+	return s[0] & 1
+}
+
+func FeIsNonZero(f *FieldElement) int32 {
+	var s [32]byte
+	FeToBytes(&s, f)
+	var x uint8
+	for _, b := range s {
+		x |= b
+	}
+	x |= x >> 4
+	x |= x >> 2
+	x |= x >> 1
+	return int32(x & 1)
+}
+
+// FeNeg sets h = -f
+//
+// Preconditions:
+//    |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Postconditions:
+//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeNeg(h, f *FieldElement) {
+	h[0] = -f[0]
+	h[1] = -f[1]
+	h[2] = -f[2]
+	h[3] = -f[3]
+	h[4] = -f[4]
+	h[5] = -f[5]
+	h[6] = -f[6]
+	h[7] = -f[7]
+	h[8] = -f[8]
+	h[9] = -f[9]
+}
+
+func FeCombine(h *FieldElement, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
+	var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9 int64
+
+	/*
+	  |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
+	    i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
+	  |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
+	    i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
+	*/
+
+	c0 = (h0 + (1 << 25)) >> 26
+	h1 += c0
+	h0 -= c0 << 26
+	c4 = (h4 + (1 << 25)) >> 26
+	h5 += c4
+	h4 -= c4 << 26
+	/* |h0| <= 2^25 */
+	/* |h4| <= 2^25 */
+	/* |h1| <= 1.51*2^58 */
+	/* |h5| <= 1.51*2^58 */
+
+	c1 = (h1 + (1 << 24)) >> 25
+	h2 += c1
+	h1 -= c1 << 25
+	c5 = (h5 + (1 << 24)) >> 25
+	h6 += c5
+	h5 -= c5 << 25
+	/* |h1| <= 2^24; from now on fits into int32 */
+	/* |h5| <= 2^24; from now on fits into int32 */
+	/* |h2| <= 1.21*2^59 */
+	/* |h6| <= 1.21*2^59 */
+
+	c2 = (h2 + (1 << 25)) >> 26
+	h3 += c2
+	h2 -= c2 << 26
+	c6 = (h6 + (1 << 25)) >> 26
+	h7 += c6
+	h6 -= c6 << 26
+	/* |h2| <= 2^25; from now on fits into int32 unchanged */
+	/* |h6| <= 2^25; from now on fits into int32 unchanged */
+	/* |h3| <= 1.51*2^58 */
+	/* |h7| <= 1.51*2^58 */
+
+	c3 = (h3 + (1 << 24)) >> 25
+	h4 += c3
+	h3 -= c3 << 25
+	c7 = (h7 + (1 << 24)) >> 25
+	h8 += c7
+	h7 -= c7 << 25
+	/* |h3| <= 2^24; from now on fits into int32 unchanged */
+	/* |h7| <= 2^24; from now on fits into int32 unchanged */
+	/* |h4| <= 1.52*2^33 */
+	/* |h8| <= 1.52*2^33 */
+
+	c4 = (h4 + (1 << 25)) >> 26
+	h5 += c4
+	h4 -= c4 << 26
+	c8 = (h8 + (1 << 25)) >> 26
+	h9 += c8
+	h8 -= c8 << 26
+	/* |h4| <= 2^25; from now on fits into int32 unchanged */
+	/* |h8| <= 2^25; from now on fits into int32 unchanged */
+	/* |h5| <= 1.01*2^24 */
+	/* |h9| <= 1.51*2^58 */
+
+	c9 = (h9 + (1 << 24)) >> 25
+	h0 += c9 * 19
+	h9 -= c9 << 25
+	/* |h9| <= 2^24; from now on fits into int32 unchanged */
+	/* |h0| <= 1.8*2^37 */
+
+	c0 = (h0 + (1 << 25)) >> 26
+	h1 += c0
+	h0 -= c0 << 26
+	/* |h0| <= 2^25; from now on fits into int32 unchanged */
+	/* |h1| <= 1.01*2^24 */
+
+	h[0] = int32(h0)
+	h[1] = int32(h1)
+	h[2] = int32(h2)
+	h[3] = int32(h3)
+	h[4] = int32(h4)
+	h[5] = int32(h5)
+	h[6] = int32(h6)
+	h[7] = int32(h7)
+	h[8] = int32(h8)
+	h[9] = int32(h9)
+}
+
+// FeMul calculates h = f * g
+// Can overlap h with f or g.
+//
+// Preconditions:
+//    |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//    |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+//
+// Notes on implementation strategy:
+//
+// Using schoolbook multiplication.
+// Karatsuba would save a little in some cost models.
+//
+// Most multiplications by 2 and 19 are 32-bit precomputations;
+// cheaper than 64-bit postcomputations.
+//
+// There is one remaining multiplication by 19 in the carry chain;
+// one *19 precomputation can be merged into this,
+// but the resulting data flow is considerably less clean.
+//
+// There are 12 carries below.
+// 10 of them are 2-way parallelizable and vectorizable.
+// Can get away with 11 carries, but then data flow is much deeper.
+//
+// With tighter constraints on inputs can squeeze carries into int32.
+func FeMul(h, f, g *FieldElement) {
+	f0 := int64(f[0])
+	f1 := int64(f[1])
+	f2 := int64(f[2])
+	f3 := int64(f[3])
+	f4 := int64(f[4])
+	f5 := int64(f[5])
+	f6 := int64(f[6])
+	f7 := int64(f[7])
+	f8 := int64(f[8])
+	f9 := int64(f[9])
+
+	f1_2 := int64(2 * f[1])
+	f3_2 := int64(2 * f[3])
+	f5_2 := int64(2 * f[5])
+	f7_2 := int64(2 * f[7])
+	f9_2 := int64(2 * f[9])
+
+	g0 := int64(g[0])
+	g1 := int64(g[1])
+	g2 := int64(g[2])
+	g3 := int64(g[3])
+	g4 := int64(g[4])
+	g5 := int64(g[5])
+	g6 := int64(g[6])
+	g7 := int64(g[7])
+	g8 := int64(g[8])
+	g9 := int64(g[9])
+
+	g1_19 := int64(19 * g[1]) /* 1.4*2^29 */
+	g2_19 := int64(19 * g[2]) /* 1.4*2^30; still ok */
+	g3_19 := int64(19 * g[3])
+	g4_19 := int64(19 * g[4])
+	g5_19 := int64(19 * g[5])
+	g6_19 := int64(19 * g[6])
+	g7_19 := int64(19 * g[7])
+	g8_19 := int64(19 * g[8])
+	g9_19 := int64(19 * g[9])
+
+	h0 := f0*g0 + f1_2*g9_19 + f2*g8_19 + f3_2*g7_19 + f4*g6_19 + f5_2*g5_19 + f6*g4_19 + f7_2*g3_19 + f8*g2_19 + f9_2*g1_19
+	h1 := f0*g1 + f1*g0 + f2*g9_19 + f3*g8_19 + f4*g7_19 + f5*g6_19 + f6*g5_19 + f7*g4_19 + f8*g3_19 + f9*g2_19
+	h2 := f0*g2 + f1_2*g1 + f2*g0 + f3_2*g9_19 + f4*g8_19 + f5_2*g7_19 + f6*g6_19 + f7_2*g5_19 + f8*g4_19 + f9_2*g3_19
+	h3 := f0*g3 + f1*g2 + f2*g1 + f3*g0 + f4*g9_19 + f5*g8_19 + f6*g7_19 + f7*g6_19 + f8*g5_19 + f9*g4_19
+	h4 := f0*g4 + f1_2*g3 + f2*g2 + f3_2*g1 + f4*g0 + f5_2*g9_19 + f6*g8_19 + f7_2*g7_19 + f8*g6_19 + f9_2*g5_19
+	h5 := f0*g5 + f1*g4 + f2*g3 + f3*g2 + f4*g1 + f5*g0 + f6*g9_19 + f7*g8_19 + f8*g7_19 + f9*g6_19
+	h6 := f0*g6 + f1_2*g5 + f2*g4 + f3_2*g3 + f4*g2 + f5_2*g1 + f6*g0 + f7_2*g9_19 + f8*g8_19 + f9_2*g7_19
+	h7 := f0*g7 + f1*g6 + f2*g5 + f3*g4 + f4*g3 + f5*g2 + f6*g1 + f7*g0 + f8*g9_19 + f9*g8_19
+	h8 := f0*g8 + f1_2*g7 + f2*g6 + f3_2*g5 + f4*g4 + f5_2*g3 + f6*g2 + f7_2*g1 + f8*g0 + f9_2*g9_19
+	h9 := f0*g9 + f1*g8 + f2*g7 + f3*g6 + f4*g5 + f5*g4 + f6*g3 + f7*g2 + f8*g1 + f9*g0
+
+	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+}
+
+func feSquare(f *FieldElement) (h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
+	f0 := int64(f[0])
+	f1 := int64(f[1])
+	f2 := int64(f[2])
+	f3 := int64(f[3])
+	f4 := int64(f[4])
+	f5 := int64(f[5])
+	f6 := int64(f[6])
+	f7 := int64(f[7])
+	f8 := int64(f[8])
+	f9 := int64(f[9])
+	f0_2 := int64(2 * f[0])
+	f1_2 := int64(2 * f[1])
+	f2_2 := int64(2 * f[2])
+	f3_2 := int64(2 * f[3])
+	f4_2 := int64(2 * f[4])
+	f5_2 := int64(2 * f[5])
+	f6_2 := int64(2 * f[6])
+	f7_2 := int64(2 * f[7])
+	f5_38 := 38 * f5 // 1.31*2^30
+	f6_19 := 19 * f6 // 1.31*2^30
+	f7_38 := 38 * f7 // 1.31*2^30
+	f8_19 := 19 * f8 // 1.31*2^30
+	f9_38 := 38 * f9 // 1.31*2^30
+
+	h0 = f0*f0 + f1_2*f9_38 + f2_2*f8_19 + f3_2*f7_38 + f4_2*f6_19 + f5*f5_38
+	h1 = f0_2*f1 + f2*f9_38 + f3_2*f8_19 + f4*f7_38 + f5_2*f6_19
+	h2 = f0_2*f2 + f1_2*f1 + f3_2*f9_38 + f4_2*f8_19 + f5_2*f7_38 + f6*f6_19
+	h3 = f0_2*f3 + f1_2*f2 + f4*f9_38 + f5_2*f8_19 + f6*f7_38
+	h4 = f0_2*f4 + f1_2*f3_2 + f2*f2 + f5_2*f9_38 + f6_2*f8_19 + f7*f7_38
+	h5 = f0_2*f5 + f1_2*f4 + f2_2*f3 + f6*f9_38 + f7_2*f8_19
+	h6 = f0_2*f6 + f1_2*f5_2 + f2_2*f4 + f3_2*f3 + f7_2*f9_38 + f8*f8_19
+	h7 = f0_2*f7 + f1_2*f6 + f2_2*f5 + f3_2*f4 + f8*f9_38
+	h8 = f0_2*f8 + f1_2*f7_2 + f2_2*f6 + f3_2*f5_2 + f4*f4 + f9*f9_38
+	h9 = f0_2*f9 + f1_2*f8 + f2_2*f7 + f3_2*f6 + f4_2*f5
+
+	return
+}
+
+// FeSquare calculates h = f*f. Can overlap h with f.
+//
+// Preconditions:
+//    |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+//
+// Postconditions:
+//    |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+func FeSquare(h, f *FieldElement) {
+	h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
+	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+}
+
+// FeSquare2 sets h = 2 * f * f
+//
+// Can overlap h with f.
+//
+// Preconditions:
+//    |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+//
+// Postconditions:
+//    |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+// See fe_mul.c for discussion of implementation strategy.
+func FeSquare2(h, f *FieldElement) {
+	h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
+
+	h0 += h0
+	h1 += h1
+	h2 += h2
+	h3 += h3
+	h4 += h4
+	h5 += h5
+	h6 += h6
+	h7 += h7
+	h8 += h8
+	h9 += h9
+
+	FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
+}
+
+func FeInvert(out, z *FieldElement) {
+	var t0, t1, t2, t3 FieldElement
+	var i int
+
+	FeSquare(&t0, z)        // 2^1
+	FeSquare(&t1, &t0)      // 2^2
+	for i = 1; i < 2; i++ { // 2^3
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t1, z, &t1)      // 2^3 + 2^0
+	FeMul(&t0, &t0, &t1)    // 2^3 + 2^1 + 2^0
+	FeSquare(&t2, &t0)      // 2^4 + 2^2 + 2^1
+	FeMul(&t1, &t1, &t2)    // 2^4 + 2^3 + 2^2 + 2^1 + 2^0
+	FeSquare(&t2, &t1)      // 5,4,3,2,1
+	for i = 1; i < 5; i++ { // 9,8,7,6,5
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t1, &t2, &t1)     // 9,8,7,6,5,4,3,2,1,0
+	FeSquare(&t2, &t1)       // 10..1
+	for i = 1; i < 10; i++ { // 19..10
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t2, &t2, &t1)     // 19..0
+	FeSquare(&t3, &t2)       // 20..1
+	for i = 1; i < 20; i++ { // 39..20
+		FeSquare(&t3, &t3)
+	}
+	FeMul(&t2, &t3, &t2)     // 39..0
+	FeSquare(&t2, &t2)       // 40..1
+	for i = 1; i < 10; i++ { // 49..10
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t1, &t2, &t1)     // 49..0
+	FeSquare(&t2, &t1)       // 50..1
+	for i = 1; i < 50; i++ { // 99..50
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t2, &t2, &t1)      // 99..0
+	FeSquare(&t3, &t2)        // 100..1
+	for i = 1; i < 100; i++ { // 199..100
+		FeSquare(&t3, &t3)
+	}
+	FeMul(&t2, &t3, &t2)     // 199..0
+	FeSquare(&t2, &t2)       // 200..1
+	for i = 1; i < 50; i++ { // 249..50
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t1, &t2, &t1)    // 249..0
+	FeSquare(&t1, &t1)      // 250..1
+	for i = 1; i < 5; i++ { // 254..5
+		FeSquare(&t1, &t1)
+	}
+	FeMul(out, &t1, &t0) // 254..5,3,1,0
+}
+
+func fePow22523(out, z *FieldElement) {
+	var t0, t1, t2 FieldElement
+	var i int
+
+	FeSquare(&t0, z)
+	for i = 1; i < 1; i++ {
+		FeSquare(&t0, &t0)
+	}
+	FeSquare(&t1, &t0)
+	for i = 1; i < 2; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t1, z, &t1)
+	FeMul(&t0, &t0, &t1)
+	FeSquare(&t0, &t0)
+	for i = 1; i < 1; i++ {
+		FeSquare(&t0, &t0)
+	}
+	FeMul(&t0, &t1, &t0)
+	FeSquare(&t1, &t0)
+	for i = 1; i < 5; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t0, &t1, &t0)
+	FeSquare(&t1, &t0)
+	for i = 1; i < 10; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t1, &t1, &t0)
+	FeSquare(&t2, &t1)
+	for i = 1; i < 20; i++ {
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t1, &t2, &t1)
+	FeSquare(&t1, &t1)
+	for i = 1; i < 10; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t0, &t1, &t0)
+	FeSquare(&t1, &t0)
+	for i = 1; i < 50; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t1, &t1, &t0)
+	FeSquare(&t2, &t1)
+	for i = 1; i < 100; i++ {
+		FeSquare(&t2, &t2)
+	}
+	FeMul(&t1, &t2, &t1)
+	FeSquare(&t1, &t1)
+	for i = 1; i < 50; i++ {
+		FeSquare(&t1, &t1)
+	}
+	FeMul(&t0, &t1, &t0)
+	FeSquare(&t0, &t0)
+	for i = 1; i < 2; i++ {
+		FeSquare(&t0, &t0)
+	}
+	FeMul(out, &t0, z)
+}
+
+// Group elements are members of the elliptic curve -x^2 + y^2 = 1 + d * x^2 *
+// y^2 where d = -121665/121666.
+//
+// Several representations are used:
+//   ProjectiveGroupElement: (X:Y:Z) satisfying x=X/Z, y=Y/Z
+//   ExtendedGroupElement: (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+//   CompletedGroupElement: ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+//   PreComputedGroupElement: (y+x,y-x,2dxy)
+
+type ProjectiveGroupElement struct {
+	X, Y, Z FieldElement
+}
+
+type ExtendedGroupElement struct {
+	X, Y, Z, T FieldElement
+}
+
+type CompletedGroupElement struct {
+	X, Y, Z, T FieldElement
+}
+
+type PreComputedGroupElement struct {
+	yPlusX, yMinusX, xy2d FieldElement
+}
+
+type CachedGroupElement struct {
+	yPlusX, yMinusX, Z, T2d FieldElement
+}
+
+func (p *ProjectiveGroupElement) Zero() {
+	FeZero(&p.X)
+	FeOne(&p.Y)
+	FeOne(&p.Z)
+}
+
+func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement) {
+	var t0 FieldElement
+
+	FeSquare(&r.X, &p.X)
+	FeSquare(&r.Z, &p.Y)
+	FeSquare2(&r.T, &p.Z)
+	FeAdd(&r.Y, &p.X, &p.Y)
+	FeSquare(&t0, &r.Y)
+	FeAdd(&r.Y, &r.Z, &r.X)
+	FeSub(&r.Z, &r.Z, &r.X)
+	FeSub(&r.X, &t0, &r.Y)
+	FeSub(&r.T, &r.T, &r.Z)
+}
+
+func (p *ProjectiveGroupElement) ToBytes(s *[32]byte) {
+	var recip, x, y FieldElement
+
+	FeInvert(&recip, &p.Z)
+	FeMul(&x, &p.X, &recip)
+	FeMul(&y, &p.Y, &recip)
+	FeToBytes(s, &y)
+	s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) Zero() {
+	FeZero(&p.X)
+	FeOne(&p.Y)
+	FeOne(&p.Z)
+	FeZero(&p.T)
+}
+
+func (p *ExtendedGroupElement) Double(r *CompletedGroupElement) {
+	var q ProjectiveGroupElement
+	p.ToProjective(&q)
+	q.Double(r)
+}
+
+func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement) {
+	FeAdd(&r.yPlusX, &p.Y, &p.X)
+	FeSub(&r.yMinusX, &p.Y, &p.X)
+	FeCopy(&r.Z, &p.Z)
+	FeMul(&r.T2d, &p.T, &d2)
+}
+
+func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+	FeCopy(&r.X, &p.X)
+	FeCopy(&r.Y, &p.Y)
+	FeCopy(&r.Z, &p.Z)
+}
+
+func (p *ExtendedGroupElement) ToBytes(s *[32]byte) {
+	var recip, x, y FieldElement
+
+	FeInvert(&recip, &p.Z)
+	FeMul(&x, &p.X, &recip)
+	FeMul(&y, &p.Y, &recip)
+	FeToBytes(s, &y)
+	s[31] ^= FeIsNegative(&x) << 7
+}
+
+func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool {
+	var u, v, v3, vxx, check FieldElement
+
+	FeFromBytes(&p.Y, s)
+	FeOne(&p.Z)
+	FeSquare(&u, &p.Y)
+	FeMul(&v, &u, &d)
+	FeSub(&u, &u, &p.Z) // y = y^2-1
+	FeAdd(&v, &v, &p.Z) // v = dy^2+1
+
+	FeSquare(&v3, &v)
+	FeMul(&v3, &v3, &v) // v3 = v^3
+	FeSquare(&p.X, &v3)
+	FeMul(&p.X, &p.X, &v)
+	FeMul(&p.X, &p.X, &u) // x = uv^7
+
+	fePow22523(&p.X, &p.X) // x = (uv^7)^((q-5)/8)
+	FeMul(&p.X, &p.X, &v3)
+	FeMul(&p.X, &p.X, &u) // x = uv^3(uv^7)^((q-5)/8)
+
+	var tmpX, tmp2 [32]byte
+
+	FeSquare(&vxx, &p.X)
+	FeMul(&vxx, &vxx, &v)
+	FeSub(&check, &vxx, &u) // vx^2-u
+	if FeIsNonZero(&check) == 1 {
+		FeAdd(&check, &vxx, &u) // vx^2+u
+		if FeIsNonZero(&check) == 1 {
+			return false
+		}
+		FeMul(&p.X, &p.X, &SqrtM1)
+
+		FeToBytes(&tmpX, &p.X)
+		for i, v := range tmpX {
+			tmp2[31-i] = v
+		}
+	}
+
+	if FeIsNegative(&p.X) != (s[31] >> 7) {
+		FeNeg(&p.X, &p.X)
+	}
+
+	FeMul(&p.T, &p.X, &p.Y)
+	return true
+}
+
+func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement) {
+	FeMul(&r.X, &p.X, &p.T)
+	FeMul(&r.Y, &p.Y, &p.Z)
+	FeMul(&r.Z, &p.Z, &p.T)
+}
+
+func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement) {
+	FeMul(&r.X, &p.X, &p.T)
+	FeMul(&r.Y, &p.Y, &p.Z)
+	FeMul(&r.Z, &p.Z, &p.T)
+	FeMul(&r.T, &p.X, &p.Y)
+}
+
+func (p *PreComputedGroupElement) Zero() {
+	FeOne(&p.yPlusX)
+	FeOne(&p.yMinusX)
+	FeZero(&p.xy2d)
+}
+
+func geAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+	var t0 FieldElement
+
+	FeAdd(&r.X, &p.Y, &p.X)
+	FeSub(&r.Y, &p.Y, &p.X)
+	FeMul(&r.Z, &r.X, &q.yPlusX)
+	FeMul(&r.Y, &r.Y, &q.yMinusX)
+	FeMul(&r.T, &q.T2d, &p.T)
+	FeMul(&r.X, &p.Z, &q.Z)
+	FeAdd(&t0, &r.X, &r.X)
+	FeSub(&r.X, &r.Z, &r.Y)
+	FeAdd(&r.Y, &r.Z, &r.Y)
+	FeAdd(&r.Z, &t0, &r.T)
+	FeSub(&r.T, &t0, &r.T)
+}
+
+func geSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
+	var t0 FieldElement
+
+	FeAdd(&r.X, &p.Y, &p.X)
+	FeSub(&r.Y, &p.Y, &p.X)
+	FeMul(&r.Z, &r.X, &q.yMinusX)
+	FeMul(&r.Y, &r.Y, &q.yPlusX)
+	FeMul(&r.T, &q.T2d, &p.T)
+	FeMul(&r.X, &p.Z, &q.Z)
+	FeAdd(&t0, &r.X, &r.X)
+	FeSub(&r.X, &r.Z, &r.Y)
+	FeAdd(&r.Y, &r.Z, &r.Y)
+	FeSub(&r.Z, &t0, &r.T)
+	FeAdd(&r.T, &t0, &r.T)
+}
+
+func geMixedAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+	var t0 FieldElement
+
+	FeAdd(&r.X, &p.Y, &p.X)
+	FeSub(&r.Y, &p.Y, &p.X)
+	FeMul(&r.Z, &r.X, &q.yPlusX)
+	FeMul(&r.Y, &r.Y, &q.yMinusX)
+	FeMul(&r.T, &q.xy2d, &p.T)
+	FeAdd(&t0, &p.Z, &p.Z)
+	FeSub(&r.X, &r.Z, &r.Y)
+	FeAdd(&r.Y, &r.Z, &r.Y)
+	FeAdd(&r.Z, &t0, &r.T)
+	FeSub(&r.T, &t0, &r.T)
+}
+
+func geMixedSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
+	var t0 FieldElement
+
+	FeAdd(&r.X, &p.Y, &p.X)
+	FeSub(&r.Y, &p.Y, &p.X)
+	FeMul(&r.Z, &r.X, &q.yMinusX)
+	FeMul(&r.Y, &r.Y, &q.yPlusX)
+	FeMul(&r.T, &q.xy2d, &p.T)
+	FeAdd(&t0, &p.Z, &p.Z)
+	FeSub(&r.X, &r.Z, &r.Y)
+	FeAdd(&r.Y, &r.Z, &r.Y)
+	FeSub(&r.Z, &t0, &r.T)
+	FeAdd(&r.T, &t0, &r.T)
+}
+
+func slide(r *[256]int8, a *[32]byte) {
+	for i := range r {
+		r[i] = int8(1 & (a[i>>3] >> uint(i&7)))
+	}
+
+	for i := range r {
+		if r[i] != 0 {
+			for b := 1; b <= 6 && i+b < 256; b++ {
+				if r[i+b] != 0 {
+					if r[i]+(r[i+b]<<uint(b)) <= 15 {
+						r[i] += r[i+b] << uint(b)
+						r[i+b] = 0
+					} else if r[i]-(r[i+b]<<uint(b)) >= -15 {
+						r[i] -= r[i+b] << uint(b)
+						for k := i + b; k < 256; k++ {
+							if r[k] == 0 {
+								r[k] = 1
+								break
+							}
+							r[k] = 0
+						}
+					} else {
+						break
+					}
+				}
+			}
+		}
+	}
+}
+
+// GeDoubleScalarMultVartime sets r = a*A + b*B
+// where a = a[0]+256*a[1]+...+256^31 a[31].
+// and b = b[0]+256*b[1]+...+256^31 b[31].
+// B is the Ed25519 base point (x,4/5) with x positive.
+func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte) {
+	var aSlide, bSlide [256]int8
+	var Ai [8]CachedGroupElement // A,3A,5A,7A,9A,11A,13A,15A
+	var t CompletedGroupElement
+	var u, A2 ExtendedGroupElement
+	var i int
+
+	slide(&aSlide, a)
+	slide(&bSlide, b)
+
+	A.ToCached(&Ai[0])
+	A.Double(&t)
+	t.ToExtended(&A2)
+
+	for i := 0; i < 7; i++ {
+		geAdd(&t, &A2, &Ai[i])
+		t.ToExtended(&u)
+		u.ToCached(&Ai[i+1])
+	}
+
+	r.Zero()
+
+	for i = 255; i >= 0; i-- {
+		if aSlide[i] != 0 || bSlide[i] != 0 {
+			break
+		}
+	}
+
+	for ; i >= 0; i-- {
+		r.Double(&t)
+
+		if aSlide[i] > 0 {
+			t.ToExtended(&u)
+			geAdd(&t, &u, &Ai[aSlide[i]/2])
+		} else if aSlide[i] < 0 {
+			t.ToExtended(&u)
+			geSub(&t, &u, &Ai[(-aSlide[i])/2])
+		}
+
+		if bSlide[i] > 0 {
+			t.ToExtended(&u)
+			geMixedAdd(&t, &u, &bi[bSlide[i]/2])
+		} else if bSlide[i] < 0 {
+			t.ToExtended(&u)
+			geMixedSub(&t, &u, &bi[(-bSlide[i])/2])
+		}
+
+		t.ToProjective(r)
+	}
+}
+
+// equal returns 1 if b == c and 0 otherwise.
+func equal(b, c int32) int32 {
+	x := uint32(b ^ c)
+	x--
+	return int32(x >> 31)
+}
+
+// negative returns 1 if b < 0 and 0 otherwise.
+func negative(b int32) int32 {
+	return (b >> 31) & 1
+}
+
+func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32) {
+	FeCMove(&t.yPlusX, &u.yPlusX, b)
+	FeCMove(&t.yMinusX, &u.yMinusX, b)
+	FeCMove(&t.xy2d, &u.xy2d, b)
+}
+
+func selectPoint(t *PreComputedGroupElement, pos int32, b int32) {
+	var minusT PreComputedGroupElement
+	bNegative := negative(b)
+	bAbs := b - (((-bNegative) & b) << 1)
+
+	t.Zero()
+	for i := int32(0); i < 8; i++ {
+		PreComputedGroupElementCMove(t, &base[pos][i], equal(bAbs, i+1))
+	}
+	FeCopy(&minusT.yPlusX, &t.yMinusX)
+	FeCopy(&minusT.yMinusX, &t.yPlusX)
+	FeNeg(&minusT.xy2d, &t.xy2d)
+	PreComputedGroupElementCMove(t, &minusT, bNegative)
+}
+
+// GeScalarMultBase computes h = a*B, where
+//   a = a[0]+256*a[1]+...+256^31 a[31]
+//   B is the Ed25519 base point (x,4/5) with x positive.
+//
+// Preconditions:
+//   a[31] <= 127
+func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte) {
+	var e [64]int8
+
+	for i, v := range a {
+		e[2*i] = int8(v & 15)
+		e[2*i+1] = int8((v >> 4) & 15)
+	}
+
+	// each e[i] is between 0 and 15 and e[63] is between 0 and 7.
+
+	carry := int8(0)
+	for i := 0; i < 63; i++ {
+		e[i] += carry
+		carry = (e[i] + 8) >> 4
+		e[i] -= carry << 4
+	}
+	e[63] += carry
+	// each e[i] is between -8 and 8.
+
+	h.Zero()
+	var t PreComputedGroupElement
+	var r CompletedGroupElement
+	for i := int32(1); i < 64; i += 2 {
+		selectPoint(&t, i/2, int32(e[i]))
+		geMixedAdd(&r, h, &t)
+		r.ToExtended(h)
+	}
+
+	var s ProjectiveGroupElement
+
+	h.Double(&r)
+	r.ToProjective(&s)
+	s.Double(&r)
+	r.ToProjective(&s)
+	s.Double(&r)
+	r.ToProjective(&s)
+	s.Double(&r)
+	r.ToExtended(h)
+
+	for i := int32(0); i < 64; i += 2 {
+		selectPoint(&t, i/2, int32(e[i]))
+		geMixedAdd(&r, h, &t)
+		r.ToExtended(h)
+	}
+}
+
+// The scalars are GF(2^252 + 27742317777372353535851937790883648493).
+
+// Input:
+//   a[0]+256*a[1]+...+256^31*a[31] = a
+//   b[0]+256*b[1]+...+256^31*b[31] = b
+//   c[0]+256*c[1]+...+256^31*c[31] = c
+//
+// Output:
+//   s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+//   where l = 2^252 + 27742317777372353535851937790883648493.
+func ScMulAdd(s, a, b, c *[32]byte) {
+	a0 := 2097151 & load3(a[:])
+	a1 := 2097151 & (load4(a[2:]) >> 5)
+	a2 := 2097151 & (load3(a[5:]) >> 2)
+	a3 := 2097151 & (load4(a[7:]) >> 7)
+	a4 := 2097151 & (load4(a[10:]) >> 4)
+	a5 := 2097151 & (load3(a[13:]) >> 1)
+	a6 := 2097151 & (load4(a[15:]) >> 6)
+	a7 := 2097151 & (load3(a[18:]) >> 3)
+	a8 := 2097151 & load3(a[21:])
+	a9 := 2097151 & (load4(a[23:]) >> 5)
+	a10 := 2097151 & (load3(a[26:]) >> 2)
+	a11 := (load4(a[28:]) >> 7)
+	b0 := 2097151 & load3(b[:])
+	b1 := 2097151 & (load4(b[2:]) >> 5)
+	b2 := 2097151 & (load3(b[5:]) >> 2)
+	b3 := 2097151 & (load4(b[7:]) >> 7)
+	b4 := 2097151 & (load4(b[10:]) >> 4)
+	b5 := 2097151 & (load3(b[13:]) >> 1)
+	b6 := 2097151 & (load4(b[15:]) >> 6)
+	b7 := 2097151 & (load3(b[18:]) >> 3)
+	b8 := 2097151 & load3(b[21:])
+	b9 := 2097151 & (load4(b[23:]) >> 5)
+	b10 := 2097151 & (load3(b[26:]) >> 2)
+	b11 := (load4(b[28:]) >> 7)
+	c0 := 2097151 & load3(c[:])
+	c1 := 2097151 & (load4(c[2:]) >> 5)
+	c2 := 2097151 & (load3(c[5:]) >> 2)
+	c3 := 2097151 & (load4(c[7:]) >> 7)
+	c4 := 2097151 & (load4(c[10:]) >> 4)
+	c5 := 2097151 & (load3(c[13:]) >> 1)
+	c6 := 2097151 & (load4(c[15:]) >> 6)
+	c7 := 2097151 & (load3(c[18:]) >> 3)
+	c8 := 2097151 & load3(c[21:])
+	c9 := 2097151 & (load4(c[23:]) >> 5)
+	c10 := 2097151 & (load3(c[26:]) >> 2)
+	c11 := (load4(c[28:]) >> 7)
+	var carry [23]int64
+
+	s0 := c0 + a0*b0
+	s1 := c1 + a0*b1 + a1*b0
+	s2 := c2 + a0*b2 + a1*b1 + a2*b0
+	s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
+	s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
+	s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
+	s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
+	s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
+	s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
+	s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
+	s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
+	s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
+	s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
+	s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
+	s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
+	s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
+	s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
+	s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
+	s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
+	s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
+	s20 := a9*b11 + a10*b10 + a11*b9
+	s21 := a10*b11 + a11*b10
+	s22 := a11 * b11
+	s23 := int64(0)
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+	carry[18] = (s18 + (1 << 20)) >> 21
+	s19 += carry[18]
+	s18 -= carry[18] << 21
+	carry[20] = (s20 + (1 << 20)) >> 21
+	s21 += carry[20]
+	s20 -= carry[20] << 21
+	carry[22] = (s22 + (1 << 20)) >> 21
+	s23 += carry[22]
+	s22 -= carry[22] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+	carry[17] = (s17 + (1 << 20)) >> 21
+	s18 += carry[17]
+	s17 -= carry[17] << 21
+	carry[19] = (s19 + (1 << 20)) >> 21
+	s20 += carry[19]
+	s19 -= carry[19] << 21
+	carry[21] = (s21 + (1 << 20)) >> 21
+	s22 += carry[21]
+	s21 -= carry[21] << 21
+
+	s11 += s23 * 666643
+	s12 += s23 * 470296
+	s13 += s23 * 654183
+	s14 -= s23 * 997805
+	s15 += s23 * 136657
+	s16 -= s23 * 683901
+	s23 = 0
+
+	s10 += s22 * 666643
+	s11 += s22 * 470296
+	s12 += s22 * 654183
+	s13 -= s22 * 997805
+	s14 += s22 * 136657
+	s15 -= s22 * 683901
+	s22 = 0
+
+	s9 += s21 * 666643
+	s10 += s21 * 470296
+	s11 += s21 * 654183
+	s12 -= s21 * 997805
+	s13 += s21 * 136657
+	s14 -= s21 * 683901
+	s21 = 0
+
+	s8 += s20 * 666643
+	s9 += s20 * 470296
+	s10 += s20 * 654183
+	s11 -= s20 * 997805
+	s12 += s20 * 136657
+	s13 -= s20 * 683901
+	s20 = 0
+
+	s7 += s19 * 666643
+	s8 += s19 * 470296
+	s9 += s19 * 654183
+	s10 -= s19 * 997805
+	s11 += s19 * 136657
+	s12 -= s19 * 683901
+	s19 = 0
+
+	s6 += s18 * 666643
+	s7 += s18 * 470296
+	s8 += s18 * 654183
+	s9 -= s18 * 997805
+	s10 += s18 * 136657
+	s11 -= s18 * 683901
+	s18 = 0
+
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+
+	s5 += s17 * 666643
+	s6 += s17 * 470296
+	s7 += s17 * 654183
+	s8 -= s17 * 997805
+	s9 += s17 * 136657
+	s10 -= s17 * 683901
+	s17 = 0
+
+	s4 += s16 * 666643
+	s5 += s16 * 470296
+	s6 += s16 * 654183
+	s7 -= s16 * 997805
+	s8 += s16 * 136657
+	s9 -= s16 * 683901
+	s16 = 0
+
+	s3 += s15 * 666643
+	s4 += s15 * 470296
+	s5 += s15 * 654183
+	s6 -= s15 * 997805
+	s7 += s15 * 136657
+	s8 -= s15 * 683901
+	s15 = 0
+
+	s2 += s14 * 666643
+	s3 += s14 * 470296
+	s4 += s14 * 654183
+	s5 -= s14 * 997805
+	s6 += s14 * 136657
+	s7 -= s14 * 683901
+	s14 = 0
+
+	s1 += s13 * 666643
+	s2 += s13 * 470296
+	s3 += s13 * 654183
+	s4 -= s13 * 997805
+	s5 += s13 * 136657
+	s6 -= s13 * 683901
+	s13 = 0
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[11] = s11 >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	s[0] = byte(s0 >> 0)
+	s[1] = byte(s0 >> 8)
+	s[2] = byte((s0 >> 16) | (s1 << 5))
+	s[3] = byte(s1 >> 3)
+	s[4] = byte(s1 >> 11)
+	s[5] = byte((s1 >> 19) | (s2 << 2))
+	s[6] = byte(s2 >> 6)
+	s[7] = byte((s2 >> 14) | (s3 << 7))
+	s[8] = byte(s3 >> 1)
+	s[9] = byte(s3 >> 9)
+	s[10] = byte((s3 >> 17) | (s4 << 4))
+	s[11] = byte(s4 >> 4)
+	s[12] = byte(s4 >> 12)
+	s[13] = byte((s4 >> 20) | (s5 << 1))
+	s[14] = byte(s5 >> 7)
+	s[15] = byte((s5 >> 15) | (s6 << 6))
+	s[16] = byte(s6 >> 2)
+	s[17] = byte(s6 >> 10)
+	s[18] = byte((s6 >> 18) | (s7 << 3))
+	s[19] = byte(s7 >> 5)
+	s[20] = byte(s7 >> 13)
+	s[21] = byte(s8 >> 0)
+	s[22] = byte(s8 >> 8)
+	s[23] = byte((s8 >> 16) | (s9 << 5))
+	s[24] = byte(s9 >> 3)
+	s[25] = byte(s9 >> 11)
+	s[26] = byte((s9 >> 19) | (s10 << 2))
+	s[27] = byte(s10 >> 6)
+	s[28] = byte((s10 >> 14) | (s11 << 7))
+	s[29] = byte(s11 >> 1)
+	s[30] = byte(s11 >> 9)
+	s[31] = byte(s11 >> 17)
+}
+
+// Input:
+//   s[0]+256*s[1]+...+256^63*s[63] = s
+//
+// Output:
+//   s[0]+256*s[1]+...+256^31*s[31] = s mod l
+//   where l = 2^252 + 27742317777372353535851937790883648493.
+func ScReduce(out *[32]byte, s *[64]byte) {
+	s0 := 2097151 & load3(s[:])
+	s1 := 2097151 & (load4(s[2:]) >> 5)
+	s2 := 2097151 & (load3(s[5:]) >> 2)
+	s3 := 2097151 & (load4(s[7:]) >> 7)
+	s4 := 2097151 & (load4(s[10:]) >> 4)
+	s5 := 2097151 & (load3(s[13:]) >> 1)
+	s6 := 2097151 & (load4(s[15:]) >> 6)
+	s7 := 2097151 & (load3(s[18:]) >> 3)
+	s8 := 2097151 & load3(s[21:])
+	s9 := 2097151 & (load4(s[23:]) >> 5)
+	s10 := 2097151 & (load3(s[26:]) >> 2)
+	s11 := 2097151 & (load4(s[28:]) >> 7)
+	s12 := 2097151 & (load4(s[31:]) >> 4)
+	s13 := 2097151 & (load3(s[34:]) >> 1)
+	s14 := 2097151 & (load4(s[36:]) >> 6)
+	s15 := 2097151 & (load3(s[39:]) >> 3)
+	s16 := 2097151 & load3(s[42:])
+	s17 := 2097151 & (load4(s[44:]) >> 5)
+	s18 := 2097151 & (load3(s[47:]) >> 2)
+	s19 := 2097151 & (load4(s[49:]) >> 7)
+	s20 := 2097151 & (load4(s[52:]) >> 4)
+	s21 := 2097151 & (load3(s[55:]) >> 1)
+	s22 := 2097151 & (load4(s[57:]) >> 6)
+	s23 := (load4(s[60:]) >> 3)
+
+	s11 += s23 * 666643
+	s12 += s23 * 470296
+	s13 += s23 * 654183
+	s14 -= s23 * 997805
+	s15 += s23 * 136657
+	s16 -= s23 * 683901
+	s23 = 0
+
+	s10 += s22 * 666643
+	s11 += s22 * 470296
+	s12 += s22 * 654183
+	s13 -= s22 * 997805
+	s14 += s22 * 136657
+	s15 -= s22 * 683901
+	s22 = 0
+
+	s9 += s21 * 666643
+	s10 += s21 * 470296
+	s11 += s21 * 654183
+	s12 -= s21 * 997805
+	s13 += s21 * 136657
+	s14 -= s21 * 683901
+	s21 = 0
+
+	s8 += s20 * 666643
+	s9 += s20 * 470296
+	s10 += s20 * 654183
+	s11 -= s20 * 997805
+	s12 += s20 * 136657
+	s13 -= s20 * 683901
+	s20 = 0
+
+	s7 += s19 * 666643
+	s8 += s19 * 470296
+	s9 += s19 * 654183
+	s10 -= s19 * 997805
+	s11 += s19 * 136657
+	s12 -= s19 * 683901
+	s19 = 0
+
+	s6 += s18 * 666643
+	s7 += s18 * 470296
+	s8 += s18 * 654183
+	s9 -= s18 * 997805
+	s10 += s18 * 136657
+	s11 -= s18 * 683901
+	s18 = 0
+
+	var carry [17]int64
+
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[12] = (s12 + (1 << 20)) >> 21
+	s13 += carry[12]
+	s12 -= carry[12] << 21
+	carry[14] = (s14 + (1 << 20)) >> 21
+	s15 += carry[14]
+	s14 -= carry[14] << 21
+	carry[16] = (s16 + (1 << 20)) >> 21
+	s17 += carry[16]
+	s16 -= carry[16] << 21
+
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+	carry[13] = (s13 + (1 << 20)) >> 21
+	s14 += carry[13]
+	s13 -= carry[13] << 21
+	carry[15] = (s15 + (1 << 20)) >> 21
+	s16 += carry[15]
+	s15 -= carry[15] << 21
+
+	s5 += s17 * 666643
+	s6 += s17 * 470296
+	s7 += s17 * 654183
+	s8 -= s17 * 997805
+	s9 += s17 * 136657
+	s10 -= s17 * 683901
+	s17 = 0
+
+	s4 += s16 * 666643
+	s5 += s16 * 470296
+	s6 += s16 * 654183
+	s7 -= s16 * 997805
+	s8 += s16 * 136657
+	s9 -= s16 * 683901
+	s16 = 0
+
+	s3 += s15 * 666643
+	s4 += s15 * 470296
+	s5 += s15 * 654183
+	s6 -= s15 * 997805
+	s7 += s15 * 136657
+	s8 -= s15 * 683901
+	s15 = 0
+
+	s2 += s14 * 666643
+	s3 += s14 * 470296
+	s4 += s14 * 654183
+	s5 -= s14 * 997805
+	s6 += s14 * 136657
+	s7 -= s14 * 683901
+	s14 = 0
+
+	s1 += s13 * 666643
+	s2 += s13 * 470296
+	s3 += s13 * 654183
+	s4 -= s13 * 997805
+	s5 += s13 * 136657
+	s6 -= s13 * 683901
+	s13 = 0
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = (s0 + (1 << 20)) >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[2] = (s2 + (1 << 20)) >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[4] = (s4 + (1 << 20)) >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[6] = (s6 + (1 << 20)) >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[8] = (s8 + (1 << 20)) >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[10] = (s10 + (1 << 20)) >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	carry[1] = (s1 + (1 << 20)) >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[3] = (s3 + (1 << 20)) >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[5] = (s5 + (1 << 20)) >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[7] = (s7 + (1 << 20)) >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[9] = (s9 + (1 << 20)) >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[11] = (s11 + (1 << 20)) >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+	carry[11] = s11 >> 21
+	s12 += carry[11]
+	s11 -= carry[11] << 21
+
+	s0 += s12 * 666643
+	s1 += s12 * 470296
+	s2 += s12 * 654183
+	s3 -= s12 * 997805
+	s4 += s12 * 136657
+	s5 -= s12 * 683901
+	s12 = 0
+
+	carry[0] = s0 >> 21
+	s1 += carry[0]
+	s0 -= carry[0] << 21
+	carry[1] = s1 >> 21
+	s2 += carry[1]
+	s1 -= carry[1] << 21
+	carry[2] = s2 >> 21
+	s3 += carry[2]
+	s2 -= carry[2] << 21
+	carry[3] = s3 >> 21
+	s4 += carry[3]
+	s3 -= carry[3] << 21
+	carry[4] = s4 >> 21
+	s5 += carry[4]
+	s4 -= carry[4] << 21
+	carry[5] = s5 >> 21
+	s6 += carry[5]
+	s5 -= carry[5] << 21
+	carry[6] = s6 >> 21
+	s7 += carry[6]
+	s6 -= carry[6] << 21
+	carry[7] = s7 >> 21
+	s8 += carry[7]
+	s7 -= carry[7] << 21
+	carry[8] = s8 >> 21
+	s9 += carry[8]
+	s8 -= carry[8] << 21
+	carry[9] = s9 >> 21
+	s10 += carry[9]
+	s9 -= carry[9] << 21
+	carry[10] = s10 >> 21
+	s11 += carry[10]
+	s10 -= carry[10] << 21
+
+	out[0] = byte(s0 >> 0)
+	out[1] = byte(s0 >> 8)
+	out[2] = byte((s0 >> 16) | (s1 << 5))
+	out[3] = byte(s1 >> 3)
+	out[4] = byte(s1 >> 11)
+	out[5] = byte((s1 >> 19) | (s2 << 2))
+	out[6] = byte(s2 >> 6)
+	out[7] = byte((s2 >> 14) | (s3 << 7))
+	out[8] = byte(s3 >> 1)
+	out[9] = byte(s3 >> 9)
+	out[10] = byte((s3 >> 17) | (s4 << 4))
+	out[11] = byte(s4 >> 4)
+	out[12] = byte(s4 >> 12)
+	out[13] = byte((s4 >> 20) | (s5 << 1))
+	out[14] = byte(s5 >> 7)
+	out[15] = byte((s5 >> 15) | (s6 << 6))
+	out[16] = byte(s6 >> 2)
+	out[17] = byte(s6 >> 10)
+	out[18] = byte((s6 >> 18) | (s7 << 3))
+	out[19] = byte(s7 >> 5)
+	out[20] = byte(s7 >> 13)
+	out[21] = byte(s8 >> 0)
+	out[22] = byte(s8 >> 8)
+	out[23] = byte((s8 >> 16) | (s9 << 5))
+	out[24] = byte(s9 >> 3)
+	out[25] = byte(s9 >> 11)
+	out[26] = byte((s9 >> 19) | (s10 << 2))
+	out[27] = byte(s10 >> 6)
+	out[28] = byte((s10 >> 14) | (s11 << 7))
+	out[29] = byte(s11 >> 1)
+	out[30] = byte(s11 >> 9)
+	out[31] = byte(s11 >> 17)
+}
diff --git a/vendor/github.com/agl/ed25519/extra25519/extra25519.go b/vendor/github.com/agl/ed25519/extra25519/extra25519.go
new file mode 100644
index 000000000..b897ba538
--- /dev/null
+++ b/vendor/github.com/agl/ed25519/extra25519/extra25519.go
@@ -0,0 +1,340 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package extra25519
+
+import (
+	"crypto/sha512"
+
+	"github.com/agl/ed25519/edwards25519"
+)
+
+// PrivateKeyToCurve25519 converts an ed25519 private key into a corresponding
+// curve25519 private key such that the resulting curve25519 public key will
+// equal the result from PublicKeyToCurve25519.
+func PrivateKeyToCurve25519(curve25519Private *[32]byte, privateKey *[64]byte) {
+	h := sha512.New()
+	h.Write(privateKey[:32])
+	digest := h.Sum(nil)
+
+	digest[0] &= 248
+	digest[31] &= 127
+	digest[31] |= 64
+
+	copy(curve25519Private[:], digest)
+}
+
+func edwardsToMontgomeryX(outX, y *edwards25519.FieldElement) {
+	// We only need the x-coordinate of the curve25519 point, which I'll
+	// call u. The isomorphism is u=(y+1)/(1-y), since y=Y/Z, this gives
+	// u=(Y+Z)/(Z-Y). We know that Z=1, thus u=(Y+1)/(1-Y).
+	var oneMinusY edwards25519.FieldElement
+	edwards25519.FeOne(&oneMinusY)
+	edwards25519.FeSub(&oneMinusY, &oneMinusY, y)
+	edwards25519.FeInvert(&oneMinusY, &oneMinusY)
+
+	edwards25519.FeOne(outX)
+	edwards25519.FeAdd(outX, outX, y)
+
+	edwards25519.FeMul(outX, outX, &oneMinusY)
+}
+
+// PublicKeyToCurve25519 converts an Ed25519 public key into the curve25519
+// public key that would be generated from the same private key.
+func PublicKeyToCurve25519(curve25519Public *[32]byte, publicKey *[32]byte) bool {
+	var A edwards25519.ExtendedGroupElement
+	if !A.FromBytes(publicKey) {
+		return false
+	}
+
+	// A.Z = 1 as a postcondition of FromBytes.
+	var x edwards25519.FieldElement
+	edwardsToMontgomeryX(&x, &A.Y)
+	edwards25519.FeToBytes(curve25519Public, &x)
+	return true
+}
+
+// sqrtMinusAPlus2 is sqrt(-(486662+2))
+var sqrtMinusAPlus2 = edwards25519.FieldElement{
+	-12222970, -8312128, -11511410, 9067497, -15300785, -241793, 25456130, 14121551, -12187136, 3972024,
+}
+
+// sqrtMinusHalf is sqrt(-1/2)
+var sqrtMinusHalf = edwards25519.FieldElement{
+	-17256545, 3971863, 28865457, -1750208, 27359696, -16640980, 12573105, 1002827, -163343, 11073975,
+}
+
+// halfQMinus1Bytes is (2^255-20)/2 expressed in little endian form.
+var halfQMinus1Bytes = [32]byte{
+	0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
+}
+
+// feBytesLess returns one if a <= b and zero otherwise.
+func feBytesLE(a, b *[32]byte) int32 {
+	equalSoFar := int32(-1)
+	greater := int32(0)
+
+	for i := uint(31); i < 32; i-- {
+		x := int32(a[i])
+		y := int32(b[i])
+
+		greater = (^equalSoFar & greater) | (equalSoFar & ((x - y) >> 31))
+		equalSoFar = equalSoFar & (((x ^ y) - 1) >> 31)
+	}
+
+	return int32(^equalSoFar & 1 & greater)
+}
+
+// ScalarBaseMult computes a curve25519 public key from a private key and also
+// a uniform representative for that public key. Note that this function will
+// fail and return false for about half of private keys.
+// See http://elligator.cr.yp.to/elligator-20130828.pdf.
+func ScalarBaseMult(publicKey, representative, privateKey *[32]byte) bool {
+	var maskedPrivateKey [32]byte
+	copy(maskedPrivateKey[:], privateKey[:])
+
+	maskedPrivateKey[0] &= 248
+	maskedPrivateKey[31] &= 127
+	maskedPrivateKey[31] |= 64
+
+	var A edwards25519.ExtendedGroupElement
+	edwards25519.GeScalarMultBase(&A, &maskedPrivateKey)
+
+	var inv1 edwards25519.FieldElement
+	edwards25519.FeSub(&inv1, &A.Z, &A.Y)
+	edwards25519.FeMul(&inv1, &inv1, &A.X)
+	edwards25519.FeInvert(&inv1, &inv1)
+
+	var t0, u edwards25519.FieldElement
+	edwards25519.FeMul(&u, &inv1, &A.X)
+	edwards25519.FeAdd(&t0, &A.Y, &A.Z)
+	edwards25519.FeMul(&u, &u, &t0)
+
+	var v edwards25519.FieldElement
+	edwards25519.FeMul(&v, &t0, &inv1)
+	edwards25519.FeMul(&v, &v, &A.Z)
+	edwards25519.FeMul(&v, &v, &sqrtMinusAPlus2)
+
+	var b edwards25519.FieldElement
+	edwards25519.FeAdd(&b, &u, &edwards25519.A)
+
+	var c, b3, b7, b8 edwards25519.FieldElement
+	edwards25519.FeSquare(&b3, &b)   // 2
+	edwards25519.FeMul(&b3, &b3, &b) // 3
+	edwards25519.FeSquare(&c, &b3)   // 6
+	edwards25519.FeMul(&b7, &c, &b)  // 7
+	edwards25519.FeMul(&b8, &b7, &b) // 8
+	edwards25519.FeMul(&c, &b7, &u)
+	q58(&c, &c)
+
+	var chi edwards25519.FieldElement
+	edwards25519.FeSquare(&chi, &c)
+	edwards25519.FeSquare(&chi, &chi)
+
+	edwards25519.FeSquare(&t0, &u)
+	edwards25519.FeMul(&chi, &chi, &t0)
+
+	edwards25519.FeSquare(&t0, &b7) // 14
+	edwards25519.FeMul(&chi, &chi, &t0)
+	edwards25519.FeNeg(&chi, &chi)
+
+	var chiBytes [32]byte
+	edwards25519.FeToBytes(&chiBytes, &chi)
+	// chi[1] is either 0 or 0xff
+	if chiBytes[1] == 0xff {
+		return false
+	}
+
+	// Calculate r1 = sqrt(-u/(2*(u+A)))
+	var r1 edwards25519.FieldElement
+	edwards25519.FeMul(&r1, &c, &u)
+	edwards25519.FeMul(&r1, &r1, &b3)
+	edwards25519.FeMul(&r1, &r1, &sqrtMinusHalf)
+
+	var maybeSqrtM1 edwards25519.FieldElement
+	edwards25519.FeSquare(&t0, &r1)
+	edwards25519.FeMul(&t0, &t0, &b)
+	edwards25519.FeAdd(&t0, &t0, &t0)
+	edwards25519.FeAdd(&t0, &t0, &u)
+
+	edwards25519.FeOne(&maybeSqrtM1)
+	edwards25519.FeCMove(&maybeSqrtM1, &edwards25519.SqrtM1, edwards25519.FeIsNonZero(&t0))
+	edwards25519.FeMul(&r1, &r1, &maybeSqrtM1)
+
+	// Calculate r = sqrt(-(u+A)/(2u))
+	var r edwards25519.FieldElement
+	edwards25519.FeSquare(&t0, &c)   // 2
+	edwards25519.FeMul(&t0, &t0, &c) // 3
+	edwards25519.FeSquare(&t0, &t0)  // 6
+	edwards25519.FeMul(&r, &t0, &c)  // 7
+
+	edwards25519.FeSquare(&t0, &u)   // 2
+	edwards25519.FeMul(&t0, &t0, &u) // 3
+	edwards25519.FeMul(&r, &r, &t0)
+
+	edwards25519.FeSquare(&t0, &b8)   // 16
+	edwards25519.FeMul(&t0, &t0, &b8) // 24
+	edwards25519.FeMul(&t0, &t0, &b)  // 25
+	edwards25519.FeMul(&r, &r, &t0)
+	edwards25519.FeMul(&r, &r, &sqrtMinusHalf)
+
+	edwards25519.FeSquare(&t0, &r)
+	edwards25519.FeMul(&t0, &t0, &u)
+	edwards25519.FeAdd(&t0, &t0, &t0)
+	edwards25519.FeAdd(&t0, &t0, &b)
+	edwards25519.FeOne(&maybeSqrtM1)
+	edwards25519.FeCMove(&maybeSqrtM1, &edwards25519.SqrtM1, edwards25519.FeIsNonZero(&t0))
+	edwards25519.FeMul(&r, &r, &maybeSqrtM1)
+
+	var vBytes [32]byte
+	edwards25519.FeToBytes(&vBytes, &v)
+	vInSquareRootImage := feBytesLE(&vBytes, &halfQMinus1Bytes)
+	edwards25519.FeCMove(&r, &r1, vInSquareRootImage)
+
+	edwards25519.FeToBytes(publicKey, &u)
+	edwards25519.FeToBytes(representative, &r)
+	return true
+}
+
+// q58 calculates out = z^((p-5)/8).
+func q58(out, z *edwards25519.FieldElement) {
+	var t1, t2, t3 edwards25519.FieldElement
+	var i int
+
+	edwards25519.FeSquare(&t1, z)     // 2^1
+	edwards25519.FeMul(&t1, &t1, z)   // 2^1 + 2^0
+	edwards25519.FeSquare(&t1, &t1)   // 2^2 + 2^1
+	edwards25519.FeSquare(&t2, &t1)   // 2^3 + 2^2
+	edwards25519.FeSquare(&t2, &t2)   // 2^4 + 2^3
+	edwards25519.FeMul(&t2, &t2, &t1) // 4,3,2,1
+	edwards25519.FeMul(&t1, &t2, z)   // 4..0
+	edwards25519.FeSquare(&t2, &t1)   // 5..1
+	for i = 1; i < 5; i++ {           // 9,8,7,6,5
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+	edwards25519.FeSquare(&t2, &t1)   // 10..1
+	for i = 1; i < 10; i++ {          // 19..10
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t2, &t2, &t1) // 19..0
+	edwards25519.FeSquare(&t3, &t2)   // 20..1
+	for i = 1; i < 20; i++ {          // 39..20
+		edwards25519.FeSquare(&t3, &t3)
+	}
+	edwards25519.FeMul(&t2, &t3, &t2) // 39..0
+	edwards25519.FeSquare(&t2, &t2)   // 40..1
+	for i = 1; i < 10; i++ {          // 49..10
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 49..0
+	edwards25519.FeSquare(&t2, &t1)   // 50..1
+	for i = 1; i < 50; i++ {          // 99..50
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t2, &t2, &t1) // 99..0
+	edwards25519.FeSquare(&t3, &t2)   // 100..1
+	for i = 1; i < 100; i++ {         // 199..100
+		edwards25519.FeSquare(&t3, &t3)
+	}
+	edwards25519.FeMul(&t2, &t3, &t2) // 199..0
+	edwards25519.FeSquare(&t2, &t2)   // 200..1
+	for i = 1; i < 50; i++ {          // 249..50
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 249..0
+	edwards25519.FeSquare(&t1, &t1)   // 250..1
+	edwards25519.FeSquare(&t1, &t1)   // 251..2
+	edwards25519.FeMul(out, &t1, z)   // 251..2,0
+}
+
+// chi calculates out = z^((p-1)/2). The result is either 1, 0, or -1 depending
+// on whether z is a non-zero square, zero, or a non-square.
+func chi(out, z *edwards25519.FieldElement) {
+	var t0, t1, t2, t3 edwards25519.FieldElement
+	var i int
+
+	edwards25519.FeSquare(&t0, z)     // 2^1
+	edwards25519.FeMul(&t1, &t0, z)   // 2^1 + 2^0
+	edwards25519.FeSquare(&t0, &t1)   // 2^2 + 2^1
+	edwards25519.FeSquare(&t2, &t0)   // 2^3 + 2^2
+	edwards25519.FeSquare(&t2, &t2)   // 4,3
+	edwards25519.FeMul(&t2, &t2, &t0) // 4,3,2,1
+	edwards25519.FeMul(&t1, &t2, z)   // 4..0
+	edwards25519.FeSquare(&t2, &t1)   // 5..1
+	for i = 1; i < 5; i++ {           // 9,8,7,6,5
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
+	edwards25519.FeSquare(&t2, &t1)   // 10..1
+	for i = 1; i < 10; i++ {          // 19..10
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t2, &t2, &t1) // 19..0
+	edwards25519.FeSquare(&t3, &t2)   // 20..1
+	for i = 1; i < 20; i++ {          // 39..20
+		edwards25519.FeSquare(&t3, &t3)
+	}
+	edwards25519.FeMul(&t2, &t3, &t2) // 39..0
+	edwards25519.FeSquare(&t2, &t2)   // 40..1
+	for i = 1; i < 10; i++ {          // 49..10
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 49..0
+	edwards25519.FeSquare(&t2, &t1)   // 50..1
+	for i = 1; i < 50; i++ {          // 99..50
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t2, &t2, &t1) // 99..0
+	edwards25519.FeSquare(&t3, &t2)   // 100..1
+	for i = 1; i < 100; i++ {         // 199..100
+		edwards25519.FeSquare(&t3, &t3)
+	}
+	edwards25519.FeMul(&t2, &t3, &t2) // 199..0
+	edwards25519.FeSquare(&t2, &t2)   // 200..1
+	for i = 1; i < 50; i++ {          // 249..50
+		edwards25519.FeSquare(&t2, &t2)
+	}
+	edwards25519.FeMul(&t1, &t2, &t1) // 249..0
+	edwards25519.FeSquare(&t1, &t1)   // 250..1
+	for i = 1; i < 4; i++ {           // 253..4
+		edwards25519.FeSquare(&t1, &t1)
+	}
+	edwards25519.FeMul(out, &t1, &t0) // 253..4,2,1
+}
+
+// RepresentativeToPublicKey converts a uniform representative value for a
+// curve25519 public key, as produced by ScalarBaseMult, to a curve25519 public
+// key.
+func RepresentativeToPublicKey(publicKey, representative *[32]byte) {
+	var rr2, v, e edwards25519.FieldElement
+	edwards25519.FeFromBytes(&rr2, representative)
+
+	edwards25519.FeSquare2(&rr2, &rr2)
+	rr2[0]++
+	edwards25519.FeInvert(&rr2, &rr2)
+	edwards25519.FeMul(&v, &edwards25519.A, &rr2)
+	edwards25519.FeNeg(&v, &v)
+
+	var v2, v3 edwards25519.FieldElement
+	edwards25519.FeSquare(&v2, &v)
+	edwards25519.FeMul(&v3, &v, &v2)
+	edwards25519.FeAdd(&e, &v3, &v)
+	edwards25519.FeMul(&v2, &v2, &edwards25519.A)
+	edwards25519.FeAdd(&e, &v2, &e)
+	chi(&e, &e)
+	var eBytes [32]byte
+	edwards25519.FeToBytes(&eBytes, &e)
+	// eBytes[1] is either 0 (for e = 1) or 0xff (for e = -1)
+	eIsMinus1 := int32(eBytes[1]) & 1
+	var negV edwards25519.FieldElement
+	edwards25519.FeNeg(&negV, &v)
+	edwards25519.FeCMove(&v, &negV, eIsMinus1)
+
+	edwards25519.FeZero(&v2)
+	edwards25519.FeCMove(&v2, &edwards25519.A, eIsMinus1)
+	edwards25519.FeSub(&v, &v, &v2)
+
+	edwards25519.FeToBytes(publicKey, &v)
+}
diff --git a/vendor/github.com/coreos/go-semver/LICENSE b/vendor/github.com/coreos/go-semver/LICENSE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/vendor/github.com/coreos/go-semver/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/github.com/coreos/go-semver/semver/semver.go b/vendor/github.com/coreos/go-semver/semver/semver.go
new file mode 100644
index 000000000..110fc23e1
--- /dev/null
+++ b/vendor/github.com/coreos/go-semver/semver/semver.go
@@ -0,0 +1,268 @@
+// Copyright 2013-2015 CoreOS, Inc.
+//
+// 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.
+
+// Semantic Versions http://semver.org
+package semver
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Version struct {
+	Major      int64
+	Minor      int64
+	Patch      int64
+	PreRelease PreRelease
+	Metadata   string
+}
+
+type PreRelease string
+
+func splitOff(input *string, delim string) (val string) {
+	parts := strings.SplitN(*input, delim, 2)
+
+	if len(parts) == 2 {
+		*input = parts[0]
+		val = parts[1]
+	}
+
+	return val
+}
+
+func New(version string) *Version {
+	return Must(NewVersion(version))
+}
+
+func NewVersion(version string) (*Version, error) {
+	v := Version{}
+
+	if err := v.Set(version); err != nil {
+		return nil, err
+	}
+
+	return &v, nil
+}
+
+// Must is a helper for wrapping NewVersion and will panic if err is not nil.
+func Must(v *Version, err error) *Version {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Set parses and updates v from the given version string. Implements flag.Value
+func (v *Version) Set(version string) error {
+	metadata := splitOff(&version, "+")
+	preRelease := PreRelease(splitOff(&version, "-"))
+	dotParts := strings.SplitN(version, ".", 3)
+
+	if len(dotParts) != 3 {
+		return fmt.Errorf("%s is not in dotted-tri format", version)
+	}
+
+	parsed := make([]int64, 3, 3)
+
+	for i, v := range dotParts[:3] {
+		val, err := strconv.ParseInt(v, 10, 64)
+		parsed[i] = val
+		if err != nil {
+			return err
+		}
+	}
+
+	v.Metadata = metadata
+	v.PreRelease = preRelease
+	v.Major = parsed[0]
+	v.Minor = parsed[1]
+	v.Patch = parsed[2]
+	return nil
+}
+
+func (v Version) String() string {
+	var buffer bytes.Buffer
+
+	fmt.Fprintf(&buffer, "%d.%d.%d", v.Major, v.Minor, v.Patch)
+
+	if v.PreRelease != "" {
+		fmt.Fprintf(&buffer, "-%s", v.PreRelease)
+	}
+
+	if v.Metadata != "" {
+		fmt.Fprintf(&buffer, "+%s", v.Metadata)
+	}
+
+	return buffer.String()
+}
+
+func (v *Version) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var data string
+	if err := unmarshal(&data); err != nil {
+		return err
+	}
+	return v.Set(data)
+}
+
+func (v Version) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + v.String() + `"`), nil
+}
+
+func (v *Version) UnmarshalJSON(data []byte) error {
+	l := len(data)
+	if l == 0 || string(data) == `""` {
+		return nil
+	}
+	if l < 2 || data[0] != '"' || data[l-1] != '"' {
+		return errors.New("invalid semver string")
+	}
+	return v.Set(string(data[1 : l-1]))
+}
+
+// Compare tests if v is less than, equal to, or greater than versionB,
+// returning -1, 0, or +1 respectively.
+func (v Version) Compare(versionB Version) int {
+	if cmp := recursiveCompare(v.Slice(), versionB.Slice()); cmp != 0 {
+		return cmp
+	}
+	return preReleaseCompare(v, versionB)
+}
+
+// Equal tests if v is equal to versionB.
+func (v Version) Equal(versionB Version) bool {
+	return v.Compare(versionB) == 0
+}
+
+// LessThan tests if v is less than versionB.
+func (v Version) LessThan(versionB Version) bool {
+	return v.Compare(versionB) < 0
+}
+
+// Slice converts the comparable parts of the semver into a slice of integers.
+func (v Version) Slice() []int64 {
+	return []int64{v.Major, v.Minor, v.Patch}
+}
+
+func (p PreRelease) Slice() []string {
+	preRelease := string(p)
+	return strings.Split(preRelease, ".")
+}
+
+func preReleaseCompare(versionA Version, versionB Version) int {
+	a := versionA.PreRelease
+	b := versionB.PreRelease
+
+	/* Handle the case where if two versions are otherwise equal it is the
+	 * one without a PreRelease that is greater */
+	if len(a) == 0 && (len(b) > 0) {
+		return 1
+	} else if len(b) == 0 && (len(a) > 0) {
+		return -1
+	}
+
+	// If there is a prerelease, check and compare each part.
+	return recursivePreReleaseCompare(a.Slice(), b.Slice())
+}
+
+func recursiveCompare(versionA []int64, versionB []int64) int {
+	if len(versionA) == 0 {
+		return 0
+	}
+
+	a := versionA[0]
+	b := versionB[0]
+
+	if a > b {
+		return 1
+	} else if a < b {
+		return -1
+	}
+
+	return recursiveCompare(versionA[1:], versionB[1:])
+}
+
+func recursivePreReleaseCompare(versionA []string, versionB []string) int {
+	// A larger set of pre-release fields has a higher precedence than a smaller set,
+	// if all of the preceding identifiers are equal.
+	if len(versionA) == 0 {
+		if len(versionB) > 0 {
+			return -1
+		}
+		return 0
+	} else if len(versionB) == 0 {
+		// We're longer than versionB so return 1.
+		return 1
+	}
+
+	a := versionA[0]
+	b := versionB[0]
+
+	aInt := false
+	bInt := false
+
+	aI, err := strconv.Atoi(versionA[0])
+	if err == nil {
+		aInt = true
+	}
+
+	bI, err := strconv.Atoi(versionB[0])
+	if err == nil {
+		bInt = true
+	}
+
+	// Handle Integer Comparison
+	if aInt && bInt {
+		if aI > bI {
+			return 1
+		} else if aI < bI {
+			return -1
+		}
+	}
+
+	// Handle String Comparison
+	if a > b {
+		return 1
+	} else if a < b {
+		return -1
+	}
+
+	return recursivePreReleaseCompare(versionA[1:], versionB[1:])
+}
+
+// BumpMajor increments the Major field by 1 and resets all other fields to their default values
+func (v *Version) BumpMajor() {
+	v.Major += 1
+	v.Minor = 0
+	v.Patch = 0
+	v.PreRelease = PreRelease("")
+	v.Metadata = ""
+}
+
+// BumpMinor increments the Minor field by 1 and resets all other fields to their default values
+func (v *Version) BumpMinor() {
+	v.Minor += 1
+	v.Patch = 0
+	v.PreRelease = PreRelease("")
+	v.Metadata = ""
+}
+
+// BumpPatch increments the Patch field by 1 and resets all other fields to their default values
+func (v *Version) BumpPatch() {
+	v.Patch += 1
+	v.PreRelease = PreRelease("")
+	v.Metadata = ""
+}
diff --git a/vendor/github.com/coreos/go-semver/semver/sort.go b/vendor/github.com/coreos/go-semver/semver/sort.go
new file mode 100644
index 000000000..e256b41a5
--- /dev/null
+++ b/vendor/github.com/coreos/go-semver/semver/sort.go
@@ -0,0 +1,38 @@
+// Copyright 2013-2015 CoreOS, Inc.
+//
+// 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 semver
+
+import (
+	"sort"
+)
+
+type Versions []*Version
+
+func (s Versions) Len() int {
+	return len(s)
+}
+
+func (s Versions) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s Versions) Less(i, j int) bool {
+	return s[i].LessThan(*s[j])
+}
+
+// Sort sorts the given slice of Version
+func Sort(versions []*Version) {
+	sort.Sort(Versions(versions))
+}
diff --git a/vendor/github.com/fd/go-nat/LICENSE b/vendor/github.com/fd/go-nat/LICENSE
new file mode 100644
index 000000000..37ec93a14
--- /dev/null
+++ b/vendor/github.com/fd/go-nat/LICENSE
@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/fd/go-nat/nat.go b/vendor/github.com/fd/go-nat/nat.go
new file mode 100644
index 000000000..3cf964858
--- /dev/null
+++ b/vendor/github.com/fd/go-nat/nat.go
@@ -0,0 +1,54 @@
+// Package nat implements NAT handling facilities
+package nat
+
+import (
+	"errors"
+	"math"
+	"math/rand"
+	"net"
+	"time"
+)
+
+var ErrNoExternalAddress = errors.New("no external address")
+var ErrNoInternalAddress = errors.New("no internal address")
+var ErrNoNATFound = errors.New("no NAT found")
+
+// protocol is either "udp" or "tcp"
+type NAT interface {
+	// Type returns the kind of NAT port mapping service that is used
+	Type() string
+
+	// GetDeviceAddress returns the internal address of the gateway device.
+	GetDeviceAddress() (addr net.IP, err error)
+
+	// GetExternalAddress returns the external address of the gateway device.
+	GetExternalAddress() (addr net.IP, err error)
+
+	// GetInternalAddress returns the address of the local host.
+	GetInternalAddress() (addr net.IP, err error)
+
+	// AddPortMapping maps a port on the local host to an external port.
+	AddPortMapping(protocol string, internalPort int, description string, timeout time.Duration) (mappedExternalPort int, err error)
+
+	// DeletePortMapping removes a port mapping.
+	DeletePortMapping(protocol string, internalPort int) (err error)
+}
+
+// DiscoverGateway attempts to find a gateway device.
+func DiscoverGateway() (NAT, error) {
+	select {
+	case nat := <-discoverUPNP_IG1():
+		return nat, nil
+	case nat := <-discoverUPNP_IG2():
+		return nat, nil
+	case nat := <-discoverNATPMP():
+		return nat, nil
+	case <-time.After(10 * time.Second):
+		return nil, ErrNoNATFound
+	}
+}
+
+func randomPort() int {
+	rand.Seed(time.Now().UnixNano())
+	return rand.Intn(math.MaxUint16-10000) + 10000
+}
diff --git a/vendor/github.com/fd/go-nat/natpmp.go b/vendor/github.com/fd/go-nat/natpmp.go
new file mode 100644
index 000000000..395a5dd57
--- /dev/null
+++ b/vendor/github.com/fd/go-nat/natpmp.go
@@ -0,0 +1,115 @@
+package nat
+
+import (
+	"net"
+	"time"
+
+	"github.com/jackpal/gateway"
+	"github.com/jackpal/go-nat-pmp"
+)
+
+var (
+	_ NAT = (*natpmpNAT)(nil)
+)
+
+func discoverNATPMP() <-chan NAT {
+	res := make(chan NAT, 1)
+
+	ip, err := gateway.DiscoverGateway()
+	if err == nil {
+		go discoverNATPMPWithAddr(res, ip)
+	}
+
+	return res
+}
+
+func discoverNATPMPWithAddr(c chan NAT, ip net.IP) {
+	client := natpmp.NewClient(ip)
+	_, err := client.GetExternalAddress()
+	if err != nil {
+		return
+	}
+
+	c <- &natpmpNAT{client, ip, make(map[int]int)}
+}
+
+type natpmpNAT struct {
+	c       *natpmp.Client
+	gateway net.IP
+	ports   map[int]int
+}
+
+func (n *natpmpNAT) GetDeviceAddress() (addr net.IP, err error) {
+	return n.gateway, nil
+}
+
+func (n *natpmpNAT) GetInternalAddress() (addr net.IP, err error) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, iface := range ifaces {
+		addrs, err := iface.Addrs()
+		if err != nil {
+			return nil, err
+		}
+
+		for _, addr := range addrs {
+			switch x := addr.(type) {
+			case *net.IPNet:
+				if x.Contains(n.gateway) {
+					return x.IP, nil
+				}
+			}
+		}
+	}
+
+	return nil, ErrNoInternalAddress
+}
+
+func (n *natpmpNAT) GetExternalAddress() (addr net.IP, err error) {
+	res, err := n.c.GetExternalAddress()
+	if err != nil {
+		return nil, err
+	}
+
+	d := res.ExternalIPAddress
+	return net.IPv4(d[0], d[1], d[2], d[3]), nil
+}
+
+func (n *natpmpNAT) AddPortMapping(protocol string, internalPort int, description string, timeout time.Duration) (int, error) {
+	var (
+		err error
+	)
+
+	timeoutInSeconds := int(timeout / time.Second)
+
+	if externalPort := n.ports[internalPort]; externalPort > 0 {
+		_, err = n.c.AddPortMapping(protocol, internalPort, externalPort, timeoutInSeconds)
+		if err == nil {
+			n.ports[internalPort] = externalPort
+			return externalPort, nil
+		}
+	}
+
+	for i := 0; i < 3; i++ {
+		externalPort := randomPort()
+		_, err = n.c.AddPortMapping(protocol, internalPort, externalPort, timeoutInSeconds)
+		if err == nil {
+			n.ports[internalPort] = externalPort
+			return externalPort, nil
+		}
+	}
+
+	return 0, err
+}
+
+func (n *natpmpNAT) DeletePortMapping(protocol string, internalPort int) (err error) {
+	delete(n.ports, internalPort)
+	return nil
+}
+
+func (n *natpmpNAT) Type() string {
+	return "NAT-PMP"
+}
diff --git a/vendor/github.com/fd/go-nat/upnp.go b/vendor/github.com/fd/go-nat/upnp.go
new file mode 100644
index 000000000..86d6e9b3b
--- /dev/null
+++ b/vendor/github.com/fd/go-nat/upnp.go
@@ -0,0 +1,239 @@
+package nat
+
+import (
+	"net"
+	"time"
+
+	"github.com/huin/goupnp"
+	"github.com/huin/goupnp/dcps/internetgateway1"
+	"github.com/huin/goupnp/dcps/internetgateway2"
+)
+
+var (
+	_ NAT = (*upnp_NAT)(nil)
+)
+
+func discoverUPNP_IG1() <-chan NAT {
+	res := make(chan NAT, 1)
+	go func() {
+
+		// find devices
+		devs, err := goupnp.DiscoverDevices(internetgateway1.URN_WANConnectionDevice_1)
+		if err != nil {
+			return
+		}
+
+		for _, dev := range devs {
+			if dev.Root == nil {
+				continue
+			}
+
+			dev.Root.Device.VisitServices(func(srv *goupnp.Service) {
+				switch srv.ServiceType {
+				case internetgateway1.URN_WANIPConnection_1:
+					client := &internetgateway1.WANIPConnection1{ServiceClient: goupnp.ServiceClient{
+						SOAPClient: srv.NewSOAPClient(),
+						RootDevice: dev.Root,
+						Service:    srv,
+					}}
+					_, isNat, err := client.GetNATRSIPStatus()
+					if err == nil && isNat {
+						res <- &upnp_NAT{client, make(map[int]int), "UPNP (IG1-IP1)", dev.Root}
+						return
+					}
+
+				case internetgateway1.URN_WANPPPConnection_1:
+					client := &internetgateway1.WANPPPConnection1{ServiceClient: goupnp.ServiceClient{
+						SOAPClient: srv.NewSOAPClient(),
+						RootDevice: dev.Root,
+						Service:    srv,
+					}}
+					_, isNat, err := client.GetNATRSIPStatus()
+					if err == nil && isNat {
+						res <- &upnp_NAT{client, make(map[int]int), "UPNP (IG1-PPP1)", dev.Root}
+						return
+					}
+
+				}
+			})
+		}
+
+	}()
+	return res
+}
+
+func discoverUPNP_IG2() <-chan NAT {
+	res := make(chan NAT, 1)
+	go func() {
+
+		// find devices
+		devs, err := goupnp.DiscoverDevices(internetgateway2.URN_WANConnectionDevice_2)
+		if err != nil {
+			return
+		}
+
+		for _, dev := range devs {
+			if dev.Root == nil {
+				continue
+			}
+
+			dev.Root.Device.VisitServices(func(srv *goupnp.Service) {
+				switch srv.ServiceType {
+				case internetgateway2.URN_WANIPConnection_1:
+					client := &internetgateway2.WANIPConnection1{ServiceClient: goupnp.ServiceClient{
+						SOAPClient: srv.NewSOAPClient(),
+						RootDevice: dev.Root,
+						Service:    srv,
+					}}
+					_, isNat, err := client.GetNATRSIPStatus()
+					if err == nil && isNat {
+						res <- &upnp_NAT{client, make(map[int]int), "UPNP (IG2-IP1)", dev.Root}
+						return
+					}
+
+				case internetgateway2.URN_WANIPConnection_2:
+					client := &internetgateway2.WANIPConnection2{ServiceClient: goupnp.ServiceClient{
+						SOAPClient: srv.NewSOAPClient(),
+						RootDevice: dev.Root,
+						Service:    srv,
+					}}
+					_, isNat, err := client.GetNATRSIPStatus()
+					if err == nil && isNat {
+						res <- &upnp_NAT{client, make(map[int]int), "UPNP (IG2-IP2)", dev.Root}
+						return
+					}
+
+				case internetgateway2.URN_WANPPPConnection_1:
+					client := &internetgateway2.WANPPPConnection1{ServiceClient: goupnp.ServiceClient{
+						SOAPClient: srv.NewSOAPClient(),
+						RootDevice: dev.Root,
+						Service:    srv,
+					}}
+					_, isNat, err := client.GetNATRSIPStatus()
+					if err == nil && isNat {
+						res <- &upnp_NAT{client, make(map[int]int), "UPNP (IG2-PPP1)", dev.Root}
+						return
+					}
+
+				}
+			})
+		}
+
+	}()
+	return res
+}
+
+type upnp_NAT_Client interface {
+	GetExternalIPAddress() (string, error)
+	AddPortMapping(string, uint16, string, uint16, string, bool, string, uint32) error
+	DeletePortMapping(string, uint16, string) error
+}
+
+type upnp_NAT struct {
+	c          upnp_NAT_Client
+	ports      map[int]int
+	typ        string
+	rootDevice *goupnp.RootDevice
+}
+
+func (u *upnp_NAT) GetExternalAddress() (addr net.IP, err error) {
+	ipString, err := u.c.GetExternalIPAddress()
+	if err != nil {
+		return nil, err
+	}
+
+	ip := net.ParseIP(ipString)
+	if ip == nil {
+		return nil, ErrNoExternalAddress
+	}
+
+	return ip, nil
+}
+
+func mapProtocol(s string) string {
+	switch s {
+	case "udp":
+		return "UDP"
+	case "tcp":
+		return "TCP"
+	default:
+		panic("invalid protocol: " + s)
+	}
+}
+
+func (u *upnp_NAT) AddPortMapping(protocol string, internalPort int, description string, timeout time.Duration) (int, error) {
+	ip, err := u.GetInternalAddress()
+	if err != nil {
+		return 0, nil
+	}
+
+	timeoutInSeconds := uint32(timeout / time.Second)
+
+	if externalPort := u.ports[internalPort]; externalPort > 0 {
+		err = u.c.AddPortMapping("", uint16(externalPort), mapProtocol(protocol), uint16(internalPort), ip.String(), true, description, timeoutInSeconds)
+		if err == nil {
+			return externalPort, nil
+		}
+	}
+
+	for i := 0; i < 3; i++ {
+		externalPort := randomPort()
+		err = u.c.AddPortMapping("", uint16(externalPort), mapProtocol(protocol), uint16(internalPort), ip.String(), true, description, timeoutInSeconds)
+		if err == nil {
+			u.ports[internalPort] = externalPort
+			return externalPort, nil
+		}
+	}
+
+	return 0, err
+}
+
+func (u *upnp_NAT) DeletePortMapping(protocol string, internalPort int) error {
+	if externalPort := u.ports[internalPort]; externalPort > 0 {
+		delete(u.ports, internalPort)
+		return u.c.DeletePortMapping("", uint16(externalPort), mapProtocol(protocol))
+	}
+
+	return nil
+}
+
+func (u *upnp_NAT) GetDeviceAddress() (net.IP, error) {
+	addr, err := net.ResolveUDPAddr("udp4", u.rootDevice.URLBase.Host)
+	if err != nil {
+		return nil, err
+	}
+
+	return addr.IP, nil
+}
+
+func (u *upnp_NAT) GetInternalAddress() (net.IP, error) {
+	devAddr, err := u.GetDeviceAddress()
+	if err != nil {
+		return nil, err
+	}
+
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, iface := range ifaces {
+		addrs, err := iface.Addrs()
+		if err != nil {
+			return nil, err
+		}
+
+		for _, addr := range addrs {
+			switch x := addr.(type) {
+			case *net.IPNet:
+				if x.Contains(devAddr) {
+					return x.IP, nil
+				}
+			}
+		}
+	}
+
+	return nil, ErrNoInternalAddress
+}
+
+func (n *upnp_NAT) Type() string { return n.typ }
diff --git a/vendor/github.com/gogo/protobuf/AUTHORS b/vendor/github.com/gogo/protobuf/AUTHORS
new file mode 100644
index 000000000..3d97fc7a2
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/AUTHORS
@@ -0,0 +1,15 @@
+# This is the official list of GoGo authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS file, which
+# lists people.  For example, employees are listed in CONTRIBUTORS,
+# but not in AUTHORS, because the employer holds the copyright.
+
+# Names should be added to this file as one of
+#     Organization's name
+#     Individual's name <submission email address>
+#     Individual's name <submission email address> <email2> <emailN>
+
+# Please keep the list sorted.
+
+Sendgrid, Inc
+Vastech SA (PTY) LTD
+Walter Schulze <awalterschulze@gmail.com>
diff --git a/vendor/github.com/gogo/protobuf/CONTRIBUTORS b/vendor/github.com/gogo/protobuf/CONTRIBUTORS
new file mode 100644
index 000000000..1b4f6c208
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/CONTRIBUTORS
@@ -0,0 +1,23 @@
+Anton Povarov <anton.povarov@gmail.com>
+Brian Goff <cpuguy83@gmail.com>
+Clayton Coleman <ccoleman@redhat.com>
+Denis Smirnov <denis.smirnov.91@gmail.com>
+DongYun Kang <ceram1000@gmail.com>
+Dwayne Schultz <dschultz@pivotal.io>
+Georg Apitz <gapitz@pivotal.io>
+Gustav Paul <gustav.paul@gmail.com>
+Johan Brandhorst <johan.brandhorst@gmail.com>
+John Shahid <jvshahid@gmail.com>
+John Tuley <john@tuley.org>
+Laurent <laurent@adyoulike.com>
+Patrick Lee <patrick@dropbox.com>
+Peter Edge <peter.edge@gmail.com>
+Roger Johansson <rogeralsing@gmail.com>
+Sam Nguyen <sam.nguyen@sendgrid.com>
+Sergio Arbeo <serabe@gmail.com>
+Stephen J Day <stephen.day@docker.com>
+Tamir Duberstein <tamird@gmail.com>
+Todd Eisenberger <teisenberger@dropbox.com>
+Tormod Erevik Lea <tormodlea@gmail.com>
+Vyacheslav Kim <kane@sendgrid.com>
+Walter Schulze <awalterschulze@gmail.com>
diff --git a/vendor/github.com/gogo/protobuf/GOLANG_CONTRIBUTORS b/vendor/github.com/gogo/protobuf/GOLANG_CONTRIBUTORS
new file mode 100644
index 000000000..b368efb7f
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/GOLANG_CONTRIBUTORS
@@ -0,0 +1,5 @@
+The contributors to the Go protobuf repository:
+
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
\ No newline at end of file
diff --git a/vendor/github.com/gogo/protobuf/LICENSE b/vendor/github.com/gogo/protobuf/LICENSE
new file mode 100644
index 000000000..7be0cc7b6
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/LICENSE
@@ -0,0 +1,36 @@
+Protocol Buffers for Go with Gadgets
+
+Copyright (c) 2013, The GoGo Authors. All rights reserved.
+http://github.com/gogo/protobuf
+
+Go support for Protocol Buffers - Google's data interchange format
+
+Copyright 2010 The Go Authors.  All rights reserved.
+https://github.com/golang/protobuf
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/vendor/github.com/gogo/protobuf/io/full.go b/vendor/github.com/gogo/protobuf/io/full.go
new file mode 100644
index 000000000..550726a32
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/io/full.go
@@ -0,0 +1,102 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package io
+
+import (
+	"github.com/gogo/protobuf/proto"
+	"io"
+)
+
+func NewFullWriter(w io.Writer) WriteCloser {
+	return &fullWriter{w, nil}
+}
+
+type fullWriter struct {
+	w      io.Writer
+	buffer []byte
+}
+
+func (this *fullWriter) WriteMsg(msg proto.Message) (err error) {
+	var data []byte
+	if m, ok := msg.(marshaler); ok {
+		n, ok := getSize(m)
+		if !ok {
+			data, err = proto.Marshal(msg)
+			if err != nil {
+				return err
+			}
+		}
+		if n >= len(this.buffer) {
+			this.buffer = make([]byte, n)
+		}
+		_, err = m.MarshalTo(this.buffer)
+		if err != nil {
+			return err
+		}
+		data = this.buffer[:n]
+	} else {
+		data, err = proto.Marshal(msg)
+		if err != nil {
+			return err
+		}
+	}
+	_, err = this.w.Write(data)
+	return err
+}
+
+func (this *fullWriter) Close() error {
+	if closer, ok := this.w.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+type fullReader struct {
+	r   io.Reader
+	buf []byte
+}
+
+func NewFullReader(r io.Reader, maxSize int) ReadCloser {
+	return &fullReader{r, make([]byte, maxSize)}
+}
+
+func (this *fullReader) ReadMsg(msg proto.Message) error {
+	length, err := this.r.Read(this.buf)
+	if err != nil {
+		return err
+	}
+	return proto.Unmarshal(this.buf[:length], msg)
+}
+
+func (this *fullReader) Close() error {
+	if closer, ok := this.r.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/io/io.go b/vendor/github.com/gogo/protobuf/io/io.go
new file mode 100644
index 000000000..6dca519a1
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/io/io.go
@@ -0,0 +1,70 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package io
+
+import (
+	"github.com/gogo/protobuf/proto"
+	"io"
+)
+
+type Writer interface {
+	WriteMsg(proto.Message) error
+}
+
+type WriteCloser interface {
+	Writer
+	io.Closer
+}
+
+type Reader interface {
+	ReadMsg(msg proto.Message) error
+}
+
+type ReadCloser interface {
+	Reader
+	io.Closer
+}
+
+type marshaler interface {
+	MarshalTo(data []byte) (n int, err error)
+}
+
+func getSize(v interface{}) (int, bool) {
+	if sz, ok := v.(interface {
+		Size() (n int)
+	}); ok {
+		return sz.Size(), true
+	} else if sz, ok := v.(interface {
+		ProtoSize() (n int)
+	}); ok {
+		return sz.ProtoSize(), true
+	} else {
+		return 0, false
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/io/uint32.go b/vendor/github.com/gogo/protobuf/io/uint32.go
new file mode 100644
index 000000000..fc43857dd
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/io/uint32.go
@@ -0,0 +1,138 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package io
+
+import (
+	"encoding/binary"
+	"io"
+
+	"github.com/gogo/protobuf/proto"
+)
+
+const uint32BinaryLen = 4
+
+func NewUint32DelimitedWriter(w io.Writer, byteOrder binary.ByteOrder) WriteCloser {
+	return &uint32Writer{w, byteOrder, nil, make([]byte, uint32BinaryLen)}
+}
+
+func NewSizeUint32DelimitedWriter(w io.Writer, byteOrder binary.ByteOrder, size int) WriteCloser {
+	return &uint32Writer{w, byteOrder, make([]byte, size), make([]byte, uint32BinaryLen)}
+}
+
+type uint32Writer struct {
+	w         io.Writer
+	byteOrder binary.ByteOrder
+	buffer    []byte
+	lenBuf    []byte
+}
+
+func (this *uint32Writer) writeFallback(msg proto.Message) error {
+	data, err := proto.Marshal(msg)
+	if err != nil {
+		return err
+	}
+
+	length := uint32(len(data))
+	this.byteOrder.PutUint32(this.lenBuf, length)
+	if _, err = this.w.Write(this.lenBuf); err != nil {
+		return err
+	}
+	_, err = this.w.Write(data)
+	return err
+}
+
+func (this *uint32Writer) WriteMsg(msg proto.Message) error {
+	m, ok := msg.(marshaler)
+	if !ok {
+		return this.writeFallback(msg)
+	}
+
+	n, ok := getSize(m)
+	if !ok {
+		return this.writeFallback(msg)
+	}
+
+	size := n + uint32BinaryLen
+	if size > len(this.buffer) {
+		this.buffer = make([]byte, size)
+	}
+
+	this.byteOrder.PutUint32(this.buffer, uint32(n))
+	if _, err := m.MarshalTo(this.buffer[uint32BinaryLen:]); err != nil {
+		return err
+	}
+
+	_, err := this.w.Write(this.buffer[:size])
+	return err
+}
+
+func (this *uint32Writer) Close() error {
+	if closer, ok := this.w.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+type uint32Reader struct {
+	r         io.Reader
+	byteOrder binary.ByteOrder
+	lenBuf    []byte
+	buf       []byte
+	maxSize   int
+}
+
+func NewUint32DelimitedReader(r io.Reader, byteOrder binary.ByteOrder, maxSize int) ReadCloser {
+	return &uint32Reader{r, byteOrder, make([]byte, 4), nil, maxSize}
+}
+
+func (this *uint32Reader) ReadMsg(msg proto.Message) error {
+	if _, err := io.ReadFull(this.r, this.lenBuf); err != nil {
+		return err
+	}
+	length32 := this.byteOrder.Uint32(this.lenBuf)
+	length := int(length32)
+	if length < 0 || length > this.maxSize {
+		return io.ErrShortBuffer
+	}
+	if length >= len(this.buf) {
+		this.buf = make([]byte, length)
+	}
+	_, err := io.ReadFull(this.r, this.buf[:length])
+	if err != nil {
+		return err
+	}
+	return proto.Unmarshal(this.buf[:length], msg)
+}
+
+func (this *uint32Reader) Close() error {
+	if closer, ok := this.r.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/io/varint.go b/vendor/github.com/gogo/protobuf/io/varint.go
new file mode 100644
index 000000000..a72e14a58
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/io/varint.go
@@ -0,0 +1,134 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package io
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"github.com/gogo/protobuf/proto"
+	"io"
+)
+
+var (
+	errSmallBuffer = errors.New("Buffer Too Small")
+	errLargeValue  = errors.New("Value is Larger than 64 bits")
+)
+
+func NewDelimitedWriter(w io.Writer) WriteCloser {
+	return &varintWriter{w, make([]byte, 10), nil}
+}
+
+type varintWriter struct {
+	w      io.Writer
+	lenBuf []byte
+	buffer []byte
+}
+
+func (this *varintWriter) WriteMsg(msg proto.Message) (err error) {
+	var data []byte
+	if m, ok := msg.(marshaler); ok {
+		n, ok := getSize(m)
+		if !ok {
+			data, err = proto.Marshal(msg)
+			if err != nil {
+				return err
+			}
+		}
+		if n >= len(this.buffer) {
+			this.buffer = make([]byte, n)
+		}
+		_, err = m.MarshalTo(this.buffer)
+		if err != nil {
+			return err
+		}
+		data = this.buffer[:n]
+	} else {
+		data, err = proto.Marshal(msg)
+		if err != nil {
+			return err
+		}
+	}
+	length := uint64(len(data))
+	n := binary.PutUvarint(this.lenBuf, length)
+	_, err = this.w.Write(this.lenBuf[:n])
+	if err != nil {
+		return err
+	}
+	_, err = this.w.Write(data)
+	return err
+}
+
+func (this *varintWriter) Close() error {
+	if closer, ok := this.w.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+func NewDelimitedReader(r io.Reader, maxSize int) ReadCloser {
+	var closer io.Closer
+	if c, ok := r.(io.Closer); ok {
+		closer = c
+	}
+	return &varintReader{bufio.NewReader(r), nil, maxSize, closer}
+}
+
+type varintReader struct {
+	r       *bufio.Reader
+	buf     []byte
+	maxSize int
+	closer  io.Closer
+}
+
+func (this *varintReader) ReadMsg(msg proto.Message) error {
+	length64, err := binary.ReadUvarint(this.r)
+	if err != nil {
+		return err
+	}
+	length := int(length64)
+	if length < 0 || length > this.maxSize {
+		return io.ErrShortBuffer
+	}
+	if len(this.buf) < length {
+		this.buf = make([]byte, length)
+	}
+	buf := this.buf[:length]
+	if _, err := io.ReadFull(this.r, buf); err != nil {
+		return err
+	}
+	return proto.Unmarshal(buf, msg)
+}
+
+func (this *varintReader) Close() error {
+	if this.closer != nil {
+		return this.closer.Close()
+	}
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/clone.go b/vendor/github.com/gogo/protobuf/proto/clone.go
new file mode 100644
index 000000000..5d4cba4b5
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/clone.go
@@ -0,0 +1,234 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer deep copy and merge.
+// TODO: RawMessage.
+
+package proto
+
+import (
+	"log"
+	"reflect"
+	"strings"
+)
+
+// Clone returns a deep copy of a protocol buffer.
+func Clone(pb Message) Message {
+	in := reflect.ValueOf(pb)
+	if in.IsNil() {
+		return pb
+	}
+
+	out := reflect.New(in.Type().Elem())
+	// out is empty so a merge is a deep copy.
+	mergeStruct(out.Elem(), in.Elem())
+	return out.Interface().(Message)
+}
+
+// Merge merges src into dst.
+// Required and optional fields that are set in src will be set to that value in dst.
+// Elements of repeated fields will be appended.
+// Merge panics if src and dst are not the same type, or if dst is nil.
+func Merge(dst, src Message) {
+	in := reflect.ValueOf(src)
+	out := reflect.ValueOf(dst)
+	if out.IsNil() {
+		panic("proto: nil destination")
+	}
+	if in.Type() != out.Type() {
+		// Explicit test prior to mergeStruct so that mistyped nils will fail
+		panic("proto: type mismatch")
+	}
+	if in.IsNil() {
+		// Merging nil into non-nil is a quiet no-op
+		return
+	}
+	mergeStruct(out.Elem(), in.Elem())
+}
+
+func mergeStruct(out, in reflect.Value) {
+	sprop := GetProperties(in.Type())
+	for i := 0; i < in.NumField(); i++ {
+		f := in.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
+	}
+
+	if emIn, ok := in.Addr().Interface().(extensionsBytes); ok {
+		emOut := out.Addr().Interface().(extensionsBytes)
+		bIn := emIn.GetExtensions()
+		bOut := emOut.GetExtensions()
+		*bOut = append(*bOut, *bIn...)
+	} else if emIn, ok := extendable(in.Addr().Interface()); ok {
+		emOut, _ := extendable(out.Addr().Interface())
+		mIn, muIn := emIn.extensionsRead()
+		if mIn != nil {
+			mOut := emOut.extensionsWrite()
+			muIn.Lock()
+			mergeExtension(mOut, mIn)
+			muIn.Unlock()
+		}
+	}
+
+	uf := in.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return
+	}
+	uin := uf.Bytes()
+	if len(uin) > 0 {
+		out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
+	}
+}
+
+// mergeAny performs a merge between two values of the same type.
+// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
+// prop is set if this is a struct field (it may be nil).
+func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
+	if in.Type() == protoMessageType {
+		if !in.IsNil() {
+			if out.IsNil() {
+				out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
+			} else {
+				Merge(out.Interface().(Message), in.Interface().(Message))
+			}
+		}
+		return
+	}
+	switch in.Kind() {
+	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+		reflect.String, reflect.Uint32, reflect.Uint64:
+		if !viaPtr && isProto3Zero(in) {
+			return
+		}
+		out.Set(in)
+	case reflect.Interface:
+		// Probably a oneof field; copy non-nil values.
+		if in.IsNil() {
+			return
+		}
+		// Allocate destination if it is not set, or set to a different type.
+		// Otherwise we will merge as normal.
+		if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
+			out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+		}
+		mergeAny(out.Elem(), in.Elem(), false, nil)
+	case reflect.Map:
+		if in.Len() == 0 {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.MakeMap(in.Type()))
+		}
+		// For maps with value types of *T or []byte we need to deep copy each value.
+		elemKind := in.Type().Elem().Kind()
+		for _, key := range in.MapKeys() {
+			var val reflect.Value
+			switch elemKind {
+			case reflect.Ptr:
+				val = reflect.New(in.Type().Elem().Elem())
+				mergeAny(val, in.MapIndex(key), false, nil)
+			case reflect.Slice:
+				val = in.MapIndex(key)
+				val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
+			default:
+				val = in.MapIndex(key)
+			}
+			out.SetMapIndex(key, val)
+		}
+	case reflect.Ptr:
+		if in.IsNil() {
+			return
+		}
+		if out.IsNil() {
+			out.Set(reflect.New(in.Elem().Type()))
+		}
+		mergeAny(out.Elem(), in.Elem(), true, nil)
+	case reflect.Slice:
+		if in.IsNil() {
+			return
+		}
+		if in.Type().Elem().Kind() == reflect.Uint8 {
+			// []byte is a scalar bytes field, not a repeated field.
+
+			// Edge case: if this is in a proto3 message, a zero length
+			// bytes field is considered the zero value, and should not
+			// be merged.
+			if prop != nil && prop.proto3 && in.Len() == 0 {
+				return
+			}
+
+			// Make a deep copy.
+			// Append to []byte{} instead of []byte(nil) so that we never end up
+			// with a nil result.
+			out.SetBytes(append([]byte{}, in.Bytes()...))
+			return
+		}
+		n := in.Len()
+		if out.IsNil() {
+			out.Set(reflect.MakeSlice(in.Type(), 0, n))
+		}
+		switch in.Type().Elem().Kind() {
+		case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
+			reflect.String, reflect.Uint32, reflect.Uint64:
+			out.Set(reflect.AppendSlice(out, in))
+		default:
+			for i := 0; i < n; i++ {
+				x := reflect.Indirect(reflect.New(in.Type().Elem()))
+				mergeAny(x, in.Index(i), false, nil)
+				out.Set(reflect.Append(out, x))
+			}
+		}
+	case reflect.Struct:
+		mergeStruct(out, in)
+	default:
+		// unknown type, so not a protocol buffer
+		log.Printf("proto: don't know how to copy %v", in)
+	}
+}
+
+func mergeExtension(out, in map[int32]Extension) {
+	for extNum, eIn := range in {
+		eOut := Extension{desc: eIn.desc}
+		if eIn.value != nil {
+			v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
+			mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
+			eOut.value = v.Interface()
+		}
+		if eIn.enc != nil {
+			eOut.enc = make([]byte, len(eIn.enc))
+			copy(eOut.enc, eIn.enc)
+		}
+
+		out[extNum] = eOut
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode.go b/vendor/github.com/gogo/protobuf/proto/decode.go
new file mode 100644
index 000000000..737f2731d
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode.go
@@ -0,0 +1,978 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for decoding protocol buffer data to construct in-memory representations.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+)
+
+// errOverflow is returned when an integer is too large to be represented.
+var errOverflow = errors.New("proto: integer overflow")
+
+// ErrInternalBadWireType is returned by generated code when an incorrect
+// wire type is encountered. It does not get returned to user code.
+var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
+
+// The fundamental decoders that interpret bytes on the wire.
+// Those that take integer types all return uint64 and are
+// therefore of type valueDecoder.
+
+// DecodeVarint reads a varint-encoded integer from the slice.
+// It returns the integer and the number of bytes consumed, or
+// zero if there is not enough.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func DecodeVarint(buf []byte) (x uint64, n int) {
+	for shift := uint(0); shift < 64; shift += 7 {
+		if n >= len(buf) {
+			return 0, 0
+		}
+		b := uint64(buf[n])
+		n++
+		x |= (b & 0x7F) << shift
+		if (b & 0x80) == 0 {
+			return x, n
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	return 0, 0
+}
+
+func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
+	i := p.index
+	l := len(p.buf)
+
+	for shift := uint(0); shift < 64; shift += 7 {
+		if i >= l {
+			err = io.ErrUnexpectedEOF
+			return
+		}
+		b := p.buf[i]
+		i++
+		x |= (uint64(b) & 0x7F) << shift
+		if b < 0x80 {
+			p.index = i
+			return
+		}
+	}
+
+	// The number is too large to represent in a 64-bit value.
+	err = errOverflow
+	return
+}
+
+// DecodeVarint reads a varint-encoded integer from the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) DecodeVarint() (x uint64, err error) {
+	i := p.index
+	buf := p.buf
+
+	if i >= len(buf) {
+		return 0, io.ErrUnexpectedEOF
+	} else if buf[i] < 0x80 {
+		p.index++
+		return uint64(buf[i]), nil
+	} else if len(buf)-i < 10 {
+		return p.decodeVarintSlow()
+	}
+
+	var b uint64
+	// we already checked the first byte
+	x = uint64(buf[i]) - 0x80
+	i++
+
+	b = uint64(buf[i])
+	i++
+	x += b << 7
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 7
+
+	b = uint64(buf[i])
+	i++
+	x += b << 14
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 14
+
+	b = uint64(buf[i])
+	i++
+	x += b << 21
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 21
+
+	b = uint64(buf[i])
+	i++
+	x += b << 28
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 28
+
+	b = uint64(buf[i])
+	i++
+	x += b << 35
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 35
+
+	b = uint64(buf[i])
+	i++
+	x += b << 42
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 42
+
+	b = uint64(buf[i])
+	i++
+	x += b << 49
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 49
+
+	b = uint64(buf[i])
+	i++
+	x += b << 56
+	if b&0x80 == 0 {
+		goto done
+	}
+	x -= 0x80 << 56
+
+	b = uint64(buf[i])
+	i++
+	x += b << 63
+	if b&0x80 == 0 {
+		goto done
+	}
+	// x -= 0x80 << 63 // Always zero.
+
+	return 0, errOverflow
+
+done:
+	p.index = i
+	return x, nil
+}
+
+// DecodeFixed64 reads a 64-bit integer from the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) DecodeFixed64() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 8
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-8])
+	x |= uint64(p.buf[i-7]) << 8
+	x |= uint64(p.buf[i-6]) << 16
+	x |= uint64(p.buf[i-5]) << 24
+	x |= uint64(p.buf[i-4]) << 32
+	x |= uint64(p.buf[i-3]) << 40
+	x |= uint64(p.buf[i-2]) << 48
+	x |= uint64(p.buf[i-1]) << 56
+	return
+}
+
+// DecodeFixed32 reads a 32-bit integer from the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) DecodeFixed32() (x uint64, err error) {
+	// x, err already 0
+	i := p.index + 4
+	if i < 0 || i > len(p.buf) {
+		err = io.ErrUnexpectedEOF
+		return
+	}
+	p.index = i
+
+	x = uint64(p.buf[i-4])
+	x |= uint64(p.buf[i-3]) << 8
+	x |= uint64(p.buf[i-2]) << 16
+	x |= uint64(p.buf[i-1]) << 24
+	return
+}
+
+// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
+// from the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
+	return
+}
+
+// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
+// from  the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
+	x, err = p.DecodeVarint()
+	if err != nil {
+		return
+	}
+	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
+	return
+}
+
+// These are not ValueDecoders: they produce an array of bytes or a string.
+// bytes, embedded messages
+
+// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
+	n, err := p.DecodeVarint()
+	if err != nil {
+		return nil, err
+	}
+
+	nb := int(n)
+	if nb < 0 {
+		return nil, fmt.Errorf("proto: bad byte length %d", nb)
+	}
+	end := p.index + nb
+	if end < p.index || end > len(p.buf) {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	if !alloc {
+		// todo: check if can get more uses of alloc=false
+		buf = p.buf[p.index:end]
+		p.index += nb
+		return
+	}
+
+	buf = make([]byte, nb)
+	copy(buf, p.buf[p.index:])
+	p.index += nb
+	return
+}
+
+// DecodeStringBytes reads an encoded string from the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) DecodeStringBytes() (s string, err error) {
+	buf, err := p.DecodeRawBytes(false)
+	if err != nil {
+		return
+	}
+	return string(buf), nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+// If the protocol buffer has extensions, and the field matches, add it as an extension.
+// Otherwise, if the XXX_unrecognized field exists, append the skipped data there.
+func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error {
+	oi := o.index
+
+	err := o.skip(t, tag, wire)
+	if err != nil {
+		return err
+	}
+
+	if !unrecField.IsValid() {
+		return nil
+	}
+
+	ptr := structPointer_Bytes(base, unrecField)
+
+	// Add the skipped field to struct field
+	obuf := o.buf
+
+	o.buf = *ptr
+	o.EncodeVarint(uint64(tag<<3 | wire))
+	*ptr = append(o.buf, obuf[oi:o.index]...)
+
+	o.buf = obuf
+
+	return nil
+}
+
+// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.
+func (o *Buffer) skip(t reflect.Type, tag, wire int) error {
+
+	var u uint64
+	var err error
+
+	switch wire {
+	case WireVarint:
+		_, err = o.DecodeVarint()
+	case WireFixed64:
+		_, err = o.DecodeFixed64()
+	case WireBytes:
+		_, err = o.DecodeRawBytes(false)
+	case WireFixed32:
+		_, err = o.DecodeFixed32()
+	case WireStartGroup:
+		for {
+			u, err = o.DecodeVarint()
+			if err != nil {
+				break
+			}
+			fwire := int(u & 0x7)
+			if fwire == WireEndGroup {
+				break
+			}
+			ftag := int(u >> 3)
+			err = o.skip(t, ftag, fwire)
+			if err != nil {
+				break
+			}
+		}
+	default:
+		err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t)
+	}
+	return err
+}
+
+// Unmarshaler is the interface representing objects that can
+// unmarshal themselves.  The method should reset the receiver before
+// decoding starts.  The argument points to data that may be
+// overwritten, so implementations should not keep references to the
+// buffer.
+type Unmarshaler interface {
+	Unmarshal([]byte) error
+}
+
+// Unmarshal parses the protocol buffer representation in buf and places the
+// decoded result in pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// Unmarshal resets pb before starting to unmarshal, so any
+// existing data in pb is always removed. Use UnmarshalMerge
+// to preserve and append to existing data.
+func Unmarshal(buf []byte, pb Message) error {
+	pb.Reset()
+	return UnmarshalMerge(buf, pb)
+}
+
+// UnmarshalMerge parses the protocol buffer representation in buf and
+// writes the decoded result to pb.  If the struct underlying pb does not match
+// the data in buf, the results can be unpredictable.
+//
+// UnmarshalMerge merges into existing data in pb.
+// Most code should use Unmarshal instead.
+func UnmarshalMerge(buf []byte, pb Message) error {
+	// If the object can unmarshal itself, let it.
+	if u, ok := pb.(Unmarshaler); ok {
+		return u.Unmarshal(buf)
+	}
+	return NewBuffer(buf).Unmarshal(pb)
+}
+
+// DecodeMessage reads a count-delimited message from the Buffer.
+func (p *Buffer) DecodeMessage(pb Message) error {
+	enc, err := p.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+	return NewBuffer(enc).Unmarshal(pb)
+}
+
+// DecodeGroup reads a tag-delimited group from the Buffer.
+func (p *Buffer) DecodeGroup(pb Message) error {
+	typ, base, err := getbase(pb)
+	if err != nil {
+		return err
+	}
+	return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base)
+}
+
+// Unmarshal parses the protocol buffer representation in the
+// Buffer and places the decoded result in pb.  If the struct
+// underlying pb does not match the data in the buffer, the results can be
+// unpredictable.
+//
+// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
+func (p *Buffer) Unmarshal(pb Message) error {
+	// If the object can unmarshal itself, let it.
+	if u, ok := pb.(Unmarshaler); ok {
+		err := u.Unmarshal(p.buf[p.index:])
+		p.index = len(p.buf)
+		return err
+	}
+
+	typ, base, err := getbase(pb)
+	if err != nil {
+		return err
+	}
+
+	err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base)
+
+	if collectStats {
+		stats.Decode++
+	}
+
+	return err
+}
+
+// unmarshalType does the work of unmarshaling a structure.
+func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error {
+	var state errorState
+	required, reqFields := prop.reqCount, uint64(0)
+
+	var err error
+	for err == nil && o.index < len(o.buf) {
+		oi := o.index
+		var u uint64
+		u, err = o.DecodeVarint()
+		if err != nil {
+			break
+		}
+		wire := int(u & 0x7)
+		if wire == WireEndGroup {
+			if is_group {
+				if required > 0 {
+					// Not enough information to determine the exact field.
+					// (See below.)
+					return &RequiredNotSetError{"{Unknown}"}
+				}
+				return nil // input is satisfied
+			}
+			return fmt.Errorf("proto: %s: wiretype end group for non-group", st)
+		}
+		tag := int(u >> 3)
+		if tag <= 0 {
+			return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire)
+		}
+		fieldnum, ok := prop.decoderTags.get(tag)
+		if !ok {
+			// Maybe it's an extension?
+			if prop.extendable {
+				if e, eok := structPointer_Interface(base, st).(extensionsBytes); eok {
+					if isExtensionField(e, int32(tag)) {
+						if err = o.skip(st, tag, wire); err == nil {
+							ext := e.GetExtensions()
+							*ext = append(*ext, o.buf[oi:o.index]...)
+						}
+						continue
+					}
+				} else if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {
+					if err = o.skip(st, tag, wire); err == nil {
+						extmap := e.extensionsWrite()
+						ext := extmap[int32(tag)] // may be missing
+						ext.enc = append(ext.enc, o.buf[oi:o.index]...)
+						extmap[int32(tag)] = ext
+					}
+					continue
+				}
+			}
+			// Maybe it's a oneof?
+			if prop.oneofUnmarshaler != nil {
+				m := structPointer_Interface(base, st).(Message)
+				// First return value indicates whether tag is a oneof field.
+				ok, err = prop.oneofUnmarshaler(m, tag, wire, o)
+				if err == ErrInternalBadWireType {
+					// Map the error to something more descriptive.
+					// Do the formatting here to save generated code space.
+					err = fmt.Errorf("bad wiretype for oneof field in %T", m)
+				}
+				if ok {
+					continue
+				}
+			}
+			err = o.skipAndSave(st, tag, wire, base, prop.unrecField)
+			continue
+		}
+		p := prop.Prop[fieldnum]
+
+		if p.dec == nil {
+			fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name)
+			continue
+		}
+		dec := p.dec
+		if wire != WireStartGroup && wire != p.WireType {
+			if wire == WireBytes && p.packedDec != nil {
+				// a packable field
+				dec = p.packedDec
+			} else {
+				err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType)
+				continue
+			}
+		}
+		decErr := dec(o, p, base)
+		if decErr != nil && !state.shouldContinue(decErr, p) {
+			err = decErr
+		}
+		if err == nil && p.Required {
+			// Successfully decoded a required field.
+			if tag <= 64 {
+				// use bitmap for fields 1-64 to catch field reuse.
+				var mask uint64 = 1 << uint64(tag-1)
+				if reqFields&mask == 0 {
+					// new required field
+					reqFields |= mask
+					required--
+				}
+			} else {
+				// This is imprecise. It can be fooled by a required field
+				// with a tag > 64 that is encoded twice; that's very rare.
+				// A fully correct implementation would require allocating
+				// a data structure, which we would like to avoid.
+				required--
+			}
+		}
+	}
+	if err == nil {
+		if is_group {
+			return io.ErrUnexpectedEOF
+		}
+		if state.err != nil {
+			return state.err
+		}
+		if required > 0 {
+			// Not enough information to determine the exact field. If we use extra
+			// CPU, we could determine the field only if the missing required field
+			// has a tag <= 64 and we check reqFields.
+			return &RequiredNotSetError{"{Unknown}"}
+		}
+	}
+	return err
+}
+
+// Individual type decoders
+// For each,
+//	u is the decoded value,
+//	v is a pointer to the field (pointer) in the struct
+
+// Sizes of the pools to allocate inside the Buffer.
+// The goal is modest amortization and allocation
+// on at least 16-byte boundaries.
+const (
+	boolPoolSize   = 16
+	uint32PoolSize = 8
+	uint64PoolSize = 4
+)
+
+// Decode a bool.
+func (o *Buffer) dec_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	if len(o.bools) == 0 {
+		o.bools = make([]bool, boolPoolSize)
+	}
+	o.bools[0] = u != 0
+	*structPointer_Bool(base, p.field) = &o.bools[0]
+	o.bools = o.bools[1:]
+	return nil
+}
+
+func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	*structPointer_BoolVal(base, p.field) = u != 0
+	return nil
+}
+
+// Decode an int32.
+func (o *Buffer) dec_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word32_Set(structPointer_Word32(base, p.field), o, uint32(u))
+	return nil
+}
+
+func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u))
+	return nil
+}
+
+// Decode an int64.
+func (o *Buffer) dec_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word64_Set(structPointer_Word64(base, p.field), o, u)
+	return nil
+}
+
+func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	word64Val_Set(structPointer_Word64Val(base, p.field), o, u)
+	return nil
+}
+
+// Decode a string.
+func (o *Buffer) dec_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	*structPointer_String(base, p.field) = &s
+	return nil
+}
+
+func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	*structPointer_StringVal(base, p.field) = s
+	return nil
+}
+
+// Decode a slice of bytes ([]byte).
+func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	*structPointer_Bytes(base, p.field) = b
+	return nil
+}
+
+// Decode a slice of bools ([]bool).
+func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	v := structPointer_BoolSlice(base, p.field)
+	*v = append(*v, u != 0)
+	return nil
+}
+
+// Decode a slice of bools ([]bool) in packed format.
+func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error {
+	v := structPointer_BoolSlice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded bools
+	fin := o.index + nb
+	if fin < o.index {
+		return errOverflow
+	}
+
+	y := *v
+	for o.index < fin {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		y = append(y, u != 0)
+	}
+
+	*v = y
+	return nil
+}
+
+// Decode a slice of int32s ([]int32).
+func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+	structPointer_Word32Slice(base, p.field).Append(uint32(u))
+	return nil
+}
+
+// Decode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Slice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded int32s
+
+	fin := o.index + nb
+	if fin < o.index {
+		return errOverflow
+	}
+	for o.index < fin {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		v.Append(uint32(u))
+	}
+	return nil
+}
+
+// Decode a slice of int64s ([]int64).
+func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error {
+	u, err := p.valDec(o)
+	if err != nil {
+		return err
+	}
+
+	structPointer_Word64Slice(base, p.field).Append(u)
+	return nil
+}
+
+// Decode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Slice(base, p.field)
+
+	nn, err := o.DecodeVarint()
+	if err != nil {
+		return err
+	}
+	nb := int(nn) // number of bytes of encoded int64s
+
+	fin := o.index + nb
+	if fin < o.index {
+		return errOverflow
+	}
+	for o.index < fin {
+		u, err := p.valDec(o)
+		if err != nil {
+			return err
+		}
+		v.Append(u)
+	}
+	return nil
+}
+
+// Decode a slice of strings ([]string).
+func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error {
+	s, err := o.DecodeStringBytes()
+	if err != nil {
+		return err
+	}
+	v := structPointer_StringSlice(base, p.field)
+	*v = append(*v, s)
+	return nil
+}
+
+// Decode a slice of slice of bytes ([][]byte).
+func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	v := structPointer_BytesSlice(base, p.field)
+	*v = append(*v, b)
+	return nil
+}
+
+// Decode a map field.
+func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+	oi := o.index       // index at the end of this map entry
+	o.index -= len(raw) // move buffer back to start of map entry
+
+	mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V
+	if mptr.Elem().IsNil() {
+		mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem()))
+	}
+	v := mptr.Elem() // map[K]V
+
+	// Prepare addressable doubly-indirect placeholders for the key and value types.
+	// See enc_new_map for why.
+	keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K
+	keybase := toStructPointer(keyptr.Addr())                  // **K
+
+	var valbase structPointer
+	var valptr reflect.Value
+	switch p.mtype.Elem().Kind() {
+	case reflect.Slice:
+		// []byte
+		var dummy []byte
+		valptr = reflect.ValueOf(&dummy)  // *[]byte
+		valbase = toStructPointer(valptr) // *[]byte
+	case reflect.Ptr:
+		// message; valptr is **Msg; need to allocate the intermediate pointer
+		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+		valptr.Set(reflect.New(valptr.Type().Elem()))
+		valbase = toStructPointer(valptr)
+	default:
+		// everything else
+		valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V
+		valbase = toStructPointer(valptr.Addr())                   // **V
+	}
+
+	// Decode.
+	// This parses a restricted wire format, namely the encoding of a message
+	// with two fields. See enc_new_map for the format.
+	for o.index < oi {
+		// tagcode for key and value properties are always a single byte
+		// because they have tags 1 and 2.
+		tagcode := o.buf[o.index]
+		o.index++
+		switch tagcode {
+		case p.mkeyprop.tagcode[0]:
+			if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil {
+				return err
+			}
+		case p.mvalprop.tagcode[0]:
+			if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil {
+				return err
+			}
+		default:
+			// TODO: Should we silently skip this instead?
+			return fmt.Errorf("proto: bad map data tag %d", raw[0])
+		}
+	}
+	keyelem, valelem := keyptr.Elem(), valptr.Elem()
+	if !keyelem.IsValid() {
+		keyelem = reflect.Zero(p.mtype.Key())
+	}
+	if !valelem.IsValid() {
+		valelem = reflect.Zero(p.mtype.Elem())
+	}
+
+	v.SetMapIndex(keyelem, valelem)
+	return nil
+}
+
+// Decode a group.
+func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error {
+	bas := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(bas) {
+		// allocate new nested message
+		bas = toStructPointer(reflect.New(p.stype))
+		structPointer_SetStructPointer(base, p.field, bas)
+	}
+	return o.unmarshalType(p.stype, p.sprop, true, bas)
+}
+
+// Decode an embedded message.
+func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) {
+	raw, e := o.DecodeRawBytes(false)
+	if e != nil {
+		return e
+	}
+
+	bas := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(bas) {
+		// allocate new nested message
+		bas = toStructPointer(reflect.New(p.stype))
+		structPointer_SetStructPointer(base, p.field, bas)
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		iv := structPointer_Interface(bas, p.stype)
+		return iv.(Unmarshaler).Unmarshal(raw)
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, false, bas)
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of embedded messages.
+func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error {
+	return o.dec_slice_struct(p, false, base)
+}
+
+// Decode a slice of embedded groups.
+func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error {
+	return o.dec_slice_struct(p, true, base)
+}
+
+// Decode a slice of structs ([]*struct).
+func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error {
+	v := reflect.New(p.stype)
+	bas := toStructPointer(v)
+	structPointer_StructPointerSlice(base, p.field).Append(bas)
+
+	if is_group {
+		err := o.unmarshalType(p.stype, p.sprop, is_group, bas)
+		return err
+	}
+
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		iv := v.Interface()
+		return iv.(Unmarshaler).Unmarshal(raw)
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, is_group, bas)
+
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/decode_gogo.go b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
new file mode 100644
index 000000000..6fb74de4c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/decode_gogo.go
@@ -0,0 +1,172 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+)
+
+// Decode a reference to a struct pointer.
+func (o *Buffer) dec_ref_struct_message(p *Properties, base structPointer) (err error) {
+	raw, e := o.DecodeRawBytes(false)
+	if e != nil {
+		return e
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		panic("not supported, since this is a pointer receiver")
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	bas := structPointer_FieldPointer(base, p.field)
+
+	err = o.unmarshalType(p.stype, p.sprop, false, bas)
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of references to struct pointers ([]struct).
+func (o *Buffer) dec_slice_ref_struct(p *Properties, is_group bool, base structPointer) error {
+	newBas := appendStructPointer(base, p.field, p.sstype)
+
+	if is_group {
+		panic("not supported, maybe in future, if requested.")
+	}
+
+	raw, err := o.DecodeRawBytes(false)
+	if err != nil {
+		return err
+	}
+
+	// If the object can unmarshal itself, let it.
+	if p.isUnmarshaler {
+		panic("not supported, since this is not a pointer receiver.")
+	}
+
+	obuf := o.buf
+	oi := o.index
+	o.buf = raw
+	o.index = 0
+
+	err = o.unmarshalType(p.stype, p.sprop, is_group, newBas)
+
+	o.buf = obuf
+	o.index = oi
+
+	return err
+}
+
+// Decode a slice of references to struct pointers.
+func (o *Buffer) dec_slice_ref_struct_message(p *Properties, base structPointer) error {
+	return o.dec_slice_ref_struct(p, false, base)
+}
+
+func setPtrCustomType(base structPointer, f field, v interface{}) {
+	if v == nil {
+		return
+	}
+	structPointer_SetStructPointer(base, f, toStructPointer(reflect.ValueOf(v)))
+}
+
+func setCustomType(base structPointer, f field, value interface{}) {
+	if value == nil {
+		return
+	}
+	v := reflect.ValueOf(value).Elem()
+	t := reflect.TypeOf(value).Elem()
+	kind := t.Kind()
+	switch kind {
+	case reflect.Slice:
+		slice := reflect.MakeSlice(t, v.Len(), v.Cap())
+		reflect.Copy(slice, v)
+		oldHeader := structPointer_GetSliceHeader(base, f)
+		oldHeader.Data = slice.Pointer()
+		oldHeader.Len = v.Len()
+		oldHeader.Cap = v.Cap()
+	default:
+		size := reflect.TypeOf(value).Elem().Size()
+		structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), int(size))
+	}
+}
+
+func (o *Buffer) dec_custom_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype.Elem()).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	setPtrCustomType(base, p.field, custom)
+	return nil
+}
+
+func (o *Buffer) dec_custom_ref_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	if custom != nil {
+		setCustomType(base, p.field, custom)
+	}
+	return nil
+}
+
+// Decode a slice of bytes ([]byte) into a slice of custom types.
+func (o *Buffer) dec_custom_slice_bytes(p *Properties, base structPointer) error {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return err
+	}
+	i := reflect.New(p.ctype.Elem()).Interface()
+	custom := (i).(Unmarshaler)
+	if err := custom.Unmarshal(b); err != nil {
+		return err
+	}
+	newBas := appendStructPointer(base, p.field, p.ctype)
+
+	var zero field
+	setCustomType(newBas, zero, custom)
+
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/discard.go b/vendor/github.com/gogo/protobuf/proto/discard.go
new file mode 100644
index 000000000..bd0e3bb4c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/discard.go
@@ -0,0 +1,151 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2017 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// DiscardUnknown recursively discards all unknown fields from this message
+// and all embedded messages.
+//
+// When unmarshaling a message with unrecognized fields, the tags and values
+// of such fields are preserved in the Message. This allows a later call to
+// marshal to be able to produce a message that continues to have those
+// unrecognized fields. To avoid this, DiscardUnknown is used to
+// explicitly clear the unknown fields after unmarshaling.
+//
+// For proto2 messages, the unknown fields of message extensions are only
+// discarded from messages that have been accessed via GetExtension.
+func DiscardUnknown(m Message) {
+	discardLegacy(m)
+}
+
+func discardLegacy(m Message) {
+	v := reflect.ValueOf(m)
+	if v.Kind() != reflect.Ptr || v.IsNil() {
+		return
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Struct {
+		return
+	}
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		f := t.Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		vf := v.Field(i)
+		tf := f.Type
+
+		// Unwrap tf to get its most basic type.
+		var isPointer, isSlice bool
+		if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {
+			isSlice = true
+			tf = tf.Elem()
+		}
+		if tf.Kind() == reflect.Ptr {
+			isPointer = true
+			tf = tf.Elem()
+		}
+		if isPointer && isSlice && tf.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))
+		}
+
+		switch tf.Kind() {
+		case reflect.Struct:
+			switch {
+			case !isPointer:
+				panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))
+			case isSlice: // E.g., []*pb.T
+				for j := 0; j < vf.Len(); j++ {
+					discardLegacy(vf.Index(j).Interface().(Message))
+				}
+			default: // E.g., *pb.T
+				discardLegacy(vf.Interface().(Message))
+			}
+		case reflect.Map:
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))
+			default: // E.g., map[K]V
+				tv := vf.Type().Elem()
+				if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)
+					for _, key := range vf.MapKeys() {
+						val := vf.MapIndex(key)
+						discardLegacy(val.Interface().(Message))
+					}
+				}
+			}
+		case reflect.Interface:
+			// Must be oneof field.
+			switch {
+			case isPointer || isSlice:
+				panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))
+			default: // E.g., test_proto.isCommunique_Union interface
+				if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {
+					vf = vf.Elem() // E.g., *test_proto.Communique_Msg
+					if !vf.IsNil() {
+						vf = vf.Elem()   // E.g., test_proto.Communique_Msg
+						vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value
+						if vf.Kind() == reflect.Ptr {
+							discardLegacy(vf.Interface().(Message))
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {
+		if vf.Type() != reflect.TypeOf([]byte{}) {
+			panic("expected XXX_unrecognized to be of type []byte")
+		}
+		vf.Set(reflect.ValueOf([]byte(nil)))
+	}
+
+	// For proto2 messages, only discard unknown fields in message extensions
+	// that have been accessed via GetExtension.
+	if em, ok := extendable(m); ok {
+		// Ignore lock since discardLegacy is not concurrency safe.
+		emm, _ := em.extensionsRead()
+		for _, mx := range emm {
+			if m, ok := mx.value.(Message); ok {
+				discardLegacy(m)
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/duration.go b/vendor/github.com/gogo/protobuf/proto/duration.go
new file mode 100644
index 000000000..93464c91c
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/duration.go
@@ -0,0 +1,100 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// This file implements conversions between google.protobuf.Duration
+// and time.Duration.
+
+import (
+	"errors"
+	"fmt"
+	"time"
+)
+
+const (
+	// Range of a Duration in seconds, as specified in
+	// google/protobuf/duration.proto. This is about 10,000 years in seconds.
+	maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
+	minSeconds = -maxSeconds
+)
+
+// validateDuration determines whether the Duration is valid according to the
+// definition in google/protobuf/duration.proto. A valid Duration
+// may still be too large to fit into a time.Duration (the range of Duration
+// is about 10,000 years, and the range of time.Duration is about 290).
+func validateDuration(d *duration) error {
+	if d == nil {
+		return errors.New("duration: nil Duration")
+	}
+	if d.Seconds < minSeconds || d.Seconds > maxSeconds {
+		return fmt.Errorf("duration: %#v: seconds out of range", d)
+	}
+	if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
+		return fmt.Errorf("duration: %#v: nanos out of range", d)
+	}
+	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+	if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
+		return fmt.Errorf("duration: %#v: seconds and nanos have different signs", d)
+	}
+	return nil
+}
+
+// DurationFromProto converts a Duration to a time.Duration. DurationFromProto
+// returns an error if the Duration is invalid or is too large to be
+// represented in a time.Duration.
+func durationFromProto(p *duration) (time.Duration, error) {
+	if err := validateDuration(p); err != nil {
+		return 0, err
+	}
+	d := time.Duration(p.Seconds) * time.Second
+	if int64(d/time.Second) != p.Seconds {
+		return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
+	}
+	if p.Nanos != 0 {
+		d += time.Duration(p.Nanos)
+		if (d < 0) != (p.Nanos < 0) {
+			return 0, fmt.Errorf("duration: %#v is out of range for time.Duration", p)
+		}
+	}
+	return d, nil
+}
+
+// DurationProto converts a time.Duration to a Duration.
+func durationProto(d time.Duration) *duration {
+	nanos := d.Nanoseconds()
+	secs := nanos / 1e9
+	nanos -= secs * 1e9
+	return &duration{
+		Seconds: secs,
+		Nanos:   int32(nanos),
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/duration_gogo.go b/vendor/github.com/gogo/protobuf/proto/duration_gogo.go
new file mode 100644
index 000000000..18e2a5f77
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/duration_gogo.go
@@ -0,0 +1,203 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2016, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+	"time"
+)
+
+var durationType = reflect.TypeOf((*time.Duration)(nil)).Elem()
+
+type duration struct {
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	Nanos   int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (m *duration) Reset()       { *m = duration{} }
+func (*duration) ProtoMessage()  {}
+func (*duration) String() string { return "duration<string>" }
+
+func init() {
+	RegisterType((*duration)(nil), "gogo.protobuf.proto.duration")
+}
+
+func (o *Buffer) decDuration() (time.Duration, error) {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return 0, err
+	}
+	dproto := &duration{}
+	if err := Unmarshal(b, dproto); err != nil {
+		return 0, err
+	}
+	return durationFromProto(dproto)
+}
+
+func (o *Buffer) dec_duration(p *Properties, base structPointer) error {
+	d, err := o.decDuration()
+	if err != nil {
+		return err
+	}
+	word64_Set(structPointer_Word64(base, p.field), o, uint64(d))
+	return nil
+}
+
+func (o *Buffer) dec_ref_duration(p *Properties, base structPointer) error {
+	d, err := o.decDuration()
+	if err != nil {
+		return err
+	}
+	word64Val_Set(structPointer_Word64Val(base, p.field), o, uint64(d))
+	return nil
+}
+
+func (o *Buffer) dec_slice_duration(p *Properties, base structPointer) error {
+	d, err := o.decDuration()
+	if err != nil {
+		return err
+	}
+	newBas := appendStructPointer(base, p.field, reflect.SliceOf(reflect.PtrTo(durationType)))
+	var zero field
+	setPtrCustomType(newBas, zero, &d)
+	return nil
+}
+
+func (o *Buffer) dec_slice_ref_duration(p *Properties, base structPointer) error {
+	d, err := o.decDuration()
+	if err != nil {
+		return err
+	}
+	structPointer_Word64Slice(base, p.field).Append(uint64(d))
+	return nil
+}
+
+func size_duration(p *Properties, base structPointer) (n int) {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+	dur := structPointer_Interface(structp, durationType).(*time.Duration)
+	d := durationProto(*dur)
+	size := Size(d)
+	return size + sizeVarint(uint64(size)) + len(p.tagcode)
+}
+
+func (o *Buffer) enc_duration(p *Properties, base structPointer) error {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+	dur := structPointer_Interface(structp, durationType).(*time.Duration)
+	d := durationProto(*dur)
+	data, err := Marshal(d)
+	if err != nil {
+		return err
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_ref_duration(p *Properties, base structPointer) (n int) {
+	dur := structPointer_InterfaceAt(base, p.field, durationType).(*time.Duration)
+	d := durationProto(*dur)
+	size := Size(d)
+	return size + sizeVarint(uint64(size)) + len(p.tagcode)
+}
+
+func (o *Buffer) enc_ref_duration(p *Properties, base structPointer) error {
+	dur := structPointer_InterfaceAt(base, p.field, durationType).(*time.Duration)
+	d := durationProto(*dur)
+	data, err := Marshal(d)
+	if err != nil {
+		return err
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_slice_duration(p *Properties, base structPointer) (n int) {
+	pdurs := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(reflect.PtrTo(durationType))).(*[]*time.Duration)
+	durs := *pdurs
+	for i := 0; i < len(durs); i++ {
+		if durs[i] == nil {
+			return 0
+		}
+		dproto := durationProto(*durs[i])
+		size := Size(dproto)
+		n += len(p.tagcode) + size + sizeVarint(uint64(size))
+	}
+	return n
+}
+
+func (o *Buffer) enc_slice_duration(p *Properties, base structPointer) error {
+	pdurs := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(reflect.PtrTo(durationType))).(*[]*time.Duration)
+	durs := *pdurs
+	for i := 0; i < len(durs); i++ {
+		if durs[i] == nil {
+			return errRepeatedHasNil
+		}
+		dproto := durationProto(*durs[i])
+		data, err := Marshal(dproto)
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
+
+func size_slice_ref_duration(p *Properties, base structPointer) (n int) {
+	pdurs := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(durationType)).(*[]time.Duration)
+	durs := *pdurs
+	for i := 0; i < len(durs); i++ {
+		dproto := durationProto(durs[i])
+		size := Size(dproto)
+		n += len(p.tagcode) + size + sizeVarint(uint64(size))
+	}
+	return n
+}
+
+func (o *Buffer) enc_slice_ref_duration(p *Properties, base structPointer) error {
+	pdurs := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(durationType)).(*[]time.Duration)
+	durs := *pdurs
+	for i := 0; i < len(durs); i++ {
+		dproto := durationProto(durs[i])
+		data, err := Marshal(dproto)
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/encode.go b/vendor/github.com/gogo/protobuf/proto/encode.go
new file mode 100644
index 000000000..8b84d1b22
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode.go
@@ -0,0 +1,1362 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// RequiredNotSetError is the error returned if Marshal is called with
+// a protocol buffer struct whose required fields have not
+// all been initialized. It is also the error returned if Unmarshal is
+// called with an encoded protocol buffer that does not include all the
+// required fields.
+//
+// When printed, RequiredNotSetError reports the first unset required field in a
+// message. If the field cannot be precisely determined, it is reported as
+// "{Unknown}".
+type RequiredNotSetError struct {
+	field string
+}
+
+func (e *RequiredNotSetError) Error() string {
+	return fmt.Sprintf("proto: required field %q not set", e.field)
+}
+
+var (
+	// errRepeatedHasNil is the error returned if Marshal is called with
+	// a struct with a repeated field containing a nil element.
+	errRepeatedHasNil = errors.New("proto: repeated field has nil element")
+
+	// errOneofHasNil is the error returned if Marshal is called with
+	// a struct with a oneof field containing a nil element.
+	errOneofHasNil = errors.New("proto: oneof field has nil value")
+
+	// ErrNil is the error returned if Marshal is called with nil.
+	ErrNil = errors.New("proto: Marshal called with nil")
+
+	// ErrTooLarge is the error returned if Marshal is called with a
+	// message that encodes to >2GB.
+	ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
+)
+
+// The fundamental encoders that put bytes on the wire.
+// Those that take integer types all accept uint64 and are
+// therefore of type valueEncoder.
+
+const maxVarintBytes = 10 // maximum length of a varint
+
+// maxMarshalSize is the largest allowed size of an encoded protobuf,
+// since C++ and Java use signed int32s for the size.
+const maxMarshalSize = 1<<31 - 1
+
+// EncodeVarint returns the varint encoding of x.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+// Not used by the package itself, but helpful to clients
+// wishing to use the same encoding.
+func EncodeVarint(x uint64) []byte {
+	var buf [maxVarintBytes]byte
+	var n int
+	for n = 0; x > 127; n++ {
+		buf[n] = 0x80 | uint8(x&0x7F)
+		x >>= 7
+	}
+	buf[n] = uint8(x)
+	n++
+	return buf[0:n]
+}
+
+// EncodeVarint writes a varint-encoded integer to the Buffer.
+// This is the format for the
+// int32, int64, uint32, uint64, bool, and enum
+// protocol buffer types.
+func (p *Buffer) EncodeVarint(x uint64) error {
+	for x >= 1<<7 {
+		p.buf = append(p.buf, uint8(x&0x7f|0x80))
+		x >>= 7
+	}
+	p.buf = append(p.buf, uint8(x))
+	return nil
+}
+
+// SizeVarint returns the varint encoding size of an integer.
+func SizeVarint(x uint64) int {
+	return sizeVarint(x)
+}
+
+func sizeVarint(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+
+// EncodeFixed64 writes a 64-bit integer to the Buffer.
+// This is the format for the
+// fixed64, sfixed64, and double protocol buffer types.
+func (p *Buffer) EncodeFixed64(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24),
+		uint8(x>>32),
+		uint8(x>>40),
+		uint8(x>>48),
+		uint8(x>>56))
+	return nil
+}
+
+func sizeFixed64(x uint64) int {
+	return 8
+}
+
+// EncodeFixed32 writes a 32-bit integer to the Buffer.
+// This is the format for the
+// fixed32, sfixed32, and float protocol buffer types.
+func (p *Buffer) EncodeFixed32(x uint64) error {
+	p.buf = append(p.buf,
+		uint8(x),
+		uint8(x>>8),
+		uint8(x>>16),
+		uint8(x>>24))
+	return nil
+}
+
+func sizeFixed32(x uint64) int {
+	return 4
+}
+
+// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
+// to the Buffer.
+// This is the format used for the sint64 protocol buffer type.
+func (p *Buffer) EncodeZigzag64(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint((x << 1) ^ uint64((int64(x) >> 63)))
+}
+
+func sizeZigzag64(x uint64) int {
+	return sizeVarint((x << 1) ^ uint64((int64(x) >> 63)))
+}
+
+// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
+// to the Buffer.
+// This is the format used for the sint32 protocol buffer type.
+func (p *Buffer) EncodeZigzag32(x uint64) error {
+	// use signed number to get arithmetic right shift.
+	return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+func sizeZigzag32(x uint64) int {
+	return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
+}
+
+// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
+// This is the format used for the bytes protocol buffer
+// type and for embedded messages.
+func (p *Buffer) EncodeRawBytes(b []byte) error {
+	p.EncodeVarint(uint64(len(b)))
+	p.buf = append(p.buf, b...)
+	return nil
+}
+
+func sizeRawBytes(b []byte) int {
+	return sizeVarint(uint64(len(b))) +
+		len(b)
+}
+
+// EncodeStringBytes writes an encoded string to the Buffer.
+// This is the format used for the proto2 string type.
+func (p *Buffer) EncodeStringBytes(s string) error {
+	p.EncodeVarint(uint64(len(s)))
+	p.buf = append(p.buf, s...)
+	return nil
+}
+
+func sizeStringBytes(s string) int {
+	return sizeVarint(uint64(len(s))) +
+		len(s)
+}
+
+// Marshaler is the interface representing objects that can marshal themselves.
+type Marshaler interface {
+	Marshal() ([]byte, error)
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, returning the data.
+func Marshal(pb Message) ([]byte, error) {
+	// Can the object marshal itself?
+	if m, ok := pb.(Marshaler); ok {
+		return m.Marshal()
+	}
+	p := NewBuffer(nil)
+	err := p.Marshal(pb)
+	if p.buf == nil && err == nil {
+		// Return a non-nil slice on success.
+		return []byte{}, nil
+	}
+	return p.buf, err
+}
+
+// EncodeMessage writes the protocol buffer to the Buffer,
+// prefixed by a varint-encoded length.
+func (p *Buffer) EncodeMessage(pb Message) error {
+	t, base, err := getbase(pb)
+	if structPointer_IsNil(base) {
+		return ErrNil
+	}
+	if err == nil {
+		var state errorState
+		err = p.enc_len_struct(GetProperties(t.Elem()), base, &state)
+	}
+	return err
+}
+
+// Marshal takes the protocol buffer
+// and encodes it into the wire format, writing the result to the
+// Buffer.
+func (p *Buffer) Marshal(pb Message) error {
+	// Can the object marshal itself?
+	if m, ok := pb.(Marshaler); ok {
+		data, err := m.Marshal()
+		p.buf = append(p.buf, data...)
+		return err
+	}
+
+	t, base, err := getbase(pb)
+	if structPointer_IsNil(base) {
+		return ErrNil
+	}
+	if err == nil {
+		err = p.enc_struct(GetProperties(t.Elem()), base)
+	}
+
+	if collectStats {
+		(stats).Encode++ // Parens are to work around a goimports bug.
+	}
+
+	if len(p.buf) > maxMarshalSize {
+		return ErrTooLarge
+	}
+	return err
+}
+
+// Size returns the encoded size of a protocol buffer.
+func Size(pb Message) (n int) {
+	// Can the object marshal itself?  If so, Size is slow.
+	// TODO: add Size to Marshaler, or add a Sizer interface.
+	if m, ok := pb.(Marshaler); ok {
+		b, _ := m.Marshal()
+		return len(b)
+	}
+
+	t, base, err := getbase(pb)
+	if structPointer_IsNil(base) {
+		return 0
+	}
+	if err == nil {
+		n = size_struct(GetProperties(t.Elem()), base)
+	}
+
+	if collectStats {
+		(stats).Size++ // Parens are to work around a goimports bug.
+	}
+
+	return
+}
+
+// Individual type encoders.
+
+// Encode a bool.
+func (o *Buffer) enc_bool(p *Properties, base structPointer) error {
+	v := *structPointer_Bool(base, p.field)
+	if v == nil {
+		return ErrNil
+	}
+	x := 0
+	if *v {
+		x = 1
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {
+	v := *structPointer_BoolVal(base, p.field)
+	if !v {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, 1)
+	return nil
+}
+
+func size_bool(p *Properties, base structPointer) int {
+	v := *structPointer_Bool(base, p.field)
+	if v == nil {
+		return 0
+	}
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+func size_proto3_bool(p *Properties, base structPointer) int {
+	v := *structPointer_BoolVal(base, p.field)
+	if !v && !p.oneof {
+		return 0
+	}
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode an int32.
+func (o *Buffer) enc_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return ErrNil
+	}
+	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return 0
+	}
+	x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func size_proto3_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
+	if x == 0 && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode a uint32.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return ErrNil
+	}
+	x := word32_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32(base, p.field)
+	if word32_IsNil(v) {
+		return 0
+	}
+	x := word32_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func size_proto3_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	if x == 0 && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode an int64.
+func (o *Buffer) enc_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64(base, p.field)
+	if word64_IsNil(v) {
+		return ErrNil
+	}
+	x := word64_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	if x == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func size_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64(base, p.field)
+	if word64_IsNil(v) {
+		return 0
+	}
+	x := word64_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+func size_proto3_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	if x == 0 && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+// Encode a string.
+func (o *Buffer) enc_string(p *Properties, base structPointer) error {
+	v := *structPointer_String(base, p.field)
+	if v == nil {
+		return ErrNil
+	}
+	x := *v
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(x)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {
+	v := *structPointer_StringVal(base, p.field)
+	if v == "" {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(v)
+	return nil
+}
+
+func size_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_String(base, p.field)
+	if v == nil {
+		return 0
+	}
+	x := *v
+	n += len(p.tagcode)
+	n += sizeStringBytes(x)
+	return
+}
+
+func size_proto3_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_StringVal(base, p.field)
+	if v == "" && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeStringBytes(v)
+	return
+}
+
+// All protocol buffer fields are nillable, but be careful.
+func isNil(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return v.IsNil()
+	}
+	return false
+}
+
+// Encode a message struct.
+func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, err := m.Marshal()
+		if err != nil && !state.shouldContinue(err, nil) {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+		return state.err
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+func size_struct_message(p *Properties, base structPointer) int {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, _ := m.Marshal()
+		n0 := len(p.tagcode)
+		n1 := sizeRawBytes(data)
+		return n0 + n1
+	}
+
+	n0 := len(p.tagcode)
+	n1 := size_struct(p.sprop, structp)
+	n2 := sizeVarint(uint64(n1)) // size of encoded length
+	return n0 + n1 + n2
+}
+
+// Encode a group struct.
+func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {
+	var state errorState
+	b := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(b) {
+		return ErrNil
+	}
+
+	o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+	err := o.enc_struct(p.sprop, b)
+	if err != nil && !state.shouldContinue(err, nil) {
+		return err
+	}
+	o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	return state.err
+}
+
+func size_struct_group(p *Properties, base structPointer) (n int) {
+	b := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(b) {
+		return 0
+	}
+
+	n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))
+	n += size_struct(p.sprop, b)
+	n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	return
+}
+
+// Encode a slice of bools ([]bool).
+func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return ErrNil
+	}
+	for _, x := range s {
+		o.buf = append(o.buf, p.tagcode...)
+		v := uint64(0)
+		if x {
+			v = 1
+		}
+		p.valEnc(o, v)
+	}
+	return nil
+}
+
+func size_slice_bool(p *Properties, base structPointer) int {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return 0
+	}
+	return l * (len(p.tagcode) + 1) // each bool takes exactly one byte
+}
+
+// Encode a slice of bools ([]bool) in packed format.
+func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(l)) // each bool takes exactly one byte
+	for _, x := range s {
+		v := uint64(0)
+		if x {
+			v = 1
+		}
+		p.valEnc(o, v)
+	}
+	return nil
+}
+
+func size_slice_packed_bool(p *Properties, base structPointer) (n int) {
+	s := *structPointer_BoolSlice(base, p.field)
+	l := len(s)
+	if l == 0 {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(l))
+	n += l // each bool takes exactly one byte
+	return
+}
+
+// Encode a slice of bytes ([]byte).
+func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(s)
+	return nil
+}
+
+func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if len(s) == 0 {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(s)
+	return nil
+}
+
+func size_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeRawBytes(s)
+	return
+}
+
+func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if len(s) == 0 && !p.oneof {
+		return 0
+	}
+	n += len(p.tagcode)
+	n += sizeRawBytes(s)
+	return
+}
+
+// Encode a slice of int32s ([]int32).
+func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		p.valEnc(o, uint64(x))
+	}
+	return nil
+}
+
+func size_slice_int32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		n += p.valSize(uint64(x))
+	}
+	return
+}
+
+// Encode a slice of int32s ([]int32) in packed format.
+func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		p.valEnc(buf, uint64(x))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_int32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
+		bufSize += p.valSize(uint64(x))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of uint32s ([]uint32).
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		x := s.Index(i)
+		p.valEnc(o, uint64(x))
+	}
+	return nil
+}
+
+func size_slice_uint32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		x := s.Index(i)
+		n += p.valSize(uint64(x))
+	}
+	return
+}
+
+// Encode a slice of uint32s ([]uint32) in packed format.
+// Exactly the same as int32, except for no sign extension.
+func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		p.valEnc(buf, uint64(s.Index(i)))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word32Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		bufSize += p.valSize(uint64(s.Index(i)))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of int64s ([]int64).
+func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		p.valEnc(o, s.Index(i))
+	}
+	return nil
+}
+
+func size_slice_int64(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	for i := 0; i < l; i++ {
+		n += len(p.tagcode)
+		n += p.valSize(s.Index(i))
+	}
+	return
+}
+
+// Encode a slice of int64s ([]int64) in packed format.
+func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return ErrNil
+	}
+	// TODO: Reuse a Buffer.
+	buf := NewBuffer(nil)
+	for i := 0; i < l; i++ {
+		p.valEnc(buf, s.Index(i))
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeVarint(uint64(len(buf.buf)))
+	o.buf = append(o.buf, buf.buf...)
+	return nil
+}
+
+func size_slice_packed_int64(p *Properties, base structPointer) (n int) {
+	s := structPointer_Word64Slice(base, p.field)
+	l := s.Len()
+	if l == 0 {
+		return 0
+	}
+	var bufSize int
+	for i := 0; i < l; i++ {
+		bufSize += p.valSize(s.Index(i))
+	}
+
+	n += len(p.tagcode)
+	n += sizeVarint(uint64(bufSize))
+	n += bufSize
+	return
+}
+
+// Encode a slice of slice of bytes ([][]byte).
+func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {
+	ss := *structPointer_BytesSlice(base, p.field)
+	l := len(ss)
+	if l == 0 {
+		return ErrNil
+	}
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(ss[i])
+	}
+	return nil
+}
+
+func size_slice_slice_byte(p *Properties, base structPointer) (n int) {
+	ss := *structPointer_BytesSlice(base, p.field)
+	l := len(ss)
+	if l == 0 {
+		return 0
+	}
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		n += sizeRawBytes(ss[i])
+	}
+	return
+}
+
+// Encode a slice of strings ([]string).
+func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {
+	ss := *structPointer_StringSlice(base, p.field)
+	l := len(ss)
+	for i := 0; i < l; i++ {
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeStringBytes(ss[i])
+	}
+	return nil
+}
+
+func size_slice_string(p *Properties, base structPointer) (n int) {
+	ss := *structPointer_StringSlice(base, p.field)
+	l := len(ss)
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		n += sizeStringBytes(ss[i])
+	}
+	return
+}
+
+// Encode a slice of message structs ([]*struct).
+func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	for i := 0; i < l; i++ {
+		structp := s.Index(i)
+		if structPointer_IsNil(structp) {
+			return errRepeatedHasNil
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, err := m.Marshal()
+			if err != nil && !state.shouldContinue(err, nil) {
+				return err
+			}
+			o.buf = append(o.buf, p.tagcode...)
+			o.EncodeRawBytes(data)
+			continue
+		}
+
+		o.buf = append(o.buf, p.tagcode...)
+		err := o.enc_len_struct(p.sprop, structp, &state)
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+	}
+	return state.err
+}
+
+func size_slice_struct_message(p *Properties, base structPointer) (n int) {
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		structp := s.Index(i)
+		if structPointer_IsNil(structp) {
+			return // return the size up to this point
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, _ := m.Marshal()
+			n += sizeRawBytes(data)
+			continue
+		}
+
+		n0 := size_struct(p.sprop, structp)
+		n1 := sizeVarint(uint64(n0)) // size of encoded length
+		n += n0 + n1
+	}
+	return
+}
+
+// Encode a slice of group structs ([]*struct).
+func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {
+	var state errorState
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	for i := 0; i < l; i++ {
+		b := s.Index(i)
+		if structPointer_IsNil(b) {
+			return errRepeatedHasNil
+		}
+
+		o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
+
+		err := o.enc_struct(p.sprop, b)
+
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+
+		o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
+	}
+	return state.err
+}
+
+func size_slice_struct_group(p *Properties, base structPointer) (n int) {
+	s := structPointer_StructPointerSlice(base, p.field)
+	l := s.Len()
+
+	n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))
+	n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))
+	for i := 0; i < l; i++ {
+		b := s.Index(i)
+		if structPointer_IsNil(b) {
+			return // return size up to this point
+		}
+
+		n += size_struct(p.sprop, b)
+	}
+	return
+}
+
+// Encode an extension map.
+func (o *Buffer) enc_map(p *Properties, base structPointer) error {
+	exts := structPointer_ExtMap(base, p.field)
+	if err := encodeExtensionsMap(*exts); err != nil {
+		return err
+	}
+
+	return o.enc_map_body(*exts)
+}
+
+func (o *Buffer) enc_exts(p *Properties, base structPointer) error {
+	exts := structPointer_Extensions(base, p.field)
+
+	v, mu := exts.extensionsRead()
+	if v == nil {
+		return nil
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if err := encodeExtensionsMap(v); err != nil {
+		return err
+	}
+
+	return o.enc_map_body(v)
+}
+
+func (o *Buffer) enc_map_body(v map[int32]Extension) error {
+	// Fast-path for common cases: zero or one extensions.
+	if len(v) <= 1 {
+		for _, e := range v {
+			o.buf = append(o.buf, e.enc...)
+		}
+		return nil
+	}
+
+	// Sort keys to provide a deterministic encoding.
+	keys := make([]int, 0, len(v))
+	for k := range v {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+
+	for _, k := range keys {
+		o.buf = append(o.buf, v[int32(k)].enc...)
+	}
+	return nil
+}
+
+func size_map(p *Properties, base structPointer) int {
+	v := structPointer_ExtMap(base, p.field)
+	return extensionsMapSize(*v)
+}
+
+func size_exts(p *Properties, base structPointer) int {
+	v := structPointer_Extensions(base, p.field)
+	return extensionsSize(v)
+}
+
+// Encode a map field.
+func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
+	var state errorState // XXX: or do we need to plumb this through?
+
+	/*
+		A map defined as
+			map<key_type, value_type> map_field = N;
+		is encoded in the same way as
+			message MapFieldEntry {
+				key_type key = 1;
+				value_type value = 2;
+			}
+			repeated MapFieldEntry map_field = N;
+	*/
+
+	v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
+	if v.Len() == 0 {
+		return nil
+	}
+
+	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+	enc := func() error {
+		if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
+			return err
+		}
+		if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {
+			return err
+		}
+		return nil
+	}
+
+	// Don't sort map keys. It is not required by the spec, and C++ doesn't do it.
+	for _, key := range v.MapKeys() {
+		val := v.MapIndex(key)
+
+		keycopy.Set(key)
+		valcopy.Set(val)
+
+		o.buf = append(o.buf, p.tagcode...)
+		if err := o.enc_len_thing(enc, &state); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func size_new_map(p *Properties, base structPointer) int {
+	v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
+
+	keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
+
+	n := 0
+	for _, key := range v.MapKeys() {
+		val := v.MapIndex(key)
+		keycopy.Set(key)
+		valcopy.Set(val)
+
+		// Tag codes for key and val are the responsibility of the sub-sizer.
+		keysize := p.mkeyprop.size(p.mkeyprop, keybase)
+		valsize := p.mvalprop.size(p.mvalprop, valbase)
+		entry := keysize + valsize
+		// Add on tag code and length of map entry itself.
+		n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry
+	}
+	return n
+}
+
+// mapEncodeScratch returns a new reflect.Value matching the map's value type,
+// and a structPointer suitable for passing to an encoder or sizer.
+func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
+	// Prepare addressable doubly-indirect placeholders for the key and value types.
+	// This is needed because the element-type encoders expect **T, but the map iteration produces T.
+
+	keycopy = reflect.New(mapType.Key()).Elem()                 // addressable K
+	keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
+	keyptr.Set(keycopy.Addr())                                  //
+	keybase = toStructPointer(keyptr.Addr())                    // **K
+
+	// Value types are more varied and require special handling.
+	switch mapType.Elem().Kind() {
+	case reflect.Slice:
+		// []byte
+		var dummy []byte
+		valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
+		valbase = toStructPointer(valcopy.Addr())
+	case reflect.Ptr:
+		// message; the generated field type is map[K]*Msg (so V is *Msg),
+		// so we only need one level of indirection.
+		valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
+		valbase = toStructPointer(valcopy.Addr())
+	default:
+		// everything else
+		valcopy = reflect.New(mapType.Elem()).Elem()                // addressable V
+		valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
+		valptr.Set(valcopy.Addr())                                  //
+		valbase = toStructPointer(valptr.Addr())                    // **V
+	}
+	return
+}
+
+// Encode a struct.
+func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
+	var state errorState
+	// Encode fields in tag order so that decoders may use optimizations
+	// that depend on the ordering.
+	// https://developers.google.com/protocol-buffers/docs/encoding#order
+	for _, i := range prop.order {
+		p := prop.Prop[i]
+		if p.enc != nil {
+			err := p.enc(o, p, base)
+			if err != nil {
+				if err == ErrNil {
+					if p.Required && state.err == nil {
+						state.err = &RequiredNotSetError{p.Name}
+					}
+				} else if err == errRepeatedHasNil {
+					// Give more context to nil values in repeated fields.
+					return errors.New("repeated field " + p.OrigName + " has nil element")
+				} else if !state.shouldContinue(err, p) {
+					return err
+				}
+			}
+			if len(o.buf) > maxMarshalSize {
+				return ErrTooLarge
+			}
+		}
+	}
+
+	// Do oneof fields.
+	if prop.oneofMarshaler != nil {
+		m := structPointer_Interface(base, prop.stype).(Message)
+		if err := prop.oneofMarshaler(m, o); err == ErrNil {
+			return errOneofHasNil
+		} else if err != nil {
+			return err
+		}
+	}
+
+	// Add unrecognized fields at the end.
+	if prop.unrecField.IsValid() {
+		v := *structPointer_Bytes(base, prop.unrecField)
+		if len(o.buf)+len(v) > maxMarshalSize {
+			return ErrTooLarge
+		}
+		if len(v) > 0 {
+			o.buf = append(o.buf, v...)
+		}
+	}
+
+	return state.err
+}
+
+func size_struct(prop *StructProperties, base structPointer) (n int) {
+	for _, i := range prop.order {
+		p := prop.Prop[i]
+		if p.size != nil {
+			n += p.size(p, base)
+		}
+	}
+
+	// Add unrecognized fields at the end.
+	if prop.unrecField.IsValid() {
+		v := *structPointer_Bytes(base, prop.unrecField)
+		n += len(v)
+	}
+
+	// Factor in any oneof fields.
+	if prop.oneofSizer != nil {
+		m := structPointer_Interface(base, prop.stype).(Message)
+		n += prop.oneofSizer(m)
+	}
+
+	return
+}
+
+var zeroes [20]byte // longer than any conceivable sizeVarint
+
+// Encode a struct, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {
+	return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)
+}
+
+// Encode something, preceded by its encoded length (as a varint).
+func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {
+	iLen := len(o.buf)
+	o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length
+	iMsg := len(o.buf)
+	err := enc()
+	if err != nil && !state.shouldContinue(err, nil) {
+		return err
+	}
+	lMsg := len(o.buf) - iMsg
+	lLen := sizeVarint(uint64(lMsg))
+	switch x := lLen - (iMsg - iLen); {
+	case x > 0: // actual length is x bytes larger than the space we reserved
+		// Move msg x bytes right.
+		o.buf = append(o.buf, zeroes[:x]...)
+		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+	case x < 0: // actual length is x bytes smaller than the space we reserved
+		// Move msg x bytes left.
+		copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
+		o.buf = o.buf[:len(o.buf)+x] // x is negative
+	}
+	// Encode the length in the reserved space.
+	o.buf = o.buf[:iLen]
+	o.EncodeVarint(uint64(lMsg))
+	o.buf = o.buf[:len(o.buf)+lMsg]
+	return state.err
+}
+
+// errorState maintains the first error that occurs and updates that error
+// with additional context.
+type errorState struct {
+	err error
+}
+
+// shouldContinue reports whether encoding should continue upon encountering the
+// given error. If the error is RequiredNotSetError, shouldContinue returns true
+// and, if this is the first appearance of that error, remembers it for future
+// reporting.
+//
+// If prop is not nil, it may update any error with additional context about the
+// field with the error.
+func (s *errorState) shouldContinue(err error, prop *Properties) bool {
+	// Ignore unset required fields.
+	reqNotSet, ok := err.(*RequiredNotSetError)
+	if !ok {
+		return false
+	}
+	if s.err == nil {
+		if prop != nil {
+			err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}
+		}
+		s.err = err
+	}
+	return true
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/encode_gogo.go b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
new file mode 100644
index 000000000..32111b7f4
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/encode_gogo.go
@@ -0,0 +1,350 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// http://github.com/golang/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+)
+
+func NewRequiredNotSetError(field string) *RequiredNotSetError {
+	return &RequiredNotSetError{field}
+}
+
+type Sizer interface {
+	Size() int
+}
+
+func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, s...)
+	return nil
+}
+
+func size_ext_slice_byte(p *Properties, base structPointer) (n int) {
+	s := *structPointer_Bytes(base, p.field)
+	if s == nil {
+		return 0
+	}
+	n += len(s)
+	return
+}
+
+// Encode a reference to bool pointer.
+func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error {
+	v := *structPointer_BoolVal(base, p.field)
+	x := 0
+	if v {
+		x = 1
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_bool(p *Properties, base structPointer) int {
+	return len(p.tagcode) + 1 // each bool takes exactly one byte
+}
+
+// Encode a reference to int32 pointer.
+func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v))
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_int32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := int32(word32Val_Get(v))
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, uint64(x))
+	return nil
+}
+
+func size_ref_uint32(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word32Val(base, p.field)
+	x := word32Val_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(uint64(x))
+	return
+}
+
+// Encode a reference to an int64 pointer.
+func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	o.buf = append(o.buf, p.tagcode...)
+	p.valEnc(o, x)
+	return nil
+}
+
+func size_ref_int64(p *Properties, base structPointer) (n int) {
+	v := structPointer_Word64Val(base, p.field)
+	x := word64Val_Get(v)
+	n += len(p.tagcode)
+	n += p.valSize(x)
+	return
+}
+
+// Encode a reference to a string pointer.
+func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error {
+	v := *structPointer_StringVal(base, p.field)
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeStringBytes(v)
+	return nil
+}
+
+func size_ref_string(p *Properties, base structPointer) (n int) {
+	v := *structPointer_StringVal(base, p.field)
+	n += len(p.tagcode)
+	n += sizeStringBytes(v)
+	return
+}
+
+// Encode a reference to a message struct.
+func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	structp := structPointer_GetRefStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, err := m.Marshal()
+		if err != nil && !state.shouldContinue(err, nil) {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+		return nil
+	}
+
+	o.buf = append(o.buf, p.tagcode...)
+	return o.enc_len_struct(p.sprop, structp, &state)
+}
+
+//TODO this is only copied, please fix this
+func size_ref_struct_message(p *Properties, base structPointer) int {
+	structp := structPointer_GetRefStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+
+	// Can the object marshal itself?
+	if p.isMarshaler {
+		m := structPointer_Interface(structp, p.stype).(Marshaler)
+		data, _ := m.Marshal()
+		n0 := len(p.tagcode)
+		n1 := sizeRawBytes(data)
+		return n0 + n1
+	}
+
+	n0 := len(p.tagcode)
+	n1 := size_struct(p.sprop, structp)
+	n2 := sizeVarint(uint64(n1)) // size of encoded length
+	return n0 + n1 + n2
+}
+
+// Encode a slice of references to message struct pointers ([]struct).
+func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error {
+	var state errorState
+	ss := structPointer_StructRefSlice(base, p.field, p.stype.Size())
+	l := ss.Len()
+	for i := 0; i < l; i++ {
+		structp := ss.Index(i)
+		if structPointer_IsNil(structp) {
+			return errRepeatedHasNil
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, err := m.Marshal()
+			if err != nil && !state.shouldContinue(err, nil) {
+				return err
+			}
+			o.buf = append(o.buf, p.tagcode...)
+			o.EncodeRawBytes(data)
+			continue
+		}
+
+		o.buf = append(o.buf, p.tagcode...)
+		err := o.enc_len_struct(p.sprop, structp, &state)
+		if err != nil && !state.shouldContinue(err, nil) {
+			if err == ErrNil {
+				return errRepeatedHasNil
+			}
+			return err
+		}
+
+	}
+	return state.err
+}
+
+//TODO this is only copied, please fix this
+func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) {
+	ss := structPointer_StructRefSlice(base, p.field, p.stype.Size())
+	l := ss.Len()
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		structp := ss.Index(i)
+		if structPointer_IsNil(structp) {
+			return // return the size up to this point
+		}
+
+		// Can the object marshal itself?
+		if p.isMarshaler {
+			m := structPointer_Interface(structp, p.stype).(Marshaler)
+			data, _ := m.Marshal()
+			n += len(p.tagcode)
+			n += sizeRawBytes(data)
+			continue
+		}
+
+		n0 := size_struct(p.sprop, structp)
+		n1 := sizeVarint(uint64(n0)) // size of encoded length
+		n += n0 + n1
+	}
+	return
+}
+
+func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error {
+	i := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if i == nil {
+		return ErrNil
+	}
+	custom := i.(Marshaler)
+	data, err := custom.Marshal()
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_custom_bytes(p *Properties, base structPointer) (n int) {
+	n += len(p.tagcode)
+	i := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if i == nil {
+		return 0
+	}
+	custom := i.(Marshaler)
+	data, _ := custom.Marshal()
+	n += sizeRawBytes(data)
+	return
+}
+
+func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error {
+	custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler)
+	data, err := custom.Marshal()
+	if err != nil {
+		return err
+	}
+	if data == nil {
+		return ErrNil
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_custom_ref_bytes(p *Properties, base structPointer) (n int) {
+	n += len(p.tagcode)
+	i := structPointer_InterfaceAt(base, p.field, p.ctype)
+	if i == nil {
+		return 0
+	}
+	custom := i.(Marshaler)
+	data, _ := custom.Marshal()
+	n += sizeRawBytes(data)
+	return
+}
+
+func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error {
+	inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if inter == nil {
+		return ErrNil
+	}
+	slice := reflect.ValueOf(inter)
+	l := slice.Len()
+	for i := 0; i < l; i++ {
+		v := slice.Index(i)
+		custom := v.Interface().(Marshaler)
+		data, err := custom.Marshal()
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
+
+func size_custom_slice_bytes(p *Properties, base structPointer) (n int) {
+	inter := structPointer_InterfaceRef(base, p.field, p.ctype)
+	if inter == nil {
+		return 0
+	}
+	slice := reflect.ValueOf(inter)
+	l := slice.Len()
+	n += l * len(p.tagcode)
+	for i := 0; i < l; i++ {
+		v := slice.Index(i)
+		custom := v.Interface().(Marshaler)
+		data, _ := custom.Marshal()
+		n += sizeRawBytes(data)
+	}
+	return
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/equal.go b/vendor/github.com/gogo/protobuf/proto/equal.go
new file mode 100644
index 000000000..2ed1cf596
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/equal.go
@@ -0,0 +1,300 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2011 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Protocol buffer comparison.
+
+package proto
+
+import (
+	"bytes"
+	"log"
+	"reflect"
+	"strings"
+)
+
+/*
+Equal returns true iff protocol buffers a and b are equal.
+The arguments must both be pointers to protocol buffer structs.
+
+Equality is defined in this way:
+  - Two messages are equal iff they are the same type,
+    corresponding fields are equal, unknown field sets
+    are equal, and extensions sets are equal.
+  - Two set scalar fields are equal iff their values are equal.
+    If the fields are of a floating-point type, remember that
+    NaN != x for all x, including NaN. If the message is defined
+    in a proto3 .proto file, fields are not "set"; specifically,
+    zero length proto3 "bytes" fields are equal (nil == {}).
+  - Two repeated fields are equal iff their lengths are the same,
+    and their corresponding elements are equal. Note a "bytes" field,
+    although represented by []byte, is not a repeated field and the
+    rule for the scalar fields described above applies.
+  - Two unset fields are equal.
+  - Two unknown field sets are equal if their current
+    encoded state is equal.
+  - Two extension sets are equal iff they have corresponding
+    elements that are pairwise equal.
+  - Two map fields are equal iff their lengths are the same,
+    and they contain the same set of elements. Zero-length map
+    fields are equal.
+  - Every other combination of things are not equal.
+
+The return value is undefined if a and b are not protocol buffers.
+*/
+func Equal(a, b Message) bool {
+	if a == nil || b == nil {
+		return a == b
+	}
+	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
+	if v1.Type() != v2.Type() {
+		return false
+	}
+	if v1.Kind() == reflect.Ptr {
+		if v1.IsNil() {
+			return v2.IsNil()
+		}
+		if v2.IsNil() {
+			return false
+		}
+		v1, v2 = v1.Elem(), v2.Elem()
+	}
+	if v1.Kind() != reflect.Struct {
+		return false
+	}
+	return equalStruct(v1, v2)
+}
+
+// v1 and v2 are known to have the same type.
+func equalStruct(v1, v2 reflect.Value) bool {
+	sprop := GetProperties(v1.Type())
+	for i := 0; i < v1.NumField(); i++ {
+		f := v1.Type().Field(i)
+		if strings.HasPrefix(f.Name, "XXX_") {
+			continue
+		}
+		f1, f2 := v1.Field(i), v2.Field(i)
+		if f.Type.Kind() == reflect.Ptr {
+			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
+				// both unset
+				continue
+			} else if n1 != n2 {
+				// set/unset mismatch
+				return false
+			}
+			b1, ok := f1.Interface().(raw)
+			if ok {
+				b2 := f2.Interface().(raw)
+				// RawMessage
+				if !bytes.Equal(b1.Bytes(), b2.Bytes()) {
+					return false
+				}
+				continue
+			}
+			f1, f2 = f1.Elem(), f2.Elem()
+		}
+		if !equalAny(f1, f2, sprop.Prop[i]) {
+			return false
+		}
+	}
+
+	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
+		em2 := v2.FieldByName("XXX_InternalExtensions")
+		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
+			return false
+		}
+	}
+
+	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
+		em2 := v2.FieldByName("XXX_extensions")
+		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
+			return false
+		}
+	}
+
+	uf := v1.FieldByName("XXX_unrecognized")
+	if !uf.IsValid() {
+		return true
+	}
+
+	u1 := uf.Bytes()
+	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
+	if !bytes.Equal(u1, u2) {
+		return false
+	}
+
+	return true
+}
+
+// v1 and v2 are known to have the same type.
+// prop may be nil.
+func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
+	if v1.Type() == protoMessageType {
+		m1, _ := v1.Interface().(Message)
+		m2, _ := v2.Interface().(Message)
+		return Equal(m1, m2)
+	}
+	switch v1.Kind() {
+	case reflect.Bool:
+		return v1.Bool() == v2.Bool()
+	case reflect.Float32, reflect.Float64:
+		return v1.Float() == v2.Float()
+	case reflect.Int32, reflect.Int64:
+		return v1.Int() == v2.Int()
+	case reflect.Interface:
+		// Probably a oneof field; compare the inner values.
+		n1, n2 := v1.IsNil(), v2.IsNil()
+		if n1 || n2 {
+			return n1 == n2
+		}
+		e1, e2 := v1.Elem(), v2.Elem()
+		if e1.Type() != e2.Type() {
+			return false
+		}
+		return equalAny(e1, e2, nil)
+	case reflect.Map:
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for _, key := range v1.MapKeys() {
+			val2 := v2.MapIndex(key)
+			if !val2.IsValid() {
+				// This key was not found in the second map.
+				return false
+			}
+			if !equalAny(v1.MapIndex(key), val2, nil) {
+				return false
+			}
+		}
+		return true
+	case reflect.Ptr:
+		// Maps may have nil values in them, so check for nil.
+		if v1.IsNil() && v2.IsNil() {
+			return true
+		}
+		if v1.IsNil() != v2.IsNil() {
+			return false
+		}
+		return equalAny(v1.Elem(), v2.Elem(), prop)
+	case reflect.Slice:
+		if v1.Type().Elem().Kind() == reflect.Uint8 {
+			// short circuit: []byte
+
+			// Edge case: if this is in a proto3 message, a zero length
+			// bytes field is considered the zero value.
+			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
+				return true
+			}
+			if v1.IsNil() != v2.IsNil() {
+				return false
+			}
+			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
+		}
+
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		for i := 0; i < v1.Len(); i++ {
+			if !equalAny(v1.Index(i), v2.Index(i), prop) {
+				return false
+			}
+		}
+		return true
+	case reflect.String:
+		return v1.Interface().(string) == v2.Interface().(string)
+	case reflect.Struct:
+		return equalStruct(v1, v2)
+	case reflect.Uint32, reflect.Uint64:
+		return v1.Uint() == v2.Uint()
+	}
+
+	// unknown type, so not a protocol buffer
+	log.Printf("proto: don't know how to compare %v", v1)
+	return false
+}
+
+// base is the struct type that the extensions are based on.
+// x1 and x2 are InternalExtensions.
+func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
+	em1, _ := x1.extensionsRead()
+	em2, _ := x2.extensionsRead()
+	return equalExtMap(base, em1, em2)
+}
+
+func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
+	if len(em1) != len(em2) {
+		return false
+	}
+
+	for extNum, e1 := range em1 {
+		e2, ok := em2[extNum]
+		if !ok {
+			return false
+		}
+
+		m1, m2 := e1.value, e2.value
+
+		if m1 != nil && m2 != nil {
+			// Both are unencoded.
+			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+				return false
+			}
+			continue
+		}
+
+		// At least one is encoded. To do a semantically correct comparison
+		// we need to unmarshal them first.
+		var desc *ExtensionDesc
+		if m := extensionMaps[base]; m != nil {
+			desc = m[extNum]
+		}
+		if desc == nil {
+			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
+			continue
+		}
+		var err error
+		if m1 == nil {
+			m1, err = decodeExtension(e1.enc, desc)
+		}
+		if m2 == nil && err == nil {
+			m2, err = decodeExtension(e2.enc, desc)
+		}
+		if err != nil {
+			// The encoded form is invalid.
+			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
+			return false
+		}
+		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions.go b/vendor/github.com/gogo/protobuf/proto/extensions.go
new file mode 100644
index 000000000..0dfcb538e
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions.go
@@ -0,0 +1,693 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Types and routines for supporting protocol buffer extensions.
+ */
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"sync"
+)
+
+// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.
+var ErrMissingExtension = errors.New("proto: missing extension")
+
+// ExtensionRange represents a range of message extensions for a protocol buffer.
+// Used in code generated by the protocol compiler.
+type ExtensionRange struct {
+	Start, End int32 // both inclusive
+}
+
+// extendableProto is an interface implemented by any protocol buffer generated by the current
+// proto compiler that may be extended.
+type extendableProto interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+	extensionsWrite() map[int32]Extension
+	extensionsRead() (map[int32]Extension, sync.Locker)
+}
+
+// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous
+// version of the proto compiler that may be extended.
+type extendableProtoV1 interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+	ExtensionMap() map[int32]Extension
+}
+
+type extensionsBytes interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+	GetExtensions() *[]byte
+}
+
+// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto.
+type extensionAdapter struct {
+	extendableProtoV1
+}
+
+func (e extensionAdapter) extensionsWrite() map[int32]Extension {
+	return e.ExtensionMap()
+}
+
+func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) {
+	return e.ExtensionMap(), notLocker{}
+}
+
+// notLocker is a sync.Locker whose Lock and Unlock methods are nops.
+type notLocker struct{}
+
+func (n notLocker) Lock()   {}
+func (n notLocker) Unlock() {}
+
+// extendable returns the extendableProto interface for the given generated proto message.
+// If the proto message has the old extension format, it returns a wrapper that implements
+// the extendableProto interface.
+func extendable(p interface{}) (extendableProto, bool) {
+	if ep, ok := p.(extendableProto); ok {
+		return ep, ok
+	}
+	if ep, ok := p.(extendableProtoV1); ok {
+		return extensionAdapter{ep}, ok
+	}
+	return nil, false
+}
+
+// XXX_InternalExtensions is an internal representation of proto extensions.
+//
+// Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
+// thus gaining the unexported 'extensions' method, which can be called only from the proto package.
+//
+// The methods of XXX_InternalExtensions are not concurrency safe in general,
+// but calls to logically read-only methods such as has and get may be executed concurrently.
+type XXX_InternalExtensions struct {
+	// The struct must be indirect so that if a user inadvertently copies a
+	// generated message and its embedded XXX_InternalExtensions, they
+	// avoid the mayhem of a copied mutex.
+	//
+	// The mutex serializes all logically read-only operations to p.extensionMap.
+	// It is up to the client to ensure that write operations to p.extensionMap are
+	// mutually exclusive with other accesses.
+	p *struct {
+		mu           sync.Mutex
+		extensionMap map[int32]Extension
+	}
+}
+
+// extensionsWrite returns the extension map, creating it on first use.
+func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension {
+	if e.p == nil {
+		e.p = new(struct {
+			mu           sync.Mutex
+			extensionMap map[int32]Extension
+		})
+		e.p.extensionMap = make(map[int32]Extension)
+	}
+	return e.p.extensionMap
+}
+
+// extensionsRead returns the extensions map for read-only use.  It may be nil.
+// The caller must hold the returned mutex's lock when accessing Elements within the map.
+func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) {
+	if e.p == nil {
+		return nil, nil
+	}
+	return e.p.extensionMap, &e.p.mu
+}
+
+type extensionRange interface {
+	Message
+	ExtensionRangeArray() []ExtensionRange
+}
+
+var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()
+var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()
+var extendableBytesType = reflect.TypeOf((*extensionsBytes)(nil)).Elem()
+var extensionRangeType = reflect.TypeOf((*extensionRange)(nil)).Elem()
+
+// ExtensionDesc represents an extension specification.
+// Used in generated code from the protocol compiler.
+type ExtensionDesc struct {
+	ExtendedType  Message     // nil pointer to the type that is being extended
+	ExtensionType interface{} // nil pointer to the extension type
+	Field         int32       // field number
+	Name          string      // fully-qualified name of extension, for text formatting
+	Tag           string      // protobuf tag style
+	Filename      string      // name of the file in which the extension is defined
+}
+
+func (ed *ExtensionDesc) repeated() bool {
+	t := reflect.TypeOf(ed.ExtensionType)
+	return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+}
+
+// Extension represents an extension in a message.
+type Extension struct {
+	// When an extension is stored in a message using SetExtension
+	// only desc and value are set. When the message is marshaled
+	// enc will be set to the encoded form of the message.
+	//
+	// When a message is unmarshaled and contains extensions, each
+	// extension will have only enc set. When such an extension is
+	// accessed using GetExtension (or GetExtensions) desc and value
+	// will be set.
+	desc  *ExtensionDesc
+	value interface{}
+	enc   []byte
+}
+
+// SetRawExtension is for testing only.
+func SetRawExtension(base Message, id int32, b []byte) {
+	if ebase, ok := base.(extensionsBytes); ok {
+		clearExtension(base, id)
+		ext := ebase.GetExtensions()
+		*ext = append(*ext, b...)
+		return
+	}
+	epb, ok := extendable(base)
+	if !ok {
+		return
+	}
+	extmap := epb.extensionsWrite()
+	extmap[id] = Extension{enc: b}
+}
+
+// isExtensionField returns true iff the given field number is in an extension range.
+func isExtensionField(pb extensionRange, field int32) bool {
+	for _, er := range pb.ExtensionRangeArray() {
+		if er.Start <= field && field <= er.End {
+			return true
+		}
+	}
+	return false
+}
+
+// checkExtensionTypes checks that the given extension is valid for pb.
+func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {
+	var pbi interface{} = pb
+	// Check the extended type.
+	if ea, ok := pbi.(extensionAdapter); ok {
+		pbi = ea.extendableProtoV1
+	}
+	if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {
+		return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())
+	}
+	// Check the range.
+	if !isExtensionField(pb, extension.Field) {
+		return errors.New("proto: bad extension number; not in declared ranges")
+	}
+	return nil
+}
+
+// extPropKey is sufficient to uniquely identify an extension.
+type extPropKey struct {
+	base  reflect.Type
+	field int32
+}
+
+var extProp = struct {
+	sync.RWMutex
+	m map[extPropKey]*Properties
+}{
+	m: make(map[extPropKey]*Properties),
+}
+
+func extensionProperties(ed *ExtensionDesc) *Properties {
+	key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field}
+
+	extProp.RLock()
+	if prop, ok := extProp.m[key]; ok {
+		extProp.RUnlock()
+		return prop
+	}
+	extProp.RUnlock()
+
+	extProp.Lock()
+	defer extProp.Unlock()
+	// Check again.
+	if prop, ok := extProp.m[key]; ok {
+		return prop
+	}
+
+	prop := new(Properties)
+	prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil)
+	extProp.m[key] = prop
+	return prop
+}
+
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensions(e *XXX_InternalExtensions) error {
+	m, mu := e.extensionsRead()
+	if m == nil {
+		return nil // fast path
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	return encodeExtensionsMap(m)
+}
+
+// encode encodes any unmarshaled (unencoded) extensions in e.
+func encodeExtensionsMap(m map[int32]Extension) error {
+	for k, e := range m {
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		et := reflect.TypeOf(e.desc.ExtensionType)
+		props := extensionProperties(e.desc)
+
+		p := NewBuffer(nil)
+		// If e.value has type T, the encoder expects a *struct{ X T }.
+		// Pass a *T with a zero field and hope it all works out.
+		x := reflect.New(et)
+		x.Elem().Set(reflect.ValueOf(e.value))
+		if err := props.enc(p, props, toStructPointer(x)); err != nil {
+			return err
+		}
+		e.enc = p.buf
+		m[k] = e
+	}
+	return nil
+}
+
+func extensionsSize(e *XXX_InternalExtensions) (n int) {
+	m, mu := e.extensionsRead()
+	if m == nil {
+		return 0
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	return extensionsMapSize(m)
+}
+
+func extensionsMapSize(m map[int32]Extension) (n int) {
+	for _, e := range m {
+		if e.value == nil || e.desc == nil {
+			// Extension is only in its encoded form.
+			n += len(e.enc)
+			continue
+		}
+
+		// We don't skip extensions that have an encoded form set,
+		// because the extension value may have been mutated after
+		// the last time this function was called.
+
+		et := reflect.TypeOf(e.desc.ExtensionType)
+		props := extensionProperties(e.desc)
+
+		// If e.value has type T, the encoder expects a *struct{ X T }.
+		// Pass a *T with a zero field and hope it all works out.
+		x := reflect.New(et)
+		x.Elem().Set(reflect.ValueOf(e.value))
+		n += props.size(props, toStructPointer(x))
+	}
+	return
+}
+
+// HasExtension returns whether the given extension is present in pb.
+func HasExtension(pb Message, extension *ExtensionDesc) bool {
+	if epb, doki := pb.(extensionsBytes); doki {
+		ext := epb.GetExtensions()
+		buf := *ext
+		o := 0
+		for o < len(buf) {
+			tag, n := DecodeVarint(buf[o:])
+			fieldNum := int32(tag >> 3)
+			if int32(fieldNum) == extension.Field {
+				return true
+			}
+			wireType := int(tag & 0x7)
+			o += n
+			l, err := size(buf[o:], wireType)
+			if err != nil {
+				return false
+			}
+			o += l
+		}
+		return false
+	}
+	// TODO: Check types, field numbers, etc.?
+	epb, ok := extendable(pb)
+	if !ok {
+		return false
+	}
+	extmap, mu := epb.extensionsRead()
+	if extmap == nil {
+		return false
+	}
+	mu.Lock()
+	_, ok = extmap[extension.Field]
+	mu.Unlock()
+	return ok
+}
+
+func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int {
+	ext := pb.GetExtensions()
+	for offset < len(*ext) {
+		tag, n1 := DecodeVarint((*ext)[offset:])
+		fieldNum := int32(tag >> 3)
+		wireType := int(tag & 0x7)
+		n2, err := size((*ext)[offset+n1:], wireType)
+		if err != nil {
+			panic(err)
+		}
+		newOffset := offset + n1 + n2
+		if fieldNum == theFieldNum {
+			*ext = append((*ext)[:offset], (*ext)[newOffset:]...)
+			return offset
+		}
+		offset = newOffset
+	}
+	return -1
+}
+
+// ClearExtension removes the given extension from pb.
+func ClearExtension(pb Message, extension *ExtensionDesc) {
+	clearExtension(pb, extension.Field)
+}
+
+func clearExtension(pb Message, fieldNum int32) {
+	if epb, doki := pb.(extensionsBytes); doki {
+		offset := 0
+		for offset != -1 {
+			offset = deleteExtension(epb, fieldNum, offset)
+		}
+		return
+	}
+	epb, ok := extendable(pb)
+	if !ok {
+		return
+	}
+	// TODO: Check types, field numbers, etc.?
+	extmap := epb.extensionsWrite()
+	delete(extmap, fieldNum)
+}
+
+// GetExtension parses and returns the given extension of pb.
+// If the extension is not present and has no default value it returns ErrMissingExtension.
+func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
+	if epb, doki := pb.(extensionsBytes); doki {
+		ext := epb.GetExtensions()
+		o := 0
+		for o < len(*ext) {
+			tag, n := DecodeVarint((*ext)[o:])
+			fieldNum := int32(tag >> 3)
+			wireType := int(tag & 0x7)
+			l, err := size((*ext)[o+n:], wireType)
+			if err != nil {
+				return nil, err
+			}
+			if int32(fieldNum) == extension.Field {
+				v, err := decodeExtension((*ext)[o:o+n+l], extension)
+				if err != nil {
+					return nil, err
+				}
+				return v, nil
+			}
+			o += n + l
+		}
+		return defaultExtensionValue(extension)
+	}
+	epb, ok := extendable(pb)
+	if !ok {
+		return nil, errors.New("proto: not an extendable proto")
+	}
+	if err := checkExtensionTypes(epb, extension); err != nil {
+		return nil, err
+	}
+
+	emap, mu := epb.extensionsRead()
+	if emap == nil {
+		return defaultExtensionValue(extension)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	e, ok := emap[extension.Field]
+	if !ok {
+		// defaultExtensionValue returns the default value or
+		// ErrMissingExtension if there is no default.
+		return defaultExtensionValue(extension)
+	}
+
+	if e.value != nil {
+		// Already decoded. Check the descriptor, though.
+		if e.desc != extension {
+			// This shouldn't happen. If it does, it means that
+			// GetExtension was called twice with two different
+			// descriptors with the same field number.
+			return nil, errors.New("proto: descriptor conflict")
+		}
+		return e.value, nil
+	}
+
+	v, err := decodeExtension(e.enc, extension)
+	if err != nil {
+		return nil, err
+	}
+
+	// Remember the decoded version and drop the encoded version.
+	// That way it is safe to mutate what we return.
+	e.value = v
+	e.desc = extension
+	e.enc = nil
+	emap[extension.Field] = e
+	return e.value, nil
+}
+
+// defaultExtensionValue returns the default value for extension.
+// If no default for an extension is defined ErrMissingExtension is returned.
+func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
+	t := reflect.TypeOf(extension.ExtensionType)
+	props := extensionProperties(extension)
+
+	sf, _, err := fieldDefault(t, props)
+	if err != nil {
+		return nil, err
+	}
+
+	if sf == nil || sf.value == nil {
+		// There is no default value.
+		return nil, ErrMissingExtension
+	}
+
+	if t.Kind() != reflect.Ptr {
+		// We do not need to return a Ptr, we can directly return sf.value.
+		return sf.value, nil
+	}
+
+	// We need to return an interface{} that is a pointer to sf.value.
+	value := reflect.New(t).Elem()
+	value.Set(reflect.New(value.Type().Elem()))
+	if sf.kind == reflect.Int32 {
+		// We may have an int32 or an enum, but the underlying data is int32.
+		// Since we can't set an int32 into a non int32 reflect.value directly
+		// set it as a int32.
+		value.Elem().SetInt(int64(sf.value.(int32)))
+	} else {
+		value.Elem().Set(reflect.ValueOf(sf.value))
+	}
+	return value.Interface(), nil
+}
+
+// decodeExtension decodes an extension encoded in b.
+func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {
+	o := NewBuffer(b)
+
+	t := reflect.TypeOf(extension.ExtensionType)
+
+	props := extensionProperties(extension)
+
+	// t is a pointer to a struct, pointer to basic type or a slice.
+	// Allocate a "field" to store the pointer/slice itself; the
+	// pointer/slice will be stored here. We pass
+	// the address of this field to props.dec.
+	// This passes a zero field and a *t and lets props.dec
+	// interpret it as a *struct{ x t }.
+	value := reflect.New(t).Elem()
+
+	for {
+		// Discard wire type and field number varint. It isn't needed.
+		if _, err := o.DecodeVarint(); err != nil {
+			return nil, err
+		}
+
+		if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil {
+			return nil, err
+		}
+
+		if o.index >= len(o.buf) {
+			break
+		}
+	}
+	return value.Interface(), nil
+}
+
+// GetExtensions returns a slice of the extensions present in pb that are also listed in es.
+// The returned slice has the same length as es; missing extensions will appear as nil elements.
+func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {
+	extensions = make([]interface{}, len(es))
+	for i, e := range es {
+		extensions[i], err = GetExtension(pb, e)
+		if err == ErrMissingExtension {
+			err = nil
+		}
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
+// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
+// just the Field field, which defines the extension's field number.
+func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {
+	epb, ok := extendable(pb)
+	if !ok {
+		return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)
+	}
+	registeredExtensions := RegisteredExtensions(pb)
+
+	emap, mu := epb.extensionsRead()
+	if emap == nil {
+		return nil, nil
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	extensions := make([]*ExtensionDesc, 0, len(emap))
+	for extid, e := range emap {
+		desc := e.desc
+		if desc == nil {
+			desc = registeredExtensions[extid]
+			if desc == nil {
+				desc = &ExtensionDesc{Field: extid}
+			}
+		}
+
+		extensions = append(extensions, desc)
+	}
+	return extensions, nil
+}
+
+// SetExtension sets the specified extension of pb to the specified value.
+func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {
+	if epb, doki := pb.(extensionsBytes); doki {
+		ClearExtension(pb, extension)
+		ext := epb.GetExtensions()
+		et := reflect.TypeOf(extension.ExtensionType)
+		props := extensionProperties(extension)
+		p := NewBuffer(nil)
+		x := reflect.New(et)
+		x.Elem().Set(reflect.ValueOf(value))
+		if err := props.enc(p, props, toStructPointer(x)); err != nil {
+			return err
+		}
+		*ext = append(*ext, p.buf...)
+		return nil
+	}
+	epb, ok := extendable(pb)
+	if !ok {
+		return errors.New("proto: not an extendable proto")
+	}
+	if err := checkExtensionTypes(epb, extension); err != nil {
+		return err
+	}
+	typ := reflect.TypeOf(extension.ExtensionType)
+	if typ != reflect.TypeOf(value) {
+		return errors.New("proto: bad extension value type")
+	}
+	// nil extension values need to be caught early, because the
+	// encoder can't distinguish an ErrNil due to a nil extension
+	// from an ErrNil due to a missing field. Extensions are
+	// always optional, so the encoder would just swallow the error
+	// and drop all the extensions from the encoded message.
+	if reflect.ValueOf(value).IsNil() {
+		return fmt.Errorf("proto: SetExtension called with nil value of type %T", value)
+	}
+
+	extmap := epb.extensionsWrite()
+	extmap[extension.Field] = Extension{desc: extension, value: value}
+	return nil
+}
+
+// ClearAllExtensions clears all extensions from pb.
+func ClearAllExtensions(pb Message) {
+	if epb, doki := pb.(extensionsBytes); doki {
+		ext := epb.GetExtensions()
+		*ext = []byte{}
+		return
+	}
+	epb, ok := extendable(pb)
+	if !ok {
+		return
+	}
+	m := epb.extensionsWrite()
+	for k := range m {
+		delete(m, k)
+	}
+}
+
+// A global registry of extensions.
+// The generated code will register the generated descriptors by calling RegisterExtension.
+
+var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc)
+
+// RegisterExtension is called from the generated code.
+func RegisterExtension(desc *ExtensionDesc) {
+	st := reflect.TypeOf(desc.ExtendedType).Elem()
+	m := extensionMaps[st]
+	if m == nil {
+		m = make(map[int32]*ExtensionDesc)
+		extensionMaps[st] = m
+	}
+	if _, ok := m[desc.Field]; ok {
+		panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field)))
+	}
+	m[desc.Field] = desc
+}
+
+// RegisteredExtensions returns a map of the registered extensions of a
+// protocol buffer struct, indexed by the extension number.
+// The argument pb should be a nil pointer to the struct type.
+func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
+	return extensionMaps[reflect.TypeOf(pb).Elem()]
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
new file mode 100644
index 000000000..ea6478f00
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/extensions_gogo.go
@@ -0,0 +1,294 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+)
+
+func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool {
+	if reflect.ValueOf(pb).IsNil() {
+		return ifnotset
+	}
+	value, err := GetExtension(pb, extension)
+	if err != nil {
+		return ifnotset
+	}
+	if value == nil {
+		return ifnotset
+	}
+	if value.(*bool) == nil {
+		return ifnotset
+	}
+	return *(value.(*bool))
+}
+
+func (this *Extension) Equal(that *Extension) bool {
+	return bytes.Equal(this.enc, that.enc)
+}
+
+func (this *Extension) Compare(that *Extension) int {
+	return bytes.Compare(this.enc, that.enc)
+}
+
+func SizeOfInternalExtension(m extendableProto) (n int) {
+	return SizeOfExtensionMap(m.extensionsWrite())
+}
+
+func SizeOfExtensionMap(m map[int32]Extension) (n int) {
+	return extensionsMapSize(m)
+}
+
+type sortableMapElem struct {
+	field int32
+	ext   Extension
+}
+
+func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions {
+	s := make(sortableExtensions, 0, len(m))
+	for k, v := range m {
+		s = append(s, &sortableMapElem{field: k, ext: v})
+	}
+	return s
+}
+
+type sortableExtensions []*sortableMapElem
+
+func (this sortableExtensions) Len() int { return len(this) }
+
+func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] }
+
+func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field }
+
+func (this sortableExtensions) String() string {
+	sort.Sort(this)
+	ss := make([]string, len(this))
+	for i := range this {
+		ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext)
+	}
+	return "map[" + strings.Join(ss, ",") + "]"
+}
+
+func StringFromInternalExtension(m extendableProto) string {
+	return StringFromExtensionsMap(m.extensionsWrite())
+}
+
+func StringFromExtensionsMap(m map[int32]Extension) string {
+	return newSortableExtensionsFromMap(m).String()
+}
+
+func StringFromExtensionsBytes(ext []byte) string {
+	m, err := BytesToExtensionsMap(ext)
+	if err != nil {
+		panic(err)
+	}
+	return StringFromExtensionsMap(m)
+}
+
+func EncodeInternalExtension(m extendableProto, data []byte) (n int, err error) {
+	return EncodeExtensionMap(m.extensionsWrite(), data)
+}
+
+func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) {
+	if err := encodeExtensionsMap(m); err != nil {
+		return 0, err
+	}
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+	for _, k := range keys {
+		n += copy(data[n:], m[int32(k)].enc)
+	}
+	return n, nil
+}
+
+func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) {
+	if m[id].value == nil || m[id].desc == nil {
+		return m[id].enc, nil
+	}
+	if err := encodeExtensionsMap(m); err != nil {
+		return nil, err
+	}
+	return m[id].enc, nil
+}
+
+func size(buf []byte, wire int) (int, error) {
+	switch wire {
+	case WireVarint:
+		_, n := DecodeVarint(buf)
+		return n, nil
+	case WireFixed64:
+		return 8, nil
+	case WireBytes:
+		v, n := DecodeVarint(buf)
+		return int(v) + n, nil
+	case WireFixed32:
+		return 4, nil
+	case WireStartGroup:
+		offset := 0
+		for {
+			u, n := DecodeVarint(buf[offset:])
+			fwire := int(u & 0x7)
+			offset += n
+			if fwire == WireEndGroup {
+				return offset, nil
+			}
+			s, err := size(buf[offset:], wire)
+			if err != nil {
+				return 0, err
+			}
+			offset += s
+		}
+	}
+	return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire)
+}
+
+func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) {
+	m := make(map[int32]Extension)
+	i := 0
+	for i < len(buf) {
+		tag, n := DecodeVarint(buf[i:])
+		if n <= 0 {
+			return nil, fmt.Errorf("unable to decode varint")
+		}
+		fieldNum := int32(tag >> 3)
+		wireType := int(tag & 0x7)
+		l, err := size(buf[i+n:], wireType)
+		if err != nil {
+			return nil, err
+		}
+		end := i + int(l) + n
+		m[int32(fieldNum)] = Extension{enc: buf[i:end]}
+		i = end
+	}
+	return m, nil
+}
+
+func NewExtension(e []byte) Extension {
+	ee := Extension{enc: make([]byte, len(e))}
+	copy(ee.enc, e)
+	return ee
+}
+
+func AppendExtension(e Message, tag int32, buf []byte) {
+	if ee, eok := e.(extensionsBytes); eok {
+		ext := ee.GetExtensions()
+		*ext = append(*ext, buf...)
+		return
+	}
+	if ee, eok := e.(extendableProto); eok {
+		m := ee.extensionsWrite()
+		ext := m[int32(tag)] // may be missing
+		ext.enc = append(ext.enc, buf...)
+		m[int32(tag)] = ext
+	}
+}
+
+func encodeExtension(e *Extension) error {
+	if e.value == nil || e.desc == nil {
+		// Extension is only in its encoded form.
+		return nil
+	}
+	// We don't skip extensions that have an encoded form set,
+	// because the extension value may have been mutated after
+	// the last time this function was called.
+
+	et := reflect.TypeOf(e.desc.ExtensionType)
+	props := extensionProperties(e.desc)
+
+	p := NewBuffer(nil)
+	// If e.value has type T, the encoder expects a *struct{ X T }.
+	// Pass a *T with a zero field and hope it all works out.
+	x := reflect.New(et)
+	x.Elem().Set(reflect.ValueOf(e.value))
+	if err := props.enc(p, props, toStructPointer(x)); err != nil {
+		return err
+	}
+	e.enc = p.buf
+	return nil
+}
+
+func (this Extension) GoString() string {
+	if this.enc == nil {
+		if err := encodeExtension(&this); err != nil {
+			panic(err)
+		}
+	}
+	return fmt.Sprintf("proto.NewExtension(%#v)", this.enc)
+}
+
+func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error {
+	typ := reflect.TypeOf(pb).Elem()
+	ext, ok := extensionMaps[typ]
+	if !ok {
+		return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+	}
+	desc, ok := ext[fieldNum]
+	if !ok {
+		return errors.New("proto: bad extension number; not in declared ranges")
+	}
+	return SetExtension(pb, desc, value)
+}
+
+func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error) {
+	typ := reflect.TypeOf(pb).Elem()
+	ext, ok := extensionMaps[typ]
+	if !ok {
+		return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String())
+	}
+	desc, ok := ext[fieldNum]
+	if !ok {
+		return nil, fmt.Errorf("unregistered field number %d", fieldNum)
+	}
+	return GetExtension(pb, desc)
+}
+
+func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions {
+	x := &XXX_InternalExtensions{
+		p: new(struct {
+			mu           sync.Mutex
+			extensionMap map[int32]Extension
+		}),
+	}
+	x.p.extensionMap = m
+	return *x
+}
+
+func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension {
+	pb := extendable.(extendableProto)
+	return pb.extensionsWrite()
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/lib.go b/vendor/github.com/gogo/protobuf/proto/lib.go
new file mode 100644
index 000000000..c98d73da4
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib.go
@@ -0,0 +1,897 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package proto converts data structures to and from the wire format of
+protocol buffers.  It works in concert with the Go source code generated
+for .proto files by the protocol compiler.
+
+A summary of the properties of the protocol buffer interface
+for a protocol buffer variable v:
+
+  - Names are turned from camel_case to CamelCase for export.
+  - There are no methods on v to set fields; just treat
+	them as structure fields.
+  - There are getters that return a field's value if set,
+	and return the field's default value if unset.
+	The getters work even if the receiver is a nil message.
+  - The zero value for a struct is its correct initialization state.
+	All desired fields must be set before marshaling.
+  - A Reset() method will restore a protobuf struct to its zero state.
+  - Non-repeated fields are pointers to the values; nil means unset.
+	That is, optional or required field int32 f becomes F *int32.
+  - Repeated fields are slices.
+  - Helper functions are available to aid the setting of fields.
+	msg.Foo = proto.String("hello") // set field
+  - Constants are defined to hold the default values of all fields that
+	have them.  They have the form Default_StructName_FieldName.
+	Because the getter methods handle defaulted values,
+	direct use of these constants should be rare.
+  - Enums are given type names and maps from names to values.
+	Enum values are prefixed by the enclosing message's name, or by the
+	enum's type name if it is a top-level enum. Enum types have a String
+	method, and a Enum method to assist in message construction.
+  - Nested messages, groups and enums have type names prefixed with the name of
+	the surrounding message type.
+  - Extensions are given descriptor names that start with E_,
+	followed by an underscore-delimited list of the nested messages
+	that contain it (if any) followed by the CamelCased name of the
+	extension field itself.  HasExtension, ClearExtension, GetExtension
+	and SetExtension are functions for manipulating extensions.
+  - Oneof field sets are given a single field in their message,
+	with distinguished wrapper types for each possible field value.
+  - Marshal and Unmarshal are functions to encode and decode the wire format.
+
+When the .proto file specifies `syntax="proto3"`, there are some differences:
+
+  - Non-repeated fields of non-message type are values instead of pointers.
+  - Enum types do not get an Enum method.
+
+The simplest way to describe this is to see an example.
+Given file test.proto, containing
+
+	package example;
+
+	enum FOO { X = 17; }
+
+	message Test {
+	  required string label = 1;
+	  optional int32 type = 2 [default=77];
+	  repeated int64 reps = 3;
+	  optional group OptionalGroup = 4 {
+	    required string RequiredField = 5;
+	  }
+	  oneof union {
+	    int32 number = 6;
+	    string name = 7;
+	  }
+	}
+
+The resulting file, test.pb.go, is:
+
+	package example
+
+	import proto "github.com/gogo/protobuf/proto"
+	import math "math"
+
+	type FOO int32
+	const (
+		FOO_X FOO = 17
+	)
+	var FOO_name = map[int32]string{
+		17: "X",
+	}
+	var FOO_value = map[string]int32{
+		"X": 17,
+	}
+
+	func (x FOO) Enum() *FOO {
+		p := new(FOO)
+		*p = x
+		return p
+	}
+	func (x FOO) String() string {
+		return proto.EnumName(FOO_name, int32(x))
+	}
+	func (x *FOO) UnmarshalJSON(data []byte) error {
+		value, err := proto.UnmarshalJSONEnum(FOO_value, data)
+		if err != nil {
+			return err
+		}
+		*x = FOO(value)
+		return nil
+	}
+
+	type Test struct {
+		Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
+		Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
+		Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
+		Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
+		// Types that are valid to be assigned to Union:
+		//	*Test_Number
+		//	*Test_Name
+		Union            isTest_Union `protobuf_oneof:"union"`
+		XXX_unrecognized []byte       `json:"-"`
+	}
+	func (m *Test) Reset()         { *m = Test{} }
+	func (m *Test) String() string { return proto.CompactTextString(m) }
+	func (*Test) ProtoMessage() {}
+
+	type isTest_Union interface {
+		isTest_Union()
+	}
+
+	type Test_Number struct {
+		Number int32 `protobuf:"varint,6,opt,name=number"`
+	}
+	type Test_Name struct {
+		Name string `protobuf:"bytes,7,opt,name=name"`
+	}
+
+	func (*Test_Number) isTest_Union() {}
+	func (*Test_Name) isTest_Union()   {}
+
+	func (m *Test) GetUnion() isTest_Union {
+		if m != nil {
+			return m.Union
+		}
+		return nil
+	}
+	const Default_Test_Type int32 = 77
+
+	func (m *Test) GetLabel() string {
+		if m != nil && m.Label != nil {
+			return *m.Label
+		}
+		return ""
+	}
+
+	func (m *Test) GetType() int32 {
+		if m != nil && m.Type != nil {
+			return *m.Type
+		}
+		return Default_Test_Type
+	}
+
+	func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
+		if m != nil {
+			return m.Optionalgroup
+		}
+		return nil
+	}
+
+	type Test_OptionalGroup struct {
+		RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
+	}
+	func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
+	func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
+
+	func (m *Test_OptionalGroup) GetRequiredField() string {
+		if m != nil && m.RequiredField != nil {
+			return *m.RequiredField
+		}
+		return ""
+	}
+
+	func (m *Test) GetNumber() int32 {
+		if x, ok := m.GetUnion().(*Test_Number); ok {
+			return x.Number
+		}
+		return 0
+	}
+
+	func (m *Test) GetName() string {
+		if x, ok := m.GetUnion().(*Test_Name); ok {
+			return x.Name
+		}
+		return ""
+	}
+
+	func init() {
+		proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
+	}
+
+To create and play with a Test object:
+
+	package main
+
+	import (
+		"log"
+
+		"github.com/gogo/protobuf/proto"
+		pb "./example.pb"
+	)
+
+	func main() {
+		test := &pb.Test{
+			Label: proto.String("hello"),
+			Type:  proto.Int32(17),
+			Reps:  []int64{1, 2, 3},
+			Optionalgroup: &pb.Test_OptionalGroup{
+				RequiredField: proto.String("good bye"),
+			},
+			Union: &pb.Test_Name{"fred"},
+		}
+		data, err := proto.Marshal(test)
+		if err != nil {
+			log.Fatal("marshaling error: ", err)
+		}
+		newTest := &pb.Test{}
+		err = proto.Unmarshal(data, newTest)
+		if err != nil {
+			log.Fatal("unmarshaling error: ", err)
+		}
+		// Now test and newTest contain the same data.
+		if test.GetLabel() != newTest.GetLabel() {
+			log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
+		}
+		// Use a type switch to determine which oneof was set.
+		switch u := test.Union.(type) {
+		case *pb.Test_Number: // u.Number contains the number.
+		case *pb.Test_Name: // u.Name contains the string.
+		}
+		// etc.
+	}
+*/
+package proto
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"reflect"
+	"sort"
+	"strconv"
+	"sync"
+)
+
+// Message is implemented by generated protocol buffer messages.
+type Message interface {
+	Reset()
+	String() string
+	ProtoMessage()
+}
+
+// Stats records allocation details about the protocol buffer encoders
+// and decoders.  Useful for tuning the library itself.
+type Stats struct {
+	Emalloc uint64 // mallocs in encode
+	Dmalloc uint64 // mallocs in decode
+	Encode  uint64 // number of encodes
+	Decode  uint64 // number of decodes
+	Chit    uint64 // number of cache hits
+	Cmiss   uint64 // number of cache misses
+	Size    uint64 // number of sizes
+}
+
+// Set to true to enable stats collection.
+const collectStats = false
+
+var stats Stats
+
+// GetStats returns a copy of the global Stats structure.
+func GetStats() Stats { return stats }
+
+// A Buffer is a buffer manager for marshaling and unmarshaling
+// protocol buffers.  It may be reused between invocations to
+// reduce memory usage.  It is not necessary to use a Buffer;
+// the global functions Marshal and Unmarshal create a
+// temporary Buffer and are fine for most applications.
+type Buffer struct {
+	buf   []byte // encode/decode byte stream
+	index int    // read point
+
+	// pools of basic types to amortize allocation.
+	bools   []bool
+	uint32s []uint32
+	uint64s []uint64
+
+	// extra pools, only used with pointer_reflect.go
+	int32s   []int32
+	int64s   []int64
+	float32s []float32
+	float64s []float64
+}
+
+// NewBuffer allocates a new Buffer and initializes its internal data to
+// the contents of the argument slice.
+func NewBuffer(e []byte) *Buffer {
+	return &Buffer{buf: e}
+}
+
+// Reset resets the Buffer, ready for marshaling a new protocol buffer.
+func (p *Buffer) Reset() {
+	p.buf = p.buf[0:0] // for reading/writing
+	p.index = 0        // for reading
+}
+
+// SetBuf replaces the internal buffer with the slice,
+// ready for unmarshaling the contents of the slice.
+func (p *Buffer) SetBuf(s []byte) {
+	p.buf = s
+	p.index = 0
+}
+
+// Bytes returns the contents of the Buffer.
+func (p *Buffer) Bytes() []byte { return p.buf }
+
+/*
+ * Helper routines for simplifying the creation of optional fields of basic type.
+ */
+
+// Bool is a helper routine that allocates a new bool value
+// to store v and returns a pointer to it.
+func Bool(v bool) *bool {
+	return &v
+}
+
+// Int32 is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it.
+func Int32(v int32) *int32 {
+	return &v
+}
+
+// Int is a helper routine that allocates a new int32 value
+// to store v and returns a pointer to it, but unlike Int32
+// its argument value is an int.
+func Int(v int) *int32 {
+	p := new(int32)
+	*p = int32(v)
+	return p
+}
+
+// Int64 is a helper routine that allocates a new int64 value
+// to store v and returns a pointer to it.
+func Int64(v int64) *int64 {
+	return &v
+}
+
+// Float32 is a helper routine that allocates a new float32 value
+// to store v and returns a pointer to it.
+func Float32(v float32) *float32 {
+	return &v
+}
+
+// Float64 is a helper routine that allocates a new float64 value
+// to store v and returns a pointer to it.
+func Float64(v float64) *float64 {
+	return &v
+}
+
+// Uint32 is a helper routine that allocates a new uint32 value
+// to store v and returns a pointer to it.
+func Uint32(v uint32) *uint32 {
+	return &v
+}
+
+// Uint64 is a helper routine that allocates a new uint64 value
+// to store v and returns a pointer to it.
+func Uint64(v uint64) *uint64 {
+	return &v
+}
+
+// String is a helper routine that allocates a new string value
+// to store v and returns a pointer to it.
+func String(v string) *string {
+	return &v
+}
+
+// EnumName is a helper function to simplify printing protocol buffer enums
+// by name.  Given an enum map and a value, it returns a useful string.
+func EnumName(m map[int32]string, v int32) string {
+	s, ok := m[v]
+	if ok {
+		return s
+	}
+	return strconv.Itoa(int(v))
+}
+
+// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
+// from their JSON-encoded representation. Given a map from the enum's symbolic
+// names to its int values, and a byte buffer containing the JSON-encoded
+// value, it returns an int32 that can be cast to the enum type by the caller.
+//
+// The function can deal with both JSON representations, numeric and symbolic.
+func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
+	if data[0] == '"' {
+		// New style: enums are strings.
+		var repr string
+		if err := json.Unmarshal(data, &repr); err != nil {
+			return -1, err
+		}
+		val, ok := m[repr]
+		if !ok {
+			return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
+		}
+		return val, nil
+	}
+	// Old style: enums are ints.
+	var val int32
+	if err := json.Unmarshal(data, &val); err != nil {
+		return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
+	}
+	return val, nil
+}
+
+// DebugPrint dumps the encoded data in b in a debugging format with a header
+// including the string s. Used in testing but made available for general debugging.
+func (p *Buffer) DebugPrint(s string, b []byte) {
+	var u uint64
+
+	obuf := p.buf
+	sindex := p.index
+	p.buf = b
+	p.index = 0
+	depth := 0
+
+	fmt.Printf("\n--- %s ---\n", s)
+
+out:
+	for {
+		for i := 0; i < depth; i++ {
+			fmt.Print("  ")
+		}
+
+		index := p.index
+		if index == len(p.buf) {
+			break
+		}
+
+		op, err := p.DecodeVarint()
+		if err != nil {
+			fmt.Printf("%3d: fetching op err %v\n", index, err)
+			break out
+		}
+		tag := op >> 3
+		wire := op & 7
+
+		switch wire {
+		default:
+			fmt.Printf("%3d: t=%3d unknown wire=%d\n",
+				index, tag, wire)
+			break out
+
+		case WireBytes:
+			var r []byte
+
+			r, err = p.DecodeRawBytes(false)
+			if err != nil {
+				break out
+			}
+			fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
+			if len(r) <= 6 {
+				for i := 0; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			} else {
+				for i := 0; i < 3; i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+				fmt.Printf(" ..")
+				for i := len(r) - 3; i < len(r); i++ {
+					fmt.Printf(" %.2x", r[i])
+				}
+			}
+			fmt.Printf("\n")
+
+		case WireFixed32:
+			u, err = p.DecodeFixed32()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
+
+		case WireFixed64:
+			u, err = p.DecodeFixed64()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
+
+		case WireVarint:
+			u, err = p.DecodeVarint()
+			if err != nil {
+				fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
+				break out
+			}
+			fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
+
+		case WireStartGroup:
+			fmt.Printf("%3d: t=%3d start\n", index, tag)
+			depth++
+
+		case WireEndGroup:
+			depth--
+			fmt.Printf("%3d: t=%3d end\n", index, tag)
+		}
+	}
+
+	if depth != 0 {
+		fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
+	}
+	fmt.Printf("\n")
+
+	p.buf = obuf
+	p.index = sindex
+}
+
+// SetDefaults sets unset protocol buffer fields to their default values.
+// It only modifies fields that are both unset and have defined defaults.
+// It recursively sets default values in any non-nil sub-messages.
+func SetDefaults(pb Message) {
+	setDefaults(reflect.ValueOf(pb), true, false)
+}
+
+// v is a pointer to a struct.
+func setDefaults(v reflect.Value, recur, zeros bool) {
+	v = v.Elem()
+
+	defaultMu.RLock()
+	dm, ok := defaults[v.Type()]
+	defaultMu.RUnlock()
+	if !ok {
+		dm = buildDefaultMessage(v.Type())
+		defaultMu.Lock()
+		defaults[v.Type()] = dm
+		defaultMu.Unlock()
+	}
+
+	for _, sf := range dm.scalars {
+		f := v.Field(sf.index)
+		if !f.IsNil() {
+			// field already set
+			continue
+		}
+		dv := sf.value
+		if dv == nil && !zeros {
+			// no explicit default, and don't want to set zeros
+			continue
+		}
+		fptr := f.Addr().Interface() // **T
+		// TODO: Consider batching the allocations we do here.
+		switch sf.kind {
+		case reflect.Bool:
+			b := new(bool)
+			if dv != nil {
+				*b = dv.(bool)
+			}
+			*(fptr.(**bool)) = b
+		case reflect.Float32:
+			f := new(float32)
+			if dv != nil {
+				*f = dv.(float32)
+			}
+			*(fptr.(**float32)) = f
+		case reflect.Float64:
+			f := new(float64)
+			if dv != nil {
+				*f = dv.(float64)
+			}
+			*(fptr.(**float64)) = f
+		case reflect.Int32:
+			// might be an enum
+			if ft := f.Type(); ft != int32PtrType {
+				// enum
+				f.Set(reflect.New(ft.Elem()))
+				if dv != nil {
+					f.Elem().SetInt(int64(dv.(int32)))
+				}
+			} else {
+				// int32 field
+				i := new(int32)
+				if dv != nil {
+					*i = dv.(int32)
+				}
+				*(fptr.(**int32)) = i
+			}
+		case reflect.Int64:
+			i := new(int64)
+			if dv != nil {
+				*i = dv.(int64)
+			}
+			*(fptr.(**int64)) = i
+		case reflect.String:
+			s := new(string)
+			if dv != nil {
+				*s = dv.(string)
+			}
+			*(fptr.(**string)) = s
+		case reflect.Uint8:
+			// exceptional case: []byte
+			var b []byte
+			if dv != nil {
+				db := dv.([]byte)
+				b = make([]byte, len(db))
+				copy(b, db)
+			} else {
+				b = []byte{}
+			}
+			*(fptr.(*[]byte)) = b
+		case reflect.Uint32:
+			u := new(uint32)
+			if dv != nil {
+				*u = dv.(uint32)
+			}
+			*(fptr.(**uint32)) = u
+		case reflect.Uint64:
+			u := new(uint64)
+			if dv != nil {
+				*u = dv.(uint64)
+			}
+			*(fptr.(**uint64)) = u
+		default:
+			log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
+		}
+	}
+
+	for _, ni := range dm.nested {
+		f := v.Field(ni)
+		// f is *T or []*T or map[T]*T
+		switch f.Kind() {
+		case reflect.Ptr:
+			if f.IsNil() {
+				continue
+			}
+			setDefaults(f, recur, zeros)
+
+		case reflect.Slice:
+			for i := 0; i < f.Len(); i++ {
+				e := f.Index(i)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+
+		case reflect.Map:
+			for _, k := range f.MapKeys() {
+				e := f.MapIndex(k)
+				if e.IsNil() {
+					continue
+				}
+				setDefaults(e, recur, zeros)
+			}
+		}
+	}
+}
+
+var (
+	// defaults maps a protocol buffer struct type to a slice of the fields,
+	// with its scalar fields set to their proto-declared non-zero default values.
+	defaultMu sync.RWMutex
+	defaults  = make(map[reflect.Type]defaultMessage)
+
+	int32PtrType = reflect.TypeOf((*int32)(nil))
+)
+
+// defaultMessage represents information about the default values of a message.
+type defaultMessage struct {
+	scalars []scalarField
+	nested  []int // struct field index of nested messages
+}
+
+type scalarField struct {
+	index int          // struct field index
+	kind  reflect.Kind // element type (the T in *T or []T)
+	value interface{}  // the proto-declared default value, or nil
+}
+
+// t is a struct type.
+func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
+	sprop := GetProperties(t)
+	for _, prop := range sprop.Prop {
+		fi, ok := sprop.decoderTags.get(prop.Tag)
+		if !ok {
+			// XXX_unrecognized
+			continue
+		}
+		ft := t.Field(fi).Type
+
+		sf, nested, err := fieldDefault(ft, prop)
+		switch {
+		case err != nil:
+			log.Print(err)
+		case nested:
+			dm.nested = append(dm.nested, fi)
+		case sf != nil:
+			sf.index = fi
+			dm.scalars = append(dm.scalars, *sf)
+		}
+	}
+
+	return dm
+}
+
+// fieldDefault returns the scalarField for field type ft.
+// sf will be nil if the field can not have a default.
+// nestedMessage will be true if this is a nested message.
+// Note that sf.index is not set on return.
+func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
+	var canHaveDefault bool
+	switch ft.Kind() {
+	case reflect.Ptr:
+		if ft.Elem().Kind() == reflect.Struct {
+			nestedMessage = true
+		} else {
+			canHaveDefault = true // proto2 scalar field
+		}
+
+	case reflect.Slice:
+		switch ft.Elem().Kind() {
+		case reflect.Ptr:
+			nestedMessage = true // repeated message
+		case reflect.Uint8:
+			canHaveDefault = true // bytes field
+		}
+
+	case reflect.Map:
+		if ft.Elem().Kind() == reflect.Ptr {
+			nestedMessage = true // map with message values
+		}
+	}
+
+	if !canHaveDefault {
+		if nestedMessage {
+			return nil, true, nil
+		}
+		return nil, false, nil
+	}
+
+	// We now know that ft is a pointer or slice.
+	sf = &scalarField{kind: ft.Elem().Kind()}
+
+	// scalar fields without defaults
+	if !prop.HasDefault {
+		return sf, false, nil
+	}
+
+	// a scalar field: either *T or []byte
+	switch ft.Elem().Kind() {
+	case reflect.Bool:
+		x, err := strconv.ParseBool(prop.Default)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.Float32:
+		x, err := strconv.ParseFloat(prop.Default, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
+		}
+		sf.value = float32(x)
+	case reflect.Float64:
+		x, err := strconv.ParseFloat(prop.Default, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.Int32:
+		x, err := strconv.ParseInt(prop.Default, 10, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
+		}
+		sf.value = int32(x)
+	case reflect.Int64:
+		x, err := strconv.ParseInt(prop.Default, 10, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	case reflect.String:
+		sf.value = prop.Default
+	case reflect.Uint8:
+		// []byte (not *uint8)
+		sf.value = []byte(prop.Default)
+	case reflect.Uint32:
+		x, err := strconv.ParseUint(prop.Default, 10, 32)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
+		}
+		sf.value = uint32(x)
+	case reflect.Uint64:
+		x, err := strconv.ParseUint(prop.Default, 10, 64)
+		if err != nil {
+			return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
+		}
+		sf.value = x
+	default:
+		return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
+	}
+
+	return sf, false, nil
+}
+
+// Map fields may have key types of non-float scalars, strings and enums.
+// The easiest way to sort them in some deterministic order is to use fmt.
+// If this turns out to be inefficient we can always consider other options,
+// such as doing a Schwartzian transform.
+
+func mapKeys(vs []reflect.Value) sort.Interface {
+	s := mapKeySorter{
+		vs: vs,
+		// default Less function: textual comparison
+		less: func(a, b reflect.Value) bool {
+			return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())
+		},
+	}
+
+	// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps;
+	// numeric keys are sorted numerically.
+	if len(vs) == 0 {
+		return s
+	}
+	switch vs[0].Kind() {
+	case reflect.Int32, reflect.Int64:
+		s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+	case reflect.Uint32, reflect.Uint64:
+		s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+	}
+
+	return s
+}
+
+type mapKeySorter struct {
+	vs   []reflect.Value
+	less func(a, b reflect.Value) bool
+}
+
+func (s mapKeySorter) Len() int      { return len(s.vs) }
+func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
+func (s mapKeySorter) Less(i, j int) bool {
+	return s.less(s.vs[i], s.vs[j])
+}
+
+// isProto3Zero reports whether v is a zero proto3 value.
+func isProto3Zero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint32, reflect.Uint64:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.String:
+		return v.String() == ""
+	}
+	return false
+}
+
+// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion2 = true
+
+// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
+// to assert that that code is compatible with this version of the proto package.
+const GoGoProtoPackageIsVersion1 = true
diff --git a/vendor/github.com/gogo/protobuf/proto/lib_gogo.go b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
new file mode 100644
index 000000000..4b4f7c909
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/lib_gogo.go
@@ -0,0 +1,42 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) {
+	s, ok := m[value]
+	if !ok {
+		s = strconv.Itoa(int(value))
+	}
+	return json.Marshal(s)
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/message_set.go b/vendor/github.com/gogo/protobuf/proto/message_set.go
new file mode 100644
index 000000000..fd982decd
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/message_set.go
@@ -0,0 +1,311 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Support for message sets.
+ */
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
+// A message type ID is required for storing a protocol buffer in a message set.
+var errNoMessageTypeID = errors.New("proto does not have a message type ID")
+
+// The first two types (_MessageSet_Item and messageSet)
+// model what the protocol compiler produces for the following protocol message:
+//   message MessageSet {
+//     repeated group Item = 1 {
+//       required int32 type_id = 2;
+//       required string message = 3;
+//     };
+//   }
+// That is the MessageSet wire format. We can't use a proto to generate these
+// because that would introduce a circular dependency between it and this package.
+
+type _MessageSet_Item struct {
+	TypeId  *int32 `protobuf:"varint,2,req,name=type_id"`
+	Message []byte `protobuf:"bytes,3,req,name=message"`
+}
+
+type messageSet struct {
+	Item             []*_MessageSet_Item `protobuf:"group,1,rep"`
+	XXX_unrecognized []byte
+	// TODO: caching?
+}
+
+// Make sure messageSet is a Message.
+var _ Message = (*messageSet)(nil)
+
+// messageTypeIder is an interface satisfied by a protocol buffer type
+// that may be stored in a MessageSet.
+type messageTypeIder interface {
+	MessageTypeId() int32
+}
+
+func (ms *messageSet) find(pb Message) *_MessageSet_Item {
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return nil
+	}
+	id := mti.MessageTypeId()
+	for _, item := range ms.Item {
+		if *item.TypeId == id {
+			return item
+		}
+	}
+	return nil
+}
+
+func (ms *messageSet) Has(pb Message) bool {
+	if ms.find(pb) != nil {
+		return true
+	}
+	return false
+}
+
+func (ms *messageSet) Unmarshal(pb Message) error {
+	if item := ms.find(pb); item != nil {
+		return Unmarshal(item.Message, pb)
+	}
+	if _, ok := pb.(messageTypeIder); !ok {
+		return errNoMessageTypeID
+	}
+	return nil // TODO: return error instead?
+}
+
+func (ms *messageSet) Marshal(pb Message) error {
+	msg, err := Marshal(pb)
+	if err != nil {
+		return err
+	}
+	if item := ms.find(pb); item != nil {
+		// reuse existing item
+		item.Message = msg
+		return nil
+	}
+
+	mti, ok := pb.(messageTypeIder)
+	if !ok {
+		return errNoMessageTypeID
+	}
+
+	mtid := mti.MessageTypeId()
+	ms.Item = append(ms.Item, &_MessageSet_Item{
+		TypeId:  &mtid,
+		Message: msg,
+	})
+	return nil
+}
+
+func (ms *messageSet) Reset()         { *ms = messageSet{} }
+func (ms *messageSet) String() string { return CompactTextString(ms) }
+func (*messageSet) ProtoMessage()     {}
+
+// Support for the message_set_wire_format message option.
+
+func skipVarint(buf []byte) []byte {
+	i := 0
+	for ; buf[i]&0x80 != 0; i++ {
+	}
+	return buf[i+1:]
+}
+
+// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
+// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSet(exts interface{}) ([]byte, error) {
+	var m map[int32]Extension
+	switch exts := exts.(type) {
+	case *XXX_InternalExtensions:
+		if err := encodeExtensions(exts); err != nil {
+			return nil, err
+		}
+		m, _ = exts.extensionsRead()
+	case map[int32]Extension:
+		if err := encodeExtensionsMap(exts); err != nil {
+			return nil, err
+		}
+		m = exts
+	default:
+		return nil, errors.New("proto: not an extension map")
+	}
+
+	// Sort extension IDs to provide a deterministic encoding.
+	// See also enc_map in encode.go.
+	ids := make([]int, 0, len(m))
+	for id := range m {
+		ids = append(ids, int(id))
+	}
+	sort.Ints(ids)
+
+	ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))}
+	for _, id := range ids {
+		e := m[int32(id)]
+		// Remove the wire type and field number varint, as well as the length varint.
+		msg := skipVarint(skipVarint(e.enc))
+
+		ms.Item = append(ms.Item, &_MessageSet_Item{
+			TypeId:  Int32(int32(id)),
+			Message: msg,
+		})
+	}
+	return Marshal(ms)
+}
+
+// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
+// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSet(buf []byte, exts interface{}) error {
+	var m map[int32]Extension
+	switch exts := exts.(type) {
+	case *XXX_InternalExtensions:
+		m = exts.extensionsWrite()
+	case map[int32]Extension:
+		m = exts
+	default:
+		return errors.New("proto: not an extension map")
+	}
+
+	ms := new(messageSet)
+	if err := Unmarshal(buf, ms); err != nil {
+		return err
+	}
+	for _, item := range ms.Item {
+		id := *item.TypeId
+		msg := item.Message
+
+		// Restore wire type and field number varint, plus length varint.
+		// Be careful to preserve duplicate items.
+		b := EncodeVarint(uint64(id)<<3 | WireBytes)
+		if ext, ok := m[id]; ok {
+			// Existing data; rip off the tag and length varint
+			// so we join the new data correctly.
+			// We can assume that ext.enc is set because we are unmarshaling.
+			o := ext.enc[len(b):]   // skip wire type and field number
+			_, n := DecodeVarint(o) // calculate length of length varint
+			o = o[n:]               // skip length varint
+			msg = append(o, msg...) // join old data and new data
+		}
+		b = append(b, EncodeVarint(uint64(len(msg)))...)
+		b = append(b, msg...)
+
+		m[id] = Extension{enc: b}
+	}
+	return nil
+}
+
+// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
+// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
+	var m map[int32]Extension
+	switch exts := exts.(type) {
+	case *XXX_InternalExtensions:
+		m, _ = exts.extensionsRead()
+	case map[int32]Extension:
+		m = exts
+	default:
+		return nil, errors.New("proto: not an extension map")
+	}
+	var b bytes.Buffer
+	b.WriteByte('{')
+
+	// Process the map in key order for deterministic output.
+	ids := make([]int32, 0, len(m))
+	for id := range m {
+		ids = append(ids, id)
+	}
+	sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
+
+	for i, id := range ids {
+		ext := m[id]
+		if i > 0 {
+			b.WriteByte(',')
+		}
+
+		msd, ok := messageSetMap[id]
+		if !ok {
+			// Unknown type; we can't render it, so skip it.
+			continue
+		}
+		fmt.Fprintf(&b, `"[%s]":`, msd.name)
+
+		x := ext.value
+		if x == nil {
+			x = reflect.New(msd.t.Elem()).Interface()
+			if err := Unmarshal(ext.enc, x.(Message)); err != nil {
+				return nil, err
+			}
+		}
+		d, err := json.Marshal(x)
+		if err != nil {
+			return nil, err
+		}
+		b.Write(d)
+	}
+	b.WriteByte('}')
+	return b.Bytes(), nil
+}
+
+// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
+// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
+func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
+	// Common-case fast path.
+	if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
+		return nil
+	}
+
+	// This is fairly tricky, and it's not clear that it is needed.
+	return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
+}
+
+// A global registry of types that can be used in a MessageSet.
+
+var messageSetMap = make(map[int32]messageSetDesc)
+
+type messageSetDesc struct {
+	t    reflect.Type // pointer to struct
+	name string
+}
+
+// RegisterMessageSetType is called from the generated code.
+func RegisterMessageSetType(m Message, fieldNum int32, name string) {
+	messageSetMap[fieldNum] = messageSetDesc{
+		t:    reflect.TypeOf(m),
+		name: name,
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
new file mode 100644
index 000000000..fb512e2e1
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect.go
@@ -0,0 +1,484 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build appengine js
+
+// This file contains an implementation of proto field accesses using package reflect.
+// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
+// be used on App Engine.
+
+package proto
+
+import (
+	"math"
+	"reflect"
+)
+
+// A structPointer is a pointer to a struct.
+type structPointer struct {
+	v reflect.Value
+}
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+// The reflect value must itself be a pointer to a struct.
+func toStructPointer(v reflect.Value) structPointer {
+	return structPointer{v}
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+	return p.v.IsNil()
+}
+
+// Interface returns the struct pointer as an interface value.
+func structPointer_Interface(p structPointer, _ reflect.Type) interface{} {
+	return p.v.Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by the sequence of field indices
+// passed to reflect's FieldByIndex.
+type field []int
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return f.Index
+}
+
+// invalidField is an invalid field identifier.
+var invalidField = field(nil)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool { return f != nil }
+
+// field returns the given field in the struct as a reflect value.
+func structPointer_field(p structPointer, f field) reflect.Value {
+	// Special case: an extension map entry with a value of type T
+	// passes a *T to the struct-handling code with a zero field,
+	// expecting that it will be treated as equivalent to *struct{ X T },
+	// which has the same memory layout. We have to handle that case
+	// specially, because reflect will panic if we call FieldByIndex on a
+	// non-struct.
+	if f == nil {
+		return p.v.Elem()
+	}
+
+	return p.v.Elem().FieldByIndex(f)
+}
+
+// ifield returns the given field in the struct as an interface value.
+func structPointer_ifield(p structPointer, f field) interface{} {
+	return structPointer_field(p, f).Addr().Interface()
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+	return structPointer_ifield(p, f).(*[]byte)
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+	return structPointer_ifield(p, f).(*[][]byte)
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+	return structPointer_ifield(p, f).(**bool)
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+	return structPointer_ifield(p, f).(*bool)
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+	return structPointer_ifield(p, f).(*[]bool)
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+	return structPointer_ifield(p, f).(**string)
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+	return structPointer_ifield(p, f).(*string)
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+	return structPointer_ifield(p, f).(*[]string)
+}
+
+// Extensions returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+	return structPointer_ifield(p, f).(*XXX_InternalExtensions)
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+	return structPointer_ifield(p, f).(*map[int32]Extension)
+}
+
+// NewAt returns the reflect.Value for a pointer to a field in the struct.
+func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
+	return structPointer_field(p, f).Addr()
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+	structPointer_field(p, f).Set(q.v)
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+	return structPointer{structPointer_field(p, f)}
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice {
+	return structPointerSlice{structPointer_field(p, f)}
+}
+
+// A structPointerSlice represents the address of a slice of pointers to structs
+// (themselves messages or groups). That is, v.Type() is *[]*struct{...}.
+type structPointerSlice struct {
+	v reflect.Value
+}
+
+func (p structPointerSlice) Len() int                  { return p.v.Len() }
+func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} }
+func (p structPointerSlice) Append(q structPointer) {
+	p.v.Set(reflect.Append(p.v, q.v))
+}
+
+var (
+	int32Type   = reflect.TypeOf(int32(0))
+	uint32Type  = reflect.TypeOf(uint32(0))
+	float32Type = reflect.TypeOf(float32(0))
+	int64Type   = reflect.TypeOf(int64(0))
+	uint64Type  = reflect.TypeOf(uint64(0))
+	float64Type = reflect.TypeOf(float64(0))
+)
+
+// A word32 represents a field of type *int32, *uint32, *float32, or *enum.
+// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable.
+type word32 struct {
+	v reflect.Value
+}
+
+// IsNil reports whether p is nil.
+func word32_IsNil(p word32) bool {
+	return p.v.IsNil()
+}
+
+// Set sets p to point at a newly allocated word with bits set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+	t := p.v.Type().Elem()
+	switch t {
+	case int32Type:
+		if len(o.int32s) == 0 {
+			o.int32s = make([]int32, uint32PoolSize)
+		}
+		o.int32s[0] = int32(x)
+		p.v.Set(reflect.ValueOf(&o.int32s[0]))
+		o.int32s = o.int32s[1:]
+		return
+	case uint32Type:
+		if len(o.uint32s) == 0 {
+			o.uint32s = make([]uint32, uint32PoolSize)
+		}
+		o.uint32s[0] = x
+		p.v.Set(reflect.ValueOf(&o.uint32s[0]))
+		o.uint32s = o.uint32s[1:]
+		return
+	case float32Type:
+		if len(o.float32s) == 0 {
+			o.float32s = make([]float32, uint32PoolSize)
+		}
+		o.float32s[0] = math.Float32frombits(x)
+		p.v.Set(reflect.ValueOf(&o.float32s[0]))
+		o.float32s = o.float32s[1:]
+		return
+	}
+
+	// must be enum
+	p.v.Set(reflect.New(t))
+	p.v.Elem().SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32_Get(p word32) uint32 {
+	elem := p.v.Elem()
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+	return word32{structPointer_field(p, f)}
+}
+
+// A word32Val represents a field of type int32, uint32, float32, or enum.
+// That is, v.Type() is int32, uint32, float32, or enum and v is assignable.
+type word32Val struct {
+	v reflect.Value
+}
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+	switch p.v.Type() {
+	case int32Type:
+		p.v.SetInt(int64(x))
+		return
+	case uint32Type:
+		p.v.SetUint(uint64(x))
+		return
+	case float32Type:
+		p.v.SetFloat(float64(math.Float32frombits(x)))
+		return
+	}
+
+	// must be enum
+	p.v.SetInt(int64(int32(x)))
+}
+
+// Get gets the bits pointed at by p, as a uint32.
+func word32Val_Get(p word32Val) uint32 {
+	elem := p.v
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+	return word32Val{structPointer_field(p, f)}
+}
+
+// A word32Slice is a slice of 32-bit values.
+// That is, v.Type() is []int32, []uint32, []float32, or []enum.
+type word32Slice struct {
+	v reflect.Value
+}
+
+func (p word32Slice) Append(x uint32) {
+	n, m := p.v.Len(), p.v.Cap()
+	if n < m {
+		p.v.SetLen(n + 1)
+	} else {
+		t := p.v.Type().Elem()
+		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+	}
+	elem := p.v.Index(n)
+	switch elem.Kind() {
+	case reflect.Int32:
+		elem.SetInt(int64(int32(x)))
+	case reflect.Uint32:
+		elem.SetUint(uint64(x))
+	case reflect.Float32:
+		elem.SetFloat(float64(math.Float32frombits(x)))
+	}
+}
+
+func (p word32Slice) Len() int {
+	return p.v.Len()
+}
+
+func (p word32Slice) Index(i int) uint32 {
+	elem := p.v.Index(i)
+	switch elem.Kind() {
+	case reflect.Int32:
+		return uint32(elem.Int())
+	case reflect.Uint32:
+		return uint32(elem.Uint())
+	case reflect.Float32:
+		return math.Float32bits(float32(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) word32Slice {
+	return word32Slice{structPointer_field(p, f)}
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 struct {
+	v reflect.Value
+}
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+	t := p.v.Type().Elem()
+	switch t {
+	case int64Type:
+		if len(o.int64s) == 0 {
+			o.int64s = make([]int64, uint64PoolSize)
+		}
+		o.int64s[0] = int64(x)
+		p.v.Set(reflect.ValueOf(&o.int64s[0]))
+		o.int64s = o.int64s[1:]
+		return
+	case uint64Type:
+		if len(o.uint64s) == 0 {
+			o.uint64s = make([]uint64, uint64PoolSize)
+		}
+		o.uint64s[0] = x
+		p.v.Set(reflect.ValueOf(&o.uint64s[0]))
+		o.uint64s = o.uint64s[1:]
+		return
+	case float64Type:
+		if len(o.float64s) == 0 {
+			o.float64s = make([]float64, uint64PoolSize)
+		}
+		o.float64s[0] = math.Float64frombits(x)
+		p.v.Set(reflect.ValueOf(&o.float64s[0]))
+		o.float64s = o.float64s[1:]
+		return
+	}
+	panic("unreachable")
+}
+
+func word64_IsNil(p word64) bool {
+	return p.v.IsNil()
+}
+
+func word64_Get(p word64) uint64 {
+	elem := p.v.Elem()
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return elem.Uint()
+	case reflect.Float64:
+		return math.Float64bits(elem.Float())
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+	return word64{structPointer_field(p, f)}
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val struct {
+	v reflect.Value
+}
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+	switch p.v.Type() {
+	case int64Type:
+		p.v.SetInt(int64(x))
+		return
+	case uint64Type:
+		p.v.SetUint(x)
+		return
+	case float64Type:
+		p.v.SetFloat(math.Float64frombits(x))
+		return
+	}
+	panic("unreachable")
+}
+
+func word64Val_Get(p word64Val) uint64 {
+	elem := p.v
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return elem.Uint()
+	case reflect.Float64:
+		return math.Float64bits(elem.Float())
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+	return word64Val{structPointer_field(p, f)}
+}
+
+type word64Slice struct {
+	v reflect.Value
+}
+
+func (p word64Slice) Append(x uint64) {
+	n, m := p.v.Len(), p.v.Cap()
+	if n < m {
+		p.v.SetLen(n + 1)
+	} else {
+		t := p.v.Type().Elem()
+		p.v.Set(reflect.Append(p.v, reflect.Zero(t)))
+	}
+	elem := p.v.Index(n)
+	switch elem.Kind() {
+	case reflect.Int64:
+		elem.SetInt(int64(int64(x)))
+	case reflect.Uint64:
+		elem.SetUint(uint64(x))
+	case reflect.Float64:
+		elem.SetFloat(float64(math.Float64frombits(x)))
+	}
+}
+
+func (p word64Slice) Len() int {
+	return p.v.Len()
+}
+
+func (p word64Slice) Index(i int) uint64 {
+	elem := p.v.Index(i)
+	switch elem.Kind() {
+	case reflect.Int64:
+		return uint64(elem.Int())
+	case reflect.Uint64:
+		return uint64(elem.Uint())
+	case reflect.Float64:
+		return math.Float64bits(float64(elem.Float()))
+	}
+	panic("unreachable")
+}
+
+func structPointer_Word64Slice(p structPointer, f field) word64Slice {
+	return word64Slice{structPointer_field(p, f)}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go
new file mode 100644
index 000000000..1763a5f22
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_reflect_gogo.go
@@ -0,0 +1,85 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2016, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build appengine js
+
+package proto
+
+import (
+	"reflect"
+)
+
+func structPointer_FieldPointer(p structPointer, f field) structPointer {
+	panic("not implemented")
+}
+
+func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer {
+	panic("not implemented")
+}
+
+func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} {
+	panic("not implemented")
+}
+
+func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} {
+	panic("not implemented")
+}
+
+func structPointer_GetRefStructPointer(p structPointer, f field) structPointer {
+	panic("not implemented")
+}
+
+func structPointer_Add(p structPointer, size field) structPointer {
+	panic("not implemented")
+}
+
+func structPointer_Len(p structPointer, f field) int {
+	panic("not implemented")
+}
+
+func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader {
+	panic("not implemented")
+}
+
+func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) {
+	panic("not implemented")
+}
+
+func structPointer_StructRefSlice(p structPointer, f field, size uintptr) *structRefSlice {
+	panic("not implemented")
+}
+
+type structRefSlice struct{}
+
+func (v *structRefSlice) Len() int {
+	panic("not implemented")
+}
+
+func (v *structRefSlice) Index(i int) structPointer {
+	panic("not implemented")
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
new file mode 100644
index 000000000..6b5567d47
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe.go
@@ -0,0 +1,270 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2012 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// NOTE: These type_Foo functions would more idiomatically be methods,
+// but Go does not allow methods on pointer types, and we must preserve
+// some pointer type for the garbage collector. We use these
+// funcs with clunky names as our poor approximation to methods.
+//
+// An alternative would be
+//	type structPointer struct { p unsafe.Pointer }
+// but that does not registerize as well.
+
+// A structPointer is a pointer to a struct.
+type structPointer unsafe.Pointer
+
+// toStructPointer returns a structPointer equivalent to the given reflect value.
+func toStructPointer(v reflect.Value) structPointer {
+	return structPointer(unsafe.Pointer(v.Pointer()))
+}
+
+// IsNil reports whether p is nil.
+func structPointer_IsNil(p structPointer) bool {
+	return p == nil
+}
+
+// Interface returns the struct pointer, assumed to have element type t,
+// as an interface value.
+func structPointer_Interface(p structPointer, t reflect.Type) interface{} {
+	return reflect.NewAt(t, unsafe.Pointer(p)).Interface()
+}
+
+// A field identifies a field in a struct, accessible from a structPointer.
+// In this implementation, a field is identified by its byte offset from the start of the struct.
+type field uintptr
+
+// toField returns a field equivalent to the given reflect field.
+func toField(f *reflect.StructField) field {
+	return field(f.Offset)
+}
+
+// invalidField is an invalid field identifier.
+const invalidField = ^field(0)
+
+// IsValid reports whether the field identifier is valid.
+func (f field) IsValid() bool {
+	return f != ^field(0)
+}
+
+// Bytes returns the address of a []byte field in the struct.
+func structPointer_Bytes(p structPointer, f field) *[]byte {
+	return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BytesSlice returns the address of a [][]byte field in the struct.
+func structPointer_BytesSlice(p structPointer, f field) *[][]byte {
+	return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// Bool returns the address of a *bool field in the struct.
+func structPointer_Bool(p structPointer, f field) **bool {
+	return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolVal returns the address of a bool field in the struct.
+func structPointer_BoolVal(p structPointer, f field) *bool {
+	return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// BoolSlice returns the address of a []bool field in the struct.
+func structPointer_BoolSlice(p structPointer, f field) *[]bool {
+	return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// String returns the address of a *string field in the struct.
+func structPointer_String(p structPointer, f field) **string {
+	return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringVal returns the address of a string field in the struct.
+func structPointer_StringVal(p structPointer, f field) *string {
+	return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StringSlice returns the address of a []string field in the struct.
+func structPointer_StringSlice(p structPointer, f field) *[]string {
+	return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// ExtMap returns the address of an extension map field in the struct.
+func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {
+	return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {
+	return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// NewAt returns the reflect.Value for a pointer to a field in the struct.
+func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {
+	return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f)))
+}
+
+// SetStructPointer writes a *struct field in the struct.
+func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {
+	*(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q
+}
+
+// GetStructPointer reads a *struct field in the struct.
+func structPointer_GetStructPointer(p structPointer, f field) structPointer {
+	return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// StructPointerSlice the address of a []*struct field in the struct.
+func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice {
+	return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups).
+type structPointerSlice []structPointer
+
+func (v *structPointerSlice) Len() int                  { return len(*v) }
+func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] }
+func (v *structPointerSlice) Append(p structPointer)    { *v = append(*v, p) }
+
+// A word32 is the address of a "pointer to 32-bit value" field.
+type word32 **uint32
+
+// IsNil reports whether *v is nil.
+func word32_IsNil(p word32) bool {
+	return *p == nil
+}
+
+// Set sets *v to point at a newly allocated word set to x.
+func word32_Set(p word32, o *Buffer, x uint32) {
+	if len(o.uint32s) == 0 {
+		o.uint32s = make([]uint32, uint32PoolSize)
+	}
+	o.uint32s[0] = x
+	*p = &o.uint32s[0]
+	o.uint32s = o.uint32s[1:]
+}
+
+// Get gets the value pointed at by *v.
+func word32_Get(p word32) uint32 {
+	return **p
+}
+
+// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32(p structPointer, f field) word32 {
+	return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Val is the address of a 32-bit value field.
+type word32Val *uint32
+
+// Set sets *p to x.
+func word32Val_Set(p word32Val, x uint32) {
+	*p = x
+}
+
+// Get gets the value pointed at by p.
+func word32Val_Get(p word32Val) uint32 {
+	return *p
+}
+
+// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct.
+func structPointer_Word32Val(p structPointer, f field) word32Val {
+	return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// A word32Slice is a slice of 32-bit values.
+type word32Slice []uint32
+
+func (v *word32Slice) Append(x uint32)    { *v = append(*v, x) }
+func (v *word32Slice) Len() int           { return len(*v) }
+func (v *word32Slice) Index(i int) uint32 { return (*v)[i] }
+
+// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct.
+func structPointer_Word32Slice(p structPointer, f field) *word32Slice {
+	return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+// word64 is like word32 but for 64-bit values.
+type word64 **uint64
+
+func word64_Set(p word64, o *Buffer, x uint64) {
+	if len(o.uint64s) == 0 {
+		o.uint64s = make([]uint64, uint64PoolSize)
+	}
+	o.uint64s[0] = x
+	*p = &o.uint64s[0]
+	o.uint64s = o.uint64s[1:]
+}
+
+func word64_IsNil(p word64) bool {
+	return *p == nil
+}
+
+func word64_Get(p word64) uint64 {
+	return **p
+}
+
+func structPointer_Word64(p structPointer, f field) word64 {
+	return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Val is like word32Val but for 64-bit values.
+type word64Val *uint64
+
+func word64Val_Set(p word64Val, o *Buffer, x uint64) {
+	*p = x
+}
+
+func word64Val_Get(p word64Val) uint64 {
+	return *p
+}
+
+func structPointer_Word64Val(p structPointer, f field) word64Val {
+	return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+// word64Slice is like word32Slice but for 64-bit values.
+type word64Slice []uint64
+
+func (v *word64Slice) Append(x uint64)    { *v = append(*v, x) }
+func (v *word64Slice) Len() int           { return len(*v) }
+func (v *word64Slice) Index(i int) uint64 { return (*v)[i] }
+
+func structPointer_Word64Slice(p structPointer, f field) *word64Slice {
+	return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
new file mode 100644
index 000000000..f156a29f0
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/pointer_unsafe_gogo.go
@@ -0,0 +1,128 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// +build !appengine,!js
+
+// This file contains the implementation of the proto field accesses using package unsafe.
+
+package proto
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} {
+	point := unsafe.Pointer(uintptr(p) + uintptr(f))
+	r := reflect.NewAt(t, point)
+	return r.Interface()
+}
+
+func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} {
+	point := unsafe.Pointer(uintptr(p) + uintptr(f))
+	r := reflect.NewAt(t, point)
+	if r.Elem().IsNil() {
+		return nil
+	}
+	return r.Elem().Interface()
+}
+
+func copyUintPtr(oldptr, newptr uintptr, size int) {
+	oldbytes := make([]byte, 0)
+	oldslice := (*reflect.SliceHeader)(unsafe.Pointer(&oldbytes))
+	oldslice.Data = oldptr
+	oldslice.Len = size
+	oldslice.Cap = size
+	newbytes := make([]byte, 0)
+	newslice := (*reflect.SliceHeader)(unsafe.Pointer(&newbytes))
+	newslice.Data = newptr
+	newslice.Len = size
+	newslice.Cap = size
+	copy(newbytes, oldbytes)
+}
+
+func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) {
+	copyUintPtr(uintptr(oldptr), uintptr(newptr), size)
+}
+
+func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer {
+	size := typ.Elem().Size()
+
+	oldHeader := structPointer_GetSliceHeader(base, f)
+	oldSlice := reflect.NewAt(typ, unsafe.Pointer(oldHeader)).Elem()
+	newLen := oldHeader.Len + 1
+	newSlice := reflect.MakeSlice(typ, newLen, newLen)
+	reflect.Copy(newSlice, oldSlice)
+	bas := toStructPointer(newSlice)
+	oldHeader.Data = uintptr(bas)
+	oldHeader.Len = newLen
+	oldHeader.Cap = newLen
+
+	return structPointer(unsafe.Pointer(uintptr(unsafe.Pointer(bas)) + uintptr(uintptr(newLen-1)*size)))
+}
+
+func structPointer_FieldPointer(p structPointer, f field) structPointer {
+	return structPointer(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_GetRefStructPointer(p structPointer, f field) structPointer {
+	return structPointer((*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))))
+}
+
+func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader {
+	return (*reflect.SliceHeader)(unsafe.Pointer(uintptr(p) + uintptr(f)))
+}
+
+func structPointer_Add(p structPointer, size field) structPointer {
+	return structPointer(unsafe.Pointer(uintptr(p) + uintptr(size)))
+}
+
+func structPointer_Len(p structPointer, f field) int {
+	return len(*(*[]interface{})(unsafe.Pointer(structPointer_GetRefStructPointer(p, f))))
+}
+
+func structPointer_StructRefSlice(p structPointer, f field, size uintptr) *structRefSlice {
+	return &structRefSlice{p: p, f: f, size: size}
+}
+
+// A structRefSlice represents a slice of structs (themselves submessages or groups).
+type structRefSlice struct {
+	p    structPointer
+	f    field
+	size uintptr
+}
+
+func (v *structRefSlice) Len() int {
+	return structPointer_Len(v.p, v.f)
+}
+
+func (v *structRefSlice) Index(i int) structPointer {
+	ss := structPointer_GetStructPointer(v.p, v.f)
+	ss1 := structPointer_GetRefStructPointer(ss, 0)
+	return structPointer_Add(ss1, field(uintptr(i)*v.size))
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/properties.go b/vendor/github.com/gogo/protobuf/proto/properties.go
new file mode 100644
index 000000000..2a69e8862
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties.go
@@ -0,0 +1,971 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+/*
+ * Routines for encoding data into the wire format for protocol buffers.
+ */
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+const debug bool = false
+
+// Constants that identify the encoding of a value on the wire.
+const (
+	WireVarint     = 0
+	WireFixed64    = 1
+	WireBytes      = 2
+	WireStartGroup = 3
+	WireEndGroup   = 4
+	WireFixed32    = 5
+)
+
+const startSize = 10 // initial slice/string sizes
+
+// Encoders are defined in encode.go
+// An encoder outputs the full representation of a field, including its
+// tag and encoder type.
+type encoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueEncoder encodes a single integer in a particular encoding.
+type valueEncoder func(o *Buffer, x uint64) error
+
+// Sizers are defined in encode.go
+// A sizer returns the encoded size of a field, including its tag and encoder
+// type.
+type sizer func(prop *Properties, base structPointer) int
+
+// A valueSizer returns the encoded size of a single integer in a particular
+// encoding.
+type valueSizer func(x uint64) int
+
+// Decoders are defined in decode.go
+// A decoder creates a value from its wire representation.
+// Unrecognized subelements are saved in unrec.
+type decoder func(p *Buffer, prop *Properties, base structPointer) error
+
+// A valueDecoder decodes a single integer in a particular encoding.
+type valueDecoder func(o *Buffer) (x uint64, err error)
+
+// A oneofMarshaler does the marshaling for all oneof fields in a message.
+type oneofMarshaler func(Message, *Buffer) error
+
+// A oneofUnmarshaler does the unmarshaling for a oneof field in a message.
+type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error)
+
+// A oneofSizer does the sizing for all oneof fields in a message.
+type oneofSizer func(Message) int
+
+// tagMap is an optimization over map[int]int for typical protocol buffer
+// use-cases. Encoded protocol buffers are often in tag order with small tag
+// numbers.
+type tagMap struct {
+	fastTags []int
+	slowTags map[int]int
+}
+
+// tagMapFastLimit is the upper bound on the tag number that will be stored in
+// the tagMap slice rather than its map.
+const tagMapFastLimit = 1024
+
+func (p *tagMap) get(t int) (int, bool) {
+	if t > 0 && t < tagMapFastLimit {
+		if t >= len(p.fastTags) {
+			return 0, false
+		}
+		fi := p.fastTags[t]
+		return fi, fi >= 0
+	}
+	fi, ok := p.slowTags[t]
+	return fi, ok
+}
+
+func (p *tagMap) put(t int, fi int) {
+	if t > 0 && t < tagMapFastLimit {
+		for len(p.fastTags) < t+1 {
+			p.fastTags = append(p.fastTags, -1)
+		}
+		p.fastTags[t] = fi
+		return
+	}
+	if p.slowTags == nil {
+		p.slowTags = make(map[int]int)
+	}
+	p.slowTags[t] = fi
+}
+
+// StructProperties represents properties for all the fields of a struct.
+// decoderTags and decoderOrigNames should only be used by the decoder.
+type StructProperties struct {
+	Prop             []*Properties  // properties for each field
+	reqCount         int            // required count
+	decoderTags      tagMap         // map from proto tag to struct field number
+	decoderOrigNames map[string]int // map from original name to struct field number
+	order            []int          // list of struct field numbers in tag order
+	unrecField       field          // field id of the XXX_unrecognized []byte field
+	extendable       bool           // is this an extendable proto
+
+	oneofMarshaler   oneofMarshaler
+	oneofUnmarshaler oneofUnmarshaler
+	oneofSizer       oneofSizer
+	stype            reflect.Type
+
+	// OneofTypes contains information about the oneof fields in this message.
+	// It is keyed by the original name of a field.
+	OneofTypes map[string]*OneofProperties
+}
+
+// OneofProperties represents information about a specific field in a oneof.
+type OneofProperties struct {
+	Type  reflect.Type // pointer to generated struct type for this oneof field
+	Field int          // struct field number of the containing oneof in the message
+	Prop  *Properties
+}
+
+// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec.
+// See encode.go, (*Buffer).enc_struct.
+
+func (sp *StructProperties) Len() int { return len(sp.order) }
+func (sp *StructProperties) Less(i, j int) bool {
+	return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag
+}
+func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] }
+
+// Properties represents the protocol-specific behavior of a single struct field.
+type Properties struct {
+	Name     string // name of the field, for error messages
+	OrigName string // original name before protocol compiler (always set)
+	JSONName string // name to use for JSON; determined by protoc
+	Wire     string
+	WireType int
+	Tag      int
+	Required bool
+	Optional bool
+	Repeated bool
+	Packed   bool   // relevant for repeated primitives only
+	Enum     string // set for enum types only
+	proto3   bool   // whether this is known to be a proto3 field; set for []byte only
+	oneof    bool   // whether this is a oneof field
+
+	Default     string // default value
+	HasDefault  bool   // whether an explicit default was provided
+	CustomType  string
+	CastType    string
+	StdTime     bool
+	StdDuration bool
+
+	enc           encoder
+	valEnc        valueEncoder // set for bool and numeric types only
+	field         field
+	tagcode       []byte // encoding of EncodeVarint((Tag<<3)|WireType)
+	tagbuf        [8]byte
+	stype         reflect.Type      // set for struct types only
+	sstype        reflect.Type      // set for slices of structs types only
+	ctype         reflect.Type      // set for custom types only
+	sprop         *StructProperties // set for struct types only
+	isMarshaler   bool
+	isUnmarshaler bool
+
+	mtype    reflect.Type // set for map types only
+	mkeyprop *Properties  // set for map types only
+	mvalprop *Properties  // set for map types only
+
+	size    sizer
+	valSize valueSizer // set for bool and numeric types only
+
+	dec    decoder
+	valDec valueDecoder // set for bool and numeric types only
+
+	// If this is a packable field, this will be the decoder for the packed version of the field.
+	packedDec decoder
+}
+
+// String formats the properties in the protobuf struct field tag style.
+func (p *Properties) String() string {
+	s := p.Wire
+	s = ","
+	s += strconv.Itoa(p.Tag)
+	if p.Required {
+		s += ",req"
+	}
+	if p.Optional {
+		s += ",opt"
+	}
+	if p.Repeated {
+		s += ",rep"
+	}
+	if p.Packed {
+		s += ",packed"
+	}
+	s += ",name=" + p.OrigName
+	if p.JSONName != p.OrigName {
+		s += ",json=" + p.JSONName
+	}
+	if p.proto3 {
+		s += ",proto3"
+	}
+	if p.oneof {
+		s += ",oneof"
+	}
+	if len(p.Enum) > 0 {
+		s += ",enum=" + p.Enum
+	}
+	if p.HasDefault {
+		s += ",def=" + p.Default
+	}
+	return s
+}
+
+// Parse populates p by parsing a string in the protobuf struct field tag style.
+func (p *Properties) Parse(s string) {
+	// "bytes,49,opt,name=foo,def=hello!"
+	fields := strings.Split(s, ",") // breaks def=, but handled below.
+	if len(fields) < 2 {
+		fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s)
+		return
+	}
+
+	p.Wire = fields[0]
+	switch p.Wire {
+	case "varint":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeVarint
+		p.valDec = (*Buffer).DecodeVarint
+		p.valSize = sizeVarint
+	case "fixed32":
+		p.WireType = WireFixed32
+		p.valEnc = (*Buffer).EncodeFixed32
+		p.valDec = (*Buffer).DecodeFixed32
+		p.valSize = sizeFixed32
+	case "fixed64":
+		p.WireType = WireFixed64
+		p.valEnc = (*Buffer).EncodeFixed64
+		p.valDec = (*Buffer).DecodeFixed64
+		p.valSize = sizeFixed64
+	case "zigzag32":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeZigzag32
+		p.valDec = (*Buffer).DecodeZigzag32
+		p.valSize = sizeZigzag32
+	case "zigzag64":
+		p.WireType = WireVarint
+		p.valEnc = (*Buffer).EncodeZigzag64
+		p.valDec = (*Buffer).DecodeZigzag64
+		p.valSize = sizeZigzag64
+	case "bytes", "group":
+		p.WireType = WireBytes
+		// no numeric converter for non-numeric types
+	default:
+		fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s)
+		return
+	}
+
+	var err error
+	p.Tag, err = strconv.Atoi(fields[1])
+	if err != nil {
+		return
+	}
+
+	for i := 2; i < len(fields); i++ {
+		f := fields[i]
+		switch {
+		case f == "req":
+			p.Required = true
+		case f == "opt":
+			p.Optional = true
+		case f == "rep":
+			p.Repeated = true
+		case f == "packed":
+			p.Packed = true
+		case strings.HasPrefix(f, "name="):
+			p.OrigName = f[5:]
+		case strings.HasPrefix(f, "json="):
+			p.JSONName = f[5:]
+		case strings.HasPrefix(f, "enum="):
+			p.Enum = f[5:]
+		case f == "proto3":
+			p.proto3 = true
+		case f == "oneof":
+			p.oneof = true
+		case strings.HasPrefix(f, "def="):
+			p.HasDefault = true
+			p.Default = f[4:] // rest of string
+			if i+1 < len(fields) {
+				// Commas aren't escaped, and def is always last.
+				p.Default += "," + strings.Join(fields[i+1:], ",")
+				break
+			}
+		case strings.HasPrefix(f, "embedded="):
+			p.OrigName = strings.Split(f, "=")[1]
+		case strings.HasPrefix(f, "customtype="):
+			p.CustomType = strings.Split(f, "=")[1]
+		case strings.HasPrefix(f, "casttype="):
+			p.CastType = strings.Split(f, "=")[1]
+		case f == "stdtime":
+			p.StdTime = true
+		case f == "stdduration":
+			p.StdDuration = true
+		}
+	}
+}
+
+func logNoSliceEnc(t1, t2 reflect.Type) {
+	fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
+}
+
+var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()
+
+// Initialize the fields for encoding and decoding.
+func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {
+	p.enc = nil
+	p.dec = nil
+	p.size = nil
+	isMap := typ.Kind() == reflect.Map
+	if len(p.CustomType) > 0 && !isMap {
+		p.setCustomEncAndDec(typ)
+		p.setTag(lockGetProp)
+		return
+	}
+	if p.StdTime && !isMap {
+		p.setTimeEncAndDec(typ)
+		p.setTag(lockGetProp)
+		return
+	}
+	if p.StdDuration && !isMap {
+		p.setDurationEncAndDec(typ)
+		p.setTag(lockGetProp)
+		return
+	}
+	switch t1 := typ; t1.Kind() {
+	default:
+		fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1)
+
+	// proto3 scalar types
+
+	case reflect.Bool:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_bool
+			p.dec = (*Buffer).dec_proto3_bool
+			p.size = size_proto3_bool
+		} else {
+			p.enc = (*Buffer).enc_ref_bool
+			p.dec = (*Buffer).dec_proto3_bool
+			p.size = size_ref_bool
+		}
+	case reflect.Int32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int32
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_proto3_int32
+		} else {
+			p.enc = (*Buffer).enc_ref_int32
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_ref_int32
+		}
+	case reflect.Uint32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_uint32
+			p.dec = (*Buffer).dec_proto3_int32 // can reuse
+			p.size = size_proto3_uint32
+		} else {
+			p.enc = (*Buffer).enc_ref_uint32
+			p.dec = (*Buffer).dec_proto3_int32 // can reuse
+			p.size = size_ref_uint32
+		}
+	case reflect.Int64, reflect.Uint64:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int64
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_proto3_int64
+		} else {
+			p.enc = (*Buffer).enc_ref_int64
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_ref_int64
+		}
+	case reflect.Float32:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_proto3_uint32
+		} else {
+			p.enc = (*Buffer).enc_ref_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int32
+			p.size = size_ref_uint32
+		}
+	case reflect.Float64:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_proto3_int64
+		} else {
+			p.enc = (*Buffer).enc_ref_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_proto3_int64
+			p.size = size_ref_int64
+		}
+	case reflect.String:
+		if p.proto3 {
+			p.enc = (*Buffer).enc_proto3_string
+			p.dec = (*Buffer).dec_proto3_string
+			p.size = size_proto3_string
+		} else {
+			p.enc = (*Buffer).enc_ref_string
+			p.dec = (*Buffer).dec_proto3_string
+			p.size = size_ref_string
+		}
+	case reflect.Struct:
+		p.stype = typ
+		p.isMarshaler = isMarshaler(typ)
+		p.isUnmarshaler = isUnmarshaler(typ)
+		if p.Wire == "bytes" {
+			p.enc = (*Buffer).enc_ref_struct_message
+			p.dec = (*Buffer).dec_ref_struct_message
+			p.size = size_ref_struct_message
+		} else {
+			fmt.Fprintf(os.Stderr, "proto: no coders for struct %T\n", typ)
+		}
+
+	case reflect.Ptr:
+		switch t2 := t1.Elem(); t2.Kind() {
+		default:
+			fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2)
+			break
+		case reflect.Bool:
+			p.enc = (*Buffer).enc_bool
+			p.dec = (*Buffer).dec_bool
+			p.size = size_bool
+		case reflect.Int32:
+			p.enc = (*Buffer).enc_int32
+			p.dec = (*Buffer).dec_int32
+			p.size = size_int32
+		case reflect.Uint32:
+			p.enc = (*Buffer).enc_uint32
+			p.dec = (*Buffer).dec_int32 // can reuse
+			p.size = size_uint32
+		case reflect.Int64, reflect.Uint64:
+			p.enc = (*Buffer).enc_int64
+			p.dec = (*Buffer).dec_int64
+			p.size = size_int64
+		case reflect.Float32:
+			p.enc = (*Buffer).enc_uint32 // can just treat them as bits
+			p.dec = (*Buffer).dec_int32
+			p.size = size_uint32
+		case reflect.Float64:
+			p.enc = (*Buffer).enc_int64 // can just treat them as bits
+			p.dec = (*Buffer).dec_int64
+			p.size = size_int64
+		case reflect.String:
+			p.enc = (*Buffer).enc_string
+			p.dec = (*Buffer).dec_string
+			p.size = size_string
+		case reflect.Struct:
+			p.stype = t1.Elem()
+			p.isMarshaler = isMarshaler(t1)
+			p.isUnmarshaler = isUnmarshaler(t1)
+			if p.Wire == "bytes" {
+				p.enc = (*Buffer).enc_struct_message
+				p.dec = (*Buffer).dec_struct_message
+				p.size = size_struct_message
+			} else {
+				p.enc = (*Buffer).enc_struct_group
+				p.dec = (*Buffer).dec_struct_group
+				p.size = size_struct_group
+			}
+		}
+
+	case reflect.Slice:
+		switch t2 := t1.Elem(); t2.Kind() {
+		default:
+			logNoSliceEnc(t1, t2)
+			break
+		case reflect.Bool:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_bool
+				p.size = size_slice_packed_bool
+			} else {
+				p.enc = (*Buffer).enc_slice_bool
+				p.size = size_slice_bool
+			}
+			p.dec = (*Buffer).dec_slice_bool
+			p.packedDec = (*Buffer).dec_slice_packed_bool
+		case reflect.Int32:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_int32
+				p.size = size_slice_packed_int32
+			} else {
+				p.enc = (*Buffer).enc_slice_int32
+				p.size = size_slice_int32
+			}
+			p.dec = (*Buffer).dec_slice_int32
+			p.packedDec = (*Buffer).dec_slice_packed_int32
+		case reflect.Uint32:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_uint32
+				p.size = size_slice_packed_uint32
+			} else {
+				p.enc = (*Buffer).enc_slice_uint32
+				p.size = size_slice_uint32
+			}
+			p.dec = (*Buffer).dec_slice_int32
+			p.packedDec = (*Buffer).dec_slice_packed_int32
+		case reflect.Int64, reflect.Uint64:
+			if p.Packed {
+				p.enc = (*Buffer).enc_slice_packed_int64
+				p.size = size_slice_packed_int64
+			} else {
+				p.enc = (*Buffer).enc_slice_int64
+				p.size = size_slice_int64
+			}
+			p.dec = (*Buffer).dec_slice_int64
+			p.packedDec = (*Buffer).dec_slice_packed_int64
+		case reflect.Uint8:
+			p.dec = (*Buffer).dec_slice_byte
+			if p.proto3 {
+				p.enc = (*Buffer).enc_proto3_slice_byte
+				p.size = size_proto3_slice_byte
+			} else {
+				p.enc = (*Buffer).enc_slice_byte
+				p.size = size_slice_byte
+			}
+		case reflect.Float32, reflect.Float64:
+			switch t2.Bits() {
+			case 32:
+				// can just treat them as bits
+				if p.Packed {
+					p.enc = (*Buffer).enc_slice_packed_uint32
+					p.size = size_slice_packed_uint32
+				} else {
+					p.enc = (*Buffer).enc_slice_uint32
+					p.size = size_slice_uint32
+				}
+				p.dec = (*Buffer).dec_slice_int32
+				p.packedDec = (*Buffer).dec_slice_packed_int32
+			case 64:
+				// can just treat them as bits
+				if p.Packed {
+					p.enc = (*Buffer).enc_slice_packed_int64
+					p.size = size_slice_packed_int64
+				} else {
+					p.enc = (*Buffer).enc_slice_int64
+					p.size = size_slice_int64
+				}
+				p.dec = (*Buffer).dec_slice_int64
+				p.packedDec = (*Buffer).dec_slice_packed_int64
+			default:
+				logNoSliceEnc(t1, t2)
+				break
+			}
+		case reflect.String:
+			p.enc = (*Buffer).enc_slice_string
+			p.dec = (*Buffer).dec_slice_string
+			p.size = size_slice_string
+		case reflect.Ptr:
+			switch t3 := t2.Elem(); t3.Kind() {
+			default:
+				fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
+				break
+			case reflect.Struct:
+				p.stype = t2.Elem()
+				p.isMarshaler = isMarshaler(t2)
+				p.isUnmarshaler = isUnmarshaler(t2)
+				if p.Wire == "bytes" {
+					p.enc = (*Buffer).enc_slice_struct_message
+					p.dec = (*Buffer).dec_slice_struct_message
+					p.size = size_slice_struct_message
+				} else {
+					p.enc = (*Buffer).enc_slice_struct_group
+					p.dec = (*Buffer).dec_slice_struct_group
+					p.size = size_slice_struct_group
+				}
+			}
+		case reflect.Slice:
+			switch t2.Elem().Kind() {
+			default:
+				fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
+				break
+			case reflect.Uint8:
+				p.enc = (*Buffer).enc_slice_slice_byte
+				p.dec = (*Buffer).dec_slice_slice_byte
+				p.size = size_slice_slice_byte
+			}
+		case reflect.Struct:
+			p.setSliceOfNonPointerStructs(t1)
+		}
+
+	case reflect.Map:
+		p.enc = (*Buffer).enc_new_map
+		p.dec = (*Buffer).dec_new_map
+		p.size = size_new_map
+
+		p.mtype = t1
+		p.mkeyprop = &Properties{}
+		p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)
+		p.mvalprop = &Properties{}
+		vtype := p.mtype.Elem()
+		if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {
+			// The value type is not a message (*T) or bytes ([]byte),
+			// so we need encoders for the pointer to this type.
+			vtype = reflect.PtrTo(vtype)
+		}
+
+		p.mvalprop.CustomType = p.CustomType
+		p.mvalprop.StdDuration = p.StdDuration
+		p.mvalprop.StdTime = p.StdTime
+		p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)
+	}
+	p.setTag(lockGetProp)
+}
+
+func (p *Properties) setTag(lockGetProp bool) {
+	// precalculate tag code
+	wire := p.WireType
+	if p.Packed {
+		wire = WireBytes
+	}
+	x := uint32(p.Tag)<<3 | uint32(wire)
+	i := 0
+	for i = 0; x > 127; i++ {
+		p.tagbuf[i] = 0x80 | uint8(x&0x7F)
+		x >>= 7
+	}
+	p.tagbuf[i] = uint8(x)
+	p.tagcode = p.tagbuf[0 : i+1]
+
+	if p.stype != nil {
+		if lockGetProp {
+			p.sprop = GetProperties(p.stype)
+		} else {
+			p.sprop = getPropertiesLocked(p.stype)
+		}
+	}
+}
+
+var (
+	marshalerType   = reflect.TypeOf((*Marshaler)(nil)).Elem()
+	unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+)
+
+// isMarshaler reports whether type t implements Marshaler.
+func isMarshaler(t reflect.Type) bool {
+	return t.Implements(marshalerType)
+}
+
+// isUnmarshaler reports whether type t implements Unmarshaler.
+func isUnmarshaler(t reflect.Type) bool {
+	return t.Implements(unmarshalerType)
+}
+
+// Init populates the properties from a protocol buffer struct tag.
+func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
+	p.init(typ, name, tag, f, true)
+}
+
+func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) {
+	// "bytes,49,opt,def=hello!"
+	p.Name = name
+	p.OrigName = name
+	if f != nil {
+		p.field = toField(f)
+	}
+	if tag == "" {
+		return
+	}
+	p.Parse(tag)
+	p.setEncAndDec(typ, f, lockGetProp)
+}
+
+var (
+	propertiesMu  sync.RWMutex
+	propertiesMap = make(map[reflect.Type]*StructProperties)
+)
+
+// GetProperties returns the list of properties for the type represented by t.
+// t must represent a generated struct type of a protocol message.
+func GetProperties(t reflect.Type) *StructProperties {
+	if t.Kind() != reflect.Struct {
+		panic("proto: type must have kind struct")
+	}
+
+	// Most calls to GetProperties in a long-running program will be
+	// retrieving details for types we have seen before.
+	propertiesMu.RLock()
+	sprop, ok := propertiesMap[t]
+	propertiesMu.RUnlock()
+	if ok {
+		if collectStats {
+			stats.Chit++
+		}
+		return sprop
+	}
+
+	propertiesMu.Lock()
+	sprop = getPropertiesLocked(t)
+	propertiesMu.Unlock()
+	return sprop
+}
+
+// getPropertiesLocked requires that propertiesMu is held.
+func getPropertiesLocked(t reflect.Type) *StructProperties {
+	if prop, ok := propertiesMap[t]; ok {
+		if collectStats {
+			stats.Chit++
+		}
+		return prop
+	}
+	if collectStats {
+		stats.Cmiss++
+	}
+
+	prop := new(StructProperties)
+	// in case of recursive protos, fill this in now.
+	propertiesMap[t] = prop
+
+	// build properties
+	prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ||
+		reflect.PtrTo(t).Implements(extendableProtoV1Type) ||
+		reflect.PtrTo(t).Implements(extendableBytesType)
+	prop.unrecField = invalidField
+	prop.Prop = make([]*Properties, t.NumField())
+	prop.order = make([]int, t.NumField())
+
+	isOneofMessage := false
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		p := new(Properties)
+		name := f.Name
+		p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)
+
+		if f.Name == "XXX_InternalExtensions" { // special case
+			p.enc = (*Buffer).enc_exts
+			p.dec = nil // not needed
+			p.size = size_exts
+		} else if f.Name == "XXX_extensions" { // special case
+			if len(f.Tag.Get("protobuf")) > 0 {
+				p.enc = (*Buffer).enc_ext_slice_byte
+				p.dec = nil // not needed
+				p.size = size_ext_slice_byte
+			} else {
+				p.enc = (*Buffer).enc_map
+				p.dec = nil // not needed
+				p.size = size_map
+			}
+		} else if f.Name == "XXX_unrecognized" { // special case
+			prop.unrecField = toField(&f)
+		}
+		oneof := f.Tag.Get("protobuf_oneof") // special case
+		if oneof != "" {
+			isOneofMessage = true
+			// Oneof fields don't use the traditional protobuf tag.
+			p.OrigName = oneof
+		}
+		prop.Prop[i] = p
+		prop.order[i] = i
+		if debug {
+			print(i, " ", f.Name, " ", t.String(), " ")
+			if p.Tag > 0 {
+				print(p.String())
+			}
+			print("\n")
+		}
+		if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" {
+			fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
+		}
+	}
+
+	// Re-order prop.order.
+	sort.Sort(prop)
+
+	type oneofMessage interface {
+		XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
+	}
+	if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); isOneofMessage && ok {
+		var oots []interface{}
+		prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs()
+		prop.stype = t
+
+		// Interpret oneof metadata.
+		prop.OneofTypes = make(map[string]*OneofProperties)
+		for _, oot := range oots {
+			oop := &OneofProperties{
+				Type: reflect.ValueOf(oot).Type(), // *T
+				Prop: new(Properties),
+			}
+			sft := oop.Type.Elem().Field(0)
+			oop.Prop.Name = sft.Name
+			oop.Prop.Parse(sft.Tag.Get("protobuf"))
+			// There will be exactly one interface field that
+			// this new value is assignable to.
+			for i := 0; i < t.NumField(); i++ {
+				f := t.Field(i)
+				if f.Type.Kind() != reflect.Interface {
+					continue
+				}
+				if !oop.Type.AssignableTo(f.Type) {
+					continue
+				}
+				oop.Field = i
+				break
+			}
+			prop.OneofTypes[oop.Prop.OrigName] = oop
+		}
+	}
+
+	// build required counts
+	// build tags
+	reqCount := 0
+	prop.decoderOrigNames = make(map[string]int)
+	for i, p := range prop.Prop {
+		if strings.HasPrefix(p.Name, "XXX_") {
+			// Internal fields should not appear in tags/origNames maps.
+			// They are handled specially when encoding and decoding.
+			continue
+		}
+		if p.Required {
+			reqCount++
+		}
+		prop.decoderTags.put(p.Tag, i)
+		prop.decoderOrigNames[p.OrigName] = i
+	}
+	prop.reqCount = reqCount
+
+	return prop
+}
+
+// Return the Properties object for the x[0]'th field of the structure.
+func propByIndex(t reflect.Type, x []int) *Properties {
+	if len(x) != 1 {
+		fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t)
+		return nil
+	}
+	prop := GetProperties(t)
+	return prop.Prop[x[0]]
+}
+
+// Get the address and type of a pointer to a struct from an interface.
+func getbase(pb Message) (t reflect.Type, b structPointer, err error) {
+	if pb == nil {
+		err = ErrNil
+		return
+	}
+	// get the reflect type of the pointer to the struct.
+	t = reflect.TypeOf(pb)
+	// get the address of the struct.
+	value := reflect.ValueOf(pb)
+	b = toStructPointer(value)
+	return
+}
+
+// A global registry of enum types.
+// The generated code will register the generated maps by calling RegisterEnum.
+
+var enumValueMaps = make(map[string]map[string]int32)
+var enumStringMaps = make(map[string]map[int32]string)
+
+// RegisterEnum is called from the generated code to install the enum descriptor
+// maps into the global table to aid parsing text format protocol buffers.
+func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) {
+	if _, ok := enumValueMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumValueMaps[typeName] = valueMap
+	if _, ok := enumStringMaps[typeName]; ok {
+		panic("proto: duplicate enum registered: " + typeName)
+	}
+	enumStringMaps[typeName] = unusedNameMap
+}
+
+// EnumValueMap returns the mapping from names to integers of the
+// enum type enumType, or a nil if not found.
+func EnumValueMap(enumType string) map[string]int32 {
+	return enumValueMaps[enumType]
+}
+
+// A registry of all linked message types.
+// The string is a fully-qualified proto name ("pkg.Message").
+var (
+	protoTypes    = make(map[string]reflect.Type)
+	revProtoTypes = make(map[reflect.Type]string)
+)
+
+// RegisterType is called from generated code and maps from the fully qualified
+// proto name to the type (pointer to struct) of the protocol buffer.
+func RegisterType(x Message, name string) {
+	if _, ok := protoTypes[name]; ok {
+		// TODO: Some day, make this a panic.
+		log.Printf("proto: duplicate proto type registered: %s", name)
+		return
+	}
+	t := reflect.TypeOf(x)
+	protoTypes[name] = t
+	revProtoTypes[t] = name
+}
+
+// MessageName returns the fully-qualified proto name for the given message type.
+func MessageName(x Message) string {
+	type xname interface {
+		XXX_MessageName() string
+	}
+	if m, ok := x.(xname); ok {
+		return m.XXX_MessageName()
+	}
+	return revProtoTypes[reflect.TypeOf(x)]
+}
+
+// MessageType returns the message type (pointer to struct) for a named message.
+func MessageType(name string) reflect.Type { return protoTypes[name] }
+
+// A registry of all linked proto files.
+var (
+	protoFiles = make(map[string][]byte) // file name => fileDescriptor
+)
+
+// RegisterFile is called from generated code and maps from the
+// full file name of a .proto file to its compressed FileDescriptorProto.
+func RegisterFile(filename string, fileDescriptor []byte) {
+	protoFiles[filename] = fileDescriptor
+}
+
+// FileDescriptor returns the compressed FileDescriptorProto for a .proto file.
+func FileDescriptor(filename string) []byte { return protoFiles[filename] }
diff --git a/vendor/github.com/gogo/protobuf/proto/properties_gogo.go b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
new file mode 100644
index 000000000..b6b7176c5
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/properties_gogo.go
@@ -0,0 +1,111 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+)
+
+func (p *Properties) setCustomEncAndDec(typ reflect.Type) {
+	p.ctype = typ
+	if p.Repeated {
+		p.enc = (*Buffer).enc_custom_slice_bytes
+		p.dec = (*Buffer).dec_custom_slice_bytes
+		p.size = size_custom_slice_bytes
+	} else if typ.Kind() == reflect.Ptr {
+		p.enc = (*Buffer).enc_custom_bytes
+		p.dec = (*Buffer).dec_custom_bytes
+		p.size = size_custom_bytes
+	} else {
+		p.enc = (*Buffer).enc_custom_ref_bytes
+		p.dec = (*Buffer).dec_custom_ref_bytes
+		p.size = size_custom_ref_bytes
+	}
+}
+
+func (p *Properties) setDurationEncAndDec(typ reflect.Type) {
+	if p.Repeated {
+		if typ.Elem().Kind() == reflect.Ptr {
+			p.enc = (*Buffer).enc_slice_duration
+			p.dec = (*Buffer).dec_slice_duration
+			p.size = size_slice_duration
+		} else {
+			p.enc = (*Buffer).enc_slice_ref_duration
+			p.dec = (*Buffer).dec_slice_ref_duration
+			p.size = size_slice_ref_duration
+		}
+	} else if typ.Kind() == reflect.Ptr {
+		p.enc = (*Buffer).enc_duration
+		p.dec = (*Buffer).dec_duration
+		p.size = size_duration
+	} else {
+		p.enc = (*Buffer).enc_ref_duration
+		p.dec = (*Buffer).dec_ref_duration
+		p.size = size_ref_duration
+	}
+}
+
+func (p *Properties) setTimeEncAndDec(typ reflect.Type) {
+	if p.Repeated {
+		if typ.Elem().Kind() == reflect.Ptr {
+			p.enc = (*Buffer).enc_slice_time
+			p.dec = (*Buffer).dec_slice_time
+			p.size = size_slice_time
+		} else {
+			p.enc = (*Buffer).enc_slice_ref_time
+			p.dec = (*Buffer).dec_slice_ref_time
+			p.size = size_slice_ref_time
+		}
+	} else if typ.Kind() == reflect.Ptr {
+		p.enc = (*Buffer).enc_time
+		p.dec = (*Buffer).dec_time
+		p.size = size_time
+	} else {
+		p.enc = (*Buffer).enc_ref_time
+		p.dec = (*Buffer).dec_ref_time
+		p.size = size_ref_time
+	}
+
+}
+
+func (p *Properties) setSliceOfNonPointerStructs(typ reflect.Type) {
+	t2 := typ.Elem()
+	p.sstype = typ
+	p.stype = t2
+	p.isMarshaler = isMarshaler(t2)
+	p.isUnmarshaler = isUnmarshaler(t2)
+	p.enc = (*Buffer).enc_slice_ref_struct_message
+	p.dec = (*Buffer).dec_slice_ref_struct_message
+	p.size = size_slice_ref_struct_message
+	if p.Wire != "bytes" {
+		fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T \n", typ, t2)
+	}
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/skip_gogo.go b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
new file mode 100644
index 000000000..5a5fd93f7
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/skip_gogo.go
@@ -0,0 +1,119 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"io"
+)
+
+func Skip(data []byte) (n int, err error) {
+	l := len(data)
+	index := 0
+	for index < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if index >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := data[index]
+			index++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for {
+				if index >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				index++
+				if data[index-1] < 0x80 {
+					break
+				}
+			}
+			return index, nil
+		case 1:
+			index += 8
+			return index, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if index >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := data[index]
+				index++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			index += length
+			return index, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = index
+				for shift := uint(0); ; shift += 7 {
+					if index >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := data[index]
+					index++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := Skip(data[start:])
+				if err != nil {
+					return 0, err
+				}
+				index = start + next
+			}
+			return index, nil
+		case 4:
+			return index, nil
+		case 5:
+			index += 4
+			return index, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/text.go b/vendor/github.com/gogo/protobuf/proto/text.go
new file mode 100644
index 000000000..f609d1d45
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text.go
@@ -0,0 +1,939 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for writing the text protocol buffer format.
+
+import (
+	"bufio"
+	"bytes"
+	"encoding"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"math"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	newline         = []byte("\n")
+	spaces          = []byte("                                        ")
+	gtNewline       = []byte(">\n")
+	endBraceNewline = []byte("}\n")
+	backslashN      = []byte{'\\', 'n'}
+	backslashR      = []byte{'\\', 'r'}
+	backslashT      = []byte{'\\', 't'}
+	backslashDQ     = []byte{'\\', '"'}
+	backslashBS     = []byte{'\\', '\\'}
+	posInf          = []byte("inf")
+	negInf          = []byte("-inf")
+	nan             = []byte("nan")
+)
+
+type writer interface {
+	io.Writer
+	WriteByte(byte) error
+}
+
+// textWriter is an io.Writer that tracks its indentation level.
+type textWriter struct {
+	ind      int
+	complete bool // if the current position is a complete line
+	compact  bool // whether to write out as a one-liner
+	w        writer
+}
+
+func (w *textWriter) WriteString(s string) (n int, err error) {
+	if !strings.Contains(s, "\n") {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		w.complete = false
+		return io.WriteString(w.w, s)
+	}
+	// WriteString is typically called without newlines, so this
+	// codepath and its copy are rare.  We copy to avoid
+	// duplicating all of Write's logic here.
+	return w.Write([]byte(s))
+}
+
+func (w *textWriter) Write(p []byte) (n int, err error) {
+	newlines := bytes.Count(p, newline)
+	if newlines == 0 {
+		if !w.compact && w.complete {
+			w.writeIndent()
+		}
+		n, err = w.w.Write(p)
+		w.complete = false
+		return n, err
+	}
+
+	frags := bytes.SplitN(p, newline, newlines+1)
+	if w.compact {
+		for i, frag := range frags {
+			if i > 0 {
+				if err := w.w.WriteByte(' '); err != nil {
+					return n, err
+				}
+				n++
+			}
+			nn, err := w.w.Write(frag)
+			n += nn
+			if err != nil {
+				return n, err
+			}
+		}
+		return n, nil
+	}
+
+	for i, frag := range frags {
+		if w.complete {
+			w.writeIndent()
+		}
+		nn, err := w.w.Write(frag)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+		if i+1 < len(frags) {
+			if err := w.w.WriteByte('\n'); err != nil {
+				return n, err
+			}
+			n++
+		}
+	}
+	w.complete = len(frags[len(frags)-1]) == 0
+	return n, nil
+}
+
+func (w *textWriter) WriteByte(c byte) error {
+	if w.compact && c == '\n' {
+		c = ' '
+	}
+	if !w.compact && w.complete {
+		w.writeIndent()
+	}
+	err := w.w.WriteByte(c)
+	w.complete = c == '\n'
+	return err
+}
+
+func (w *textWriter) indent() { w.ind++ }
+
+func (w *textWriter) unindent() {
+	if w.ind == 0 {
+		log.Print("proto: textWriter unindented too far")
+		return
+	}
+	w.ind--
+}
+
+func writeName(w *textWriter, props *Properties) error {
+	if _, err := w.WriteString(props.OrigName); err != nil {
+		return err
+	}
+	if props.Wire != "group" {
+		return w.WriteByte(':')
+	}
+	return nil
+}
+
+// raw is the interface satisfied by RawMessage.
+type raw interface {
+	Bytes() []byte
+}
+
+func requiresQuotes(u string) bool {
+	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
+	for _, ch := range u {
+		switch {
+		case ch == '.' || ch == '/' || ch == '_':
+			continue
+		case '0' <= ch && ch <= '9':
+			continue
+		case 'A' <= ch && ch <= 'Z':
+			continue
+		case 'a' <= ch && ch <= 'z':
+			continue
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+// isAny reports whether sv is a google.protobuf.Any message
+func isAny(sv reflect.Value) bool {
+	type wkt interface {
+		XXX_WellKnownType() string
+	}
+	t, ok := sv.Addr().Interface().(wkt)
+	return ok && t.XXX_WellKnownType() == "Any"
+}
+
+// writeProto3Any writes an expanded google.protobuf.Any message.
+//
+// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
+// required messages are not linked in).
+//
+// It returns (true, error) when sv was written in expanded format or an error
+// was encountered.
+func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
+	turl := sv.FieldByName("TypeUrl")
+	val := sv.FieldByName("Value")
+	if !turl.IsValid() || !val.IsValid() {
+		return true, errors.New("proto: invalid google.protobuf.Any message")
+	}
+
+	b, ok := val.Interface().([]byte)
+	if !ok {
+		return true, errors.New("proto: invalid google.protobuf.Any message")
+	}
+
+	parts := strings.Split(turl.String(), "/")
+	mt := MessageType(parts[len(parts)-1])
+	if mt == nil {
+		return false, nil
+	}
+	m := reflect.New(mt.Elem())
+	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
+		return false, nil
+	}
+	w.Write([]byte("["))
+	u := turl.String()
+	if requiresQuotes(u) {
+		writeString(w, u)
+	} else {
+		w.Write([]byte(u))
+	}
+	if w.compact {
+		w.Write([]byte("]:<"))
+	} else {
+		w.Write([]byte("]: <\n"))
+		w.ind++
+	}
+	if err := tm.writeStruct(w, m.Elem()); err != nil {
+		return true, err
+	}
+	if w.compact {
+		w.Write([]byte("> "))
+	} else {
+		w.ind--
+		w.Write([]byte(">\n"))
+	}
+	return true, nil
+}
+
+func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
+	if tm.ExpandAny && isAny(sv) {
+		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
+			return err
+		}
+	}
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < sv.NumField(); i++ {
+		fv := sv.Field(i)
+		props := sprops.Prop[i]
+		name := st.Field(i).Name
+
+		if strings.HasPrefix(name, "XXX_") {
+			// There are two XXX_ fields:
+			//   XXX_unrecognized []byte
+			//   XXX_extensions   map[int32]proto.Extension
+			// The first is handled here;
+			// the second is handled at the bottom of this function.
+			if name == "XXX_unrecognized" && !fv.IsNil() {
+				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Ptr && fv.IsNil() {
+			// Field not filled in. This could be an optional field or
+			// a required field that wasn't filled in. Either way, there
+			// isn't anything we can show for it.
+			continue
+		}
+		if fv.Kind() == reflect.Slice && fv.IsNil() {
+			// Repeated field that is empty, or a bytes field that is unused.
+			continue
+		}
+
+		if props.Repeated && fv.Kind() == reflect.Slice {
+			// Repeated field.
+			for j := 0; j < fv.Len(); j++ {
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				v := fv.Index(j)
+				if v.Kind() == reflect.Ptr && v.IsNil() {
+					// A nil message in a repeated field is not valid,
+					// but we can handle that more gracefully than panicking.
+					if _, err := w.Write([]byte("<nil>\n")); err != nil {
+						return err
+					}
+					continue
+				}
+				if len(props.Enum) > 0 {
+					if err := tm.writeEnum(w, v, props); err != nil {
+						return err
+					}
+				} else if err := tm.writeAny(w, v, props); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if fv.Kind() == reflect.Map {
+			// Map fields are rendered as a repeated struct with key/value fields.
+			keys := fv.MapKeys()
+			sort.Sort(mapKeys(keys))
+			for _, key := range keys {
+				val := fv.MapIndex(key)
+				if err := writeName(w, props); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				// open struct
+				if err := w.WriteByte('<'); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte('\n'); err != nil {
+						return err
+					}
+				}
+				w.indent()
+				// key
+				if _, err := w.WriteString("key:"); err != nil {
+					return err
+				}
+				if !w.compact {
+					if err := w.WriteByte(' '); err != nil {
+						return err
+					}
+				}
+				if err := tm.writeAny(w, key, props.mkeyprop); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+				// nil values aren't legal, but we can avoid panicking because of them.
+				if val.Kind() != reflect.Ptr || !val.IsNil() {
+					// value
+					if _, err := w.WriteString("value:"); err != nil {
+						return err
+					}
+					if !w.compact {
+						if err := w.WriteByte(' '); err != nil {
+							return err
+						}
+					}
+					if err := tm.writeAny(w, val, props.mvalprop); err != nil {
+						return err
+					}
+					if err := w.WriteByte('\n'); err != nil {
+						return err
+					}
+				}
+				// close struct
+				w.unindent()
+				if err := w.WriteByte('>'); err != nil {
+					return err
+				}
+				if err := w.WriteByte('\n'); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
+			// empty bytes field
+			continue
+		}
+		if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
+			// proto3 non-repeated scalar field; skip if zero value
+			if isProto3Zero(fv) {
+				continue
+			}
+		}
+
+		if fv.Kind() == reflect.Interface {
+			// Check if it is a oneof.
+			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
+				// fv is nil, or holds a pointer to generated struct.
+				// That generated struct has exactly one field,
+				// which has a protobuf struct tag.
+				if fv.IsNil() {
+					continue
+				}
+				inner := fv.Elem().Elem() // interface -> *T -> T
+				tag := inner.Type().Field(0).Tag.Get("protobuf")
+				props = new(Properties) // Overwrite the outer props var, but not its pointee.
+				props.Parse(tag)
+				// Write the value in the oneof, not the oneof itself.
+				fv = inner.Field(0)
+
+				// Special case to cope with malformed messages gracefully:
+				// If the value in the oneof is a nil pointer, don't panic
+				// in writeAny.
+				if fv.Kind() == reflect.Ptr && fv.IsNil() {
+					// Use errors.New so writeAny won't render quotes.
+					msg := errors.New("/* nil */")
+					fv = reflect.ValueOf(&msg).Elem()
+				}
+			}
+		}
+
+		if err := writeName(w, props); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+		if b, ok := fv.Interface().(raw); ok {
+			if err := writeRaw(w, b.Bytes()); err != nil {
+				return err
+			}
+			continue
+		}
+
+		if len(props.Enum) > 0 {
+			if err := tm.writeEnum(w, fv, props); err != nil {
+				return err
+			}
+		} else if err := tm.writeAny(w, fv, props); err != nil {
+			return err
+		}
+
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+
+	// Extensions (the XXX_extensions field).
+	pv := sv
+	if pv.CanAddr() {
+		pv = sv.Addr()
+	} else {
+		pv = reflect.New(sv.Type())
+		pv.Elem().Set(sv)
+	}
+	if pv.Type().Implements(extensionRangeType) {
+		if err := tm.writeExtensions(w, pv); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeRaw writes an uninterpreted raw message.
+func writeRaw(w *textWriter, b []byte) error {
+	if err := w.WriteByte('<'); err != nil {
+		return err
+	}
+	if !w.compact {
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+	w.indent()
+	if err := writeUnknownStruct(w, b); err != nil {
+		return err
+	}
+	w.unindent()
+	if err := w.WriteByte('>'); err != nil {
+		return err
+	}
+	return nil
+}
+
+// writeAny writes an arbitrary field.
+func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
+	v = reflect.Indirect(v)
+
+	if props != nil {
+		if len(props.CustomType) > 0 {
+			custom, ok := v.Interface().(Marshaler)
+			if ok {
+				data, err := custom.Marshal()
+				if err != nil {
+					return err
+				}
+				if err := writeString(w, string(data)); err != nil {
+					return err
+				}
+				return nil
+			}
+		} else if len(props.CastType) > 0 {
+			if _, ok := v.Interface().(interface {
+				String() string
+			}); ok {
+				switch v.Kind() {
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+					_, err := fmt.Fprintf(w, "%d", v.Interface())
+					return err
+				}
+			}
+		} else if props.StdTime {
+			t, ok := v.Interface().(time.Time)
+			if !ok {
+				return fmt.Errorf("stdtime is not time.Time, but %T", v.Interface())
+			}
+			tproto, err := timestampProto(t)
+			if err != nil {
+				return err
+			}
+			propsCopy := *props // Make a copy so that this is goroutine-safe
+			propsCopy.StdTime = false
+			err = tm.writeAny(w, reflect.ValueOf(tproto), &propsCopy)
+			return err
+		} else if props.StdDuration {
+			d, ok := v.Interface().(time.Duration)
+			if !ok {
+				return fmt.Errorf("stdtime is not time.Duration, but %T", v.Interface())
+			}
+			dproto := durationProto(d)
+			propsCopy := *props // Make a copy so that this is goroutine-safe
+			propsCopy.StdDuration = false
+			err := tm.writeAny(w, reflect.ValueOf(dproto), &propsCopy)
+			return err
+		}
+	}
+
+	// Floats have special cases.
+	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
+		x := v.Float()
+		var b []byte
+		switch {
+		case math.IsInf(x, 1):
+			b = posInf
+		case math.IsInf(x, -1):
+			b = negInf
+		case math.IsNaN(x):
+			b = nan
+		}
+		if b != nil {
+			_, err := w.Write(b)
+			return err
+		}
+		// Other values are handled below.
+	}
+
+	// We don't attempt to serialise every possible value type; only those
+	// that can occur in protocol buffers.
+	switch v.Kind() {
+	case reflect.Slice:
+		// Should only be a []byte; repeated fields are handled in writeStruct.
+		if err := writeString(w, string(v.Bytes())); err != nil {
+			return err
+		}
+	case reflect.String:
+		if err := writeString(w, v.String()); err != nil {
+			return err
+		}
+	case reflect.Struct:
+		// Required/optional group/message.
+		var bra, ket byte = '<', '>'
+		if props != nil && props.Wire == "group" {
+			bra, ket = '{', '}'
+		}
+		if err := w.WriteByte(bra); err != nil {
+			return err
+		}
+		if !w.compact {
+			if err := w.WriteByte('\n'); err != nil {
+				return err
+			}
+		}
+		w.indent()
+		if etm, ok := v.Interface().(encoding.TextMarshaler); ok {
+			text, err := etm.MarshalText()
+			if err != nil {
+				return err
+			}
+			if _, err = w.Write(text); err != nil {
+				return err
+			}
+		} else if err := tm.writeStruct(w, v); err != nil {
+			return err
+		}
+		w.unindent()
+		if err := w.WriteByte(ket); err != nil {
+			return err
+		}
+	default:
+		_, err := fmt.Fprint(w, v.Interface())
+		return err
+	}
+	return nil
+}
+
+// equivalent to C's isprint.
+func isprint(c byte) bool {
+	return c >= 0x20 && c < 0x7f
+}
+
+// writeString writes a string in the protocol buffer text format.
+// It is similar to strconv.Quote except we don't use Go escape sequences,
+// we treat the string as a byte sequence, and we use octal escapes.
+// These differences are to maintain interoperability with the other
+// languages' implementations of the text format.
+func writeString(w *textWriter, s string) error {
+	// use WriteByte here to get any needed indent
+	if err := w.WriteByte('"'); err != nil {
+		return err
+	}
+	// Loop over the bytes, not the runes.
+	for i := 0; i < len(s); i++ {
+		var err error
+		// Divergence from C++: we don't escape apostrophes.
+		// There's no need to escape them, and the C++ parser
+		// copes with a naked apostrophe.
+		switch c := s[i]; c {
+		case '\n':
+			_, err = w.w.Write(backslashN)
+		case '\r':
+			_, err = w.w.Write(backslashR)
+		case '\t':
+			_, err = w.w.Write(backslashT)
+		case '"':
+			_, err = w.w.Write(backslashDQ)
+		case '\\':
+			_, err = w.w.Write(backslashBS)
+		default:
+			if isprint(c) {
+				err = w.w.WriteByte(c)
+			} else {
+				_, err = fmt.Fprintf(w.w, "\\%03o", c)
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return w.WriteByte('"')
+}
+
+func writeUnknownStruct(w *textWriter, data []byte) (err error) {
+	if !w.compact {
+		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
+			return err
+		}
+	}
+	b := NewBuffer(data)
+	for b.index < len(b.buf) {
+		x, err := b.DecodeVarint()
+		if err != nil {
+			_, ferr := fmt.Fprintf(w, "/* %v */\n", err)
+			return ferr
+		}
+		wire, tag := x&7, x>>3
+		if wire == WireEndGroup {
+			w.unindent()
+			if _, werr := w.Write(endBraceNewline); werr != nil {
+				return werr
+			}
+			continue
+		}
+		if _, ferr := fmt.Fprint(w, tag); ferr != nil {
+			return ferr
+		}
+		if wire != WireStartGroup {
+			if err = w.WriteByte(':'); err != nil {
+				return err
+			}
+		}
+		if !w.compact || wire == WireStartGroup {
+			if err = w.WriteByte(' '); err != nil {
+				return err
+			}
+		}
+		switch wire {
+		case WireBytes:
+			buf, e := b.DecodeRawBytes(false)
+			if e == nil {
+				_, err = fmt.Fprintf(w, "%q", buf)
+			} else {
+				_, err = fmt.Fprintf(w, "/* %v */", e)
+			}
+		case WireFixed32:
+			x, err = b.DecodeFixed32()
+			err = writeUnknownInt(w, x, err)
+		case WireFixed64:
+			x, err = b.DecodeFixed64()
+			err = writeUnknownInt(w, x, err)
+		case WireStartGroup:
+			err = w.WriteByte('{')
+			w.indent()
+		case WireVarint:
+			x, err = b.DecodeVarint()
+			err = writeUnknownInt(w, x, err)
+		default:
+			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
+		}
+		if err != nil {
+			return err
+		}
+		if err := w.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeUnknownInt(w *textWriter, x uint64, err error) error {
+	if err == nil {
+		_, err = fmt.Fprint(w, x)
+	} else {
+		_, err = fmt.Fprintf(w, "/* %v */", err)
+	}
+	return err
+}
+
+type int32Slice []int32
+
+func (s int32Slice) Len() int           { return len(s) }
+func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
+func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// writeExtensions writes all the extensions in pv.
+// pv is assumed to be a pointer to a protocol message struct that is extendable.
+func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
+	emap := extensionMaps[pv.Type().Elem()]
+	e := pv.Interface().(Message)
+
+	var m map[int32]Extension
+	var mu sync.Locker
+	if em, ok := e.(extensionsBytes); ok {
+		eb := em.GetExtensions()
+		var err error
+		m, err = BytesToExtensionsMap(*eb)
+		if err != nil {
+			return err
+		}
+		mu = notLocker{}
+	} else if _, ok := e.(extendableProto); ok {
+		ep, _ := extendable(e)
+		m, mu = ep.extensionsRead()
+		if m == nil {
+			return nil
+		}
+	}
+
+	// Order the extensions by ID.
+	// This isn't strictly necessary, but it will give us
+	// canonical output, which will also make testing easier.
+
+	mu.Lock()
+	ids := make([]int32, 0, len(m))
+	for id := range m {
+		ids = append(ids, id)
+	}
+	sort.Sort(int32Slice(ids))
+	mu.Unlock()
+
+	for _, extNum := range ids {
+		ext := m[extNum]
+		var desc *ExtensionDesc
+		if emap != nil {
+			desc = emap[extNum]
+		}
+		if desc == nil {
+			// Unknown extension.
+			if err := writeUnknownStruct(w, ext.enc); err != nil {
+				return err
+			}
+			continue
+		}
+
+		pb, err := GetExtension(e, desc)
+		if err != nil {
+			return fmt.Errorf("failed getting extension: %v", err)
+		}
+
+		// Repeated extensions will appear as a slice.
+		if !desc.repeated() {
+			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
+				return err
+			}
+		} else {
+			v := reflect.ValueOf(pb)
+			for i := 0; i < v.Len(); i++ {
+				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
+	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
+		return err
+	}
+	if !w.compact {
+		if err := w.WriteByte(' '); err != nil {
+			return err
+		}
+	}
+	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
+		return err
+	}
+	if err := w.WriteByte('\n'); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (w *textWriter) writeIndent() {
+	if !w.complete {
+		return
+	}
+	remain := w.ind * 2
+	for remain > 0 {
+		n := remain
+		if n > len(spaces) {
+			n = len(spaces)
+		}
+		w.w.Write(spaces[:n])
+		remain -= n
+	}
+	w.complete = false
+}
+
+// TextMarshaler is a configurable text format marshaler.
+type TextMarshaler struct {
+	Compact   bool // use compact text format (one line).
+	ExpandAny bool // expand google.protobuf.Any messages of known types
+}
+
+// Marshal writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
+	val := reflect.ValueOf(pb)
+	if pb == nil || val.IsNil() {
+		w.Write([]byte("<nil>"))
+		return nil
+	}
+	var bw *bufio.Writer
+	ww, ok := w.(writer)
+	if !ok {
+		bw = bufio.NewWriter(w)
+		ww = bw
+	}
+	aw := &textWriter{
+		w:        ww,
+		complete: true,
+		compact:  tm.Compact,
+	}
+
+	if etm, ok := pb.(encoding.TextMarshaler); ok {
+		text, err := etm.MarshalText()
+		if err != nil {
+			return err
+		}
+		if _, err = aw.Write(text); err != nil {
+			return err
+		}
+		if bw != nil {
+			return bw.Flush()
+		}
+		return nil
+	}
+	// Dereference the received pointer so we don't have outer < and >.
+	v := reflect.Indirect(val)
+	if err := tm.writeStruct(aw, v); err != nil {
+		return err
+	}
+	if bw != nil {
+		return bw.Flush()
+	}
+	return nil
+}
+
+// Text is the same as Marshal, but returns the string directly.
+func (tm *TextMarshaler) Text(pb Message) string {
+	var buf bytes.Buffer
+	tm.Marshal(&buf, pb)
+	return buf.String()
+}
+
+var (
+	defaultTextMarshaler = TextMarshaler{}
+	compactTextMarshaler = TextMarshaler{Compact: true}
+)
+
+// TODO: consider removing some of the Marshal functions below.
+
+// MarshalText writes a given protocol buffer in text format.
+// The only errors returned are from w.
+func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
+
+// MarshalTextString is the same as MarshalText, but returns the string directly.
+func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
+
+// CompactText writes a given protocol buffer in compact text format (one line).
+func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
+
+// CompactTextString is the same as CompactText, but returns the string directly.
+func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
diff --git a/vendor/github.com/gogo/protobuf/proto/text_gogo.go b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
new file mode 100644
index 000000000..1d6c6aa0e
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_gogo.go
@@ -0,0 +1,57 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func (tm *TextMarshaler) writeEnum(w *textWriter, v reflect.Value, props *Properties) error {
+	m, ok := enumStringMaps[props.Enum]
+	if !ok {
+		if err := tm.writeAny(w, v, props); err != nil {
+			return err
+		}
+	}
+	key := int32(0)
+	if v.Kind() == reflect.Ptr {
+		key = int32(v.Elem().Int())
+	} else {
+		key = int32(v.Int())
+	}
+	s, ok := m[key]
+	if !ok {
+		if err := tm.writeAny(w, v, props); err != nil {
+			return err
+		}
+	}
+	_, err := fmt.Fprint(w, s)
+	return err
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/text_parser.go b/vendor/github.com/gogo/protobuf/proto/text_parser.go
new file mode 100644
index 000000000..f1276729a
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/text_parser.go
@@ -0,0 +1,1013 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// Functions for parsing the Text protocol buffer format.
+// TODO: message sets.
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// Error string emitted when deserializing Any and fields are already set
+const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set"
+
+type ParseError struct {
+	Message string
+	Line    int // 1-based line number
+	Offset  int // 0-based byte offset from start of input
+}
+
+func (p *ParseError) Error() string {
+	if p.Line == 1 {
+		// show offset only for first line
+		return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message)
+	}
+	return fmt.Sprintf("line %d: %v", p.Line, p.Message)
+}
+
+type token struct {
+	value    string
+	err      *ParseError
+	line     int    // line number
+	offset   int    // byte number from start of input, not start of line
+	unquoted string // the unquoted version of value, if it was a quoted string
+}
+
+func (t *token) String() string {
+	if t.err == nil {
+		return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset)
+	}
+	return fmt.Sprintf("parse error: %v", t.err)
+}
+
+type textParser struct {
+	s            string // remaining input
+	done         bool   // whether the parsing is finished (success or error)
+	backed       bool   // whether back() was called
+	offset, line int
+	cur          token
+}
+
+func newTextParser(s string) *textParser {
+	p := new(textParser)
+	p.s = s
+	p.line = 1
+	p.cur.line = 1
+	return p
+}
+
+func (p *textParser) errorf(format string, a ...interface{}) *ParseError {
+	pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
+	p.cur.err = pe
+	p.done = true
+	return pe
+}
+
+// Numbers and identifiers are matched by [-+._A-Za-z0-9]
+func isIdentOrNumberChar(c byte) bool {
+	switch {
+	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z':
+		return true
+	case '0' <= c && c <= '9':
+		return true
+	}
+	switch c {
+	case '-', '+', '.', '_':
+		return true
+	}
+	return false
+}
+
+func isWhitespace(c byte) bool {
+	switch c {
+	case ' ', '\t', '\n', '\r':
+		return true
+	}
+	return false
+}
+
+func isQuote(c byte) bool {
+	switch c {
+	case '"', '\'':
+		return true
+	}
+	return false
+}
+
+func (p *textParser) skipWhitespace() {
+	i := 0
+	for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') {
+		if p.s[i] == '#' {
+			// comment; skip to end of line or input
+			for i < len(p.s) && p.s[i] != '\n' {
+				i++
+			}
+			if i == len(p.s) {
+				break
+			}
+		}
+		if p.s[i] == '\n' {
+			p.line++
+		}
+		i++
+	}
+	p.offset += i
+	p.s = p.s[i:len(p.s)]
+	if len(p.s) == 0 {
+		p.done = true
+	}
+}
+
+func (p *textParser) advance() {
+	// Skip whitespace
+	p.skipWhitespace()
+	if p.done {
+		return
+	}
+
+	// Start of non-whitespace
+	p.cur.err = nil
+	p.cur.offset, p.cur.line = p.offset, p.line
+	p.cur.unquoted = ""
+	switch p.s[0] {
+	case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/':
+		// Single symbol
+		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
+	case '"', '\'':
+		// Quoted string
+		i := 1
+		for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' {
+			if p.s[i] == '\\' && i+1 < len(p.s) {
+				// skip escaped char
+				i++
+			}
+			i++
+		}
+		if i >= len(p.s) || p.s[i] != p.s[0] {
+			p.errorf("unmatched quote")
+			return
+		}
+		unq, err := unquoteC(p.s[1:i], rune(p.s[0]))
+		if err != nil {
+			p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err)
+			return
+		}
+		p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)]
+		p.cur.unquoted = unq
+	default:
+		i := 0
+		for i < len(p.s) && isIdentOrNumberChar(p.s[i]) {
+			i++
+		}
+		if i == 0 {
+			p.errorf("unexpected byte %#x", p.s[0])
+			return
+		}
+		p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)]
+	}
+	p.offset += len(p.cur.value)
+}
+
+var (
+	errBadUTF8 = errors.New("proto: bad UTF-8")
+	errBadHex  = errors.New("proto: bad hexadecimal")
+)
+
+func unquoteC(s string, quote rune) (string, error) {
+	// This is based on C++'s tokenizer.cc.
+	// Despite its name, this is *not* parsing C syntax.
+	// For instance, "\0" is an invalid quoted string.
+
+	// Avoid allocation in trivial cases.
+	simple := true
+	for _, r := range s {
+		if r == '\\' || r == quote {
+			simple = false
+			break
+		}
+	}
+	if simple {
+		return s, nil
+	}
+
+	buf := make([]byte, 0, 3*len(s)/2)
+	for len(s) > 0 {
+		r, n := utf8.DecodeRuneInString(s)
+		if r == utf8.RuneError && n == 1 {
+			return "", errBadUTF8
+		}
+		s = s[n:]
+		if r != '\\' {
+			if r < utf8.RuneSelf {
+				buf = append(buf, byte(r))
+			} else {
+				buf = append(buf, string(r)...)
+			}
+			continue
+		}
+
+		ch, tail, err := unescape(s)
+		if err != nil {
+			return "", err
+		}
+		buf = append(buf, ch...)
+		s = tail
+	}
+	return string(buf), nil
+}
+
+func unescape(s string) (ch string, tail string, err error) {
+	r, n := utf8.DecodeRuneInString(s)
+	if r == utf8.RuneError && n == 1 {
+		return "", "", errBadUTF8
+	}
+	s = s[n:]
+	switch r {
+	case 'a':
+		return "\a", s, nil
+	case 'b':
+		return "\b", s, nil
+	case 'f':
+		return "\f", s, nil
+	case 'n':
+		return "\n", s, nil
+	case 'r':
+		return "\r", s, nil
+	case 't':
+		return "\t", s, nil
+	case 'v':
+		return "\v", s, nil
+	case '?':
+		return "?", s, nil // trigraph workaround
+	case '\'', '"', '\\':
+		return string(r), s, nil
+	case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X':
+		if len(s) < 2 {
+			return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)
+		}
+		base := 8
+		ss := s[:2]
+		s = s[2:]
+		if r == 'x' || r == 'X' {
+			base = 16
+		} else {
+			ss = string(r) + ss
+		}
+		i, err := strconv.ParseUint(ss, base, 8)
+		if err != nil {
+			return "", "", err
+		}
+		return string([]byte{byte(i)}), s, nil
+	case 'u', 'U':
+		n := 4
+		if r == 'U' {
+			n = 8
+		}
+		if len(s) < n {
+			return "", "", fmt.Errorf(`\%c requires %d digits`, r, n)
+		}
+
+		bs := make([]byte, n/2)
+		for i := 0; i < n; i += 2 {
+			a, ok1 := unhex(s[i])
+			b, ok2 := unhex(s[i+1])
+			if !ok1 || !ok2 {
+				return "", "", errBadHex
+			}
+			bs[i/2] = a<<4 | b
+		}
+		s = s[n:]
+		return string(bs), s, nil
+	}
+	return "", "", fmt.Errorf(`unknown escape \%c`, r)
+}
+
+// Adapted from src/pkg/strconv/quote.go.
+func unhex(b byte) (v byte, ok bool) {
+	switch {
+	case '0' <= b && b <= '9':
+		return b - '0', true
+	case 'a' <= b && b <= 'f':
+		return b - 'a' + 10, true
+	case 'A' <= b && b <= 'F':
+		return b - 'A' + 10, true
+	}
+	return 0, false
+}
+
+// Back off the parser by one token. Can only be done between calls to next().
+// It makes the next advance() a no-op.
+func (p *textParser) back() { p.backed = true }
+
+// Advances the parser and returns the new current token.
+func (p *textParser) next() *token {
+	if p.backed || p.done {
+		p.backed = false
+		return &p.cur
+	}
+	p.advance()
+	if p.done {
+		p.cur.value = ""
+	} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) {
+		// Look for multiple quoted strings separated by whitespace,
+		// and concatenate them.
+		cat := p.cur
+		for {
+			p.skipWhitespace()
+			if p.done || !isQuote(p.s[0]) {
+				break
+			}
+			p.advance()
+			if p.cur.err != nil {
+				return &p.cur
+			}
+			cat.value += " " + p.cur.value
+			cat.unquoted += p.cur.unquoted
+		}
+		p.done = false // parser may have seen EOF, but we want to return cat
+		p.cur = cat
+	}
+	return &p.cur
+}
+
+func (p *textParser) consumeToken(s string) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != s {
+		p.back()
+		return p.errorf("expected %q, found %q", s, tok.value)
+	}
+	return nil
+}
+
+// Return a RequiredNotSetError indicating which required field was not set.
+func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError {
+	st := sv.Type()
+	sprops := GetProperties(st)
+	for i := 0; i < st.NumField(); i++ {
+		if !isNil(sv.Field(i)) {
+			continue
+		}
+
+		props := sprops.Prop[i]
+		if props.Required {
+			return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)}
+		}
+	}
+	return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
+}
+
+// Returns the index in the struct for the named field, as well as the parsed tag properties.
+func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) {
+	i, ok := sprops.decoderOrigNames[name]
+	if ok {
+		return i, sprops.Prop[i], true
+	}
+	return -1, nil, false
+}
+
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ":" {
+		// Colon is optional when the field is a group or message.
+		needColon := true
+		switch props.Wire {
+		case "group":
+			needColon = false
+		case "bytes":
+			// A "bytes" field is either a message, a string, or a repeated field;
+			// those three become *T, *string and []T respectively, so we can check for
+			// this field being a pointer to a non-string.
+			if typ.Kind() == reflect.Ptr {
+				// *T or *string
+				if typ.Elem().Kind() == reflect.String {
+					break
+				}
+			} else if typ.Kind() == reflect.Slice {
+				// []T or []*T
+				if typ.Elem().Kind() != reflect.Ptr {
+					break
+				}
+			} else if typ.Kind() == reflect.String {
+				// The proto3 exception is for a string field,
+				// which requires a colon.
+				break
+			}
+			needColon = false
+		}
+		if needColon {
+			return p.errorf("expected ':', found %q", tok.value)
+		}
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) readStruct(sv reflect.Value, terminator string) error {
+	st := sv.Type()
+	sprops := GetProperties(st)
+	reqCount := sprops.reqCount
+	var reqFieldErr error
+	fieldSet := make(map[string]bool)
+	// A struct is a sequence of "name: value", terminated by one of
+	// '>' or '}', or the end of the input.  A name may also be
+	// "[extension]" or "[type/url]".
+	//
+	// The whole struct can also be an expanded Any message, like:
+	// [type/url] < ... struct contents ... >
+	for {
+		tok := p.next()
+		if tok.err != nil {
+			return tok.err
+		}
+		if tok.value == terminator {
+			break
+		}
+		if tok.value == "[" {
+			// Looks like an extension or an Any.
+			//
+			// TODO: Check whether we need to handle
+			// namespace rooted names (e.g. ".something.Foo").
+			extName, err := p.consumeExtName()
+			if err != nil {
+				return err
+			}
+
+			if s := strings.LastIndex(extName, "/"); s >= 0 {
+				// If it contains a slash, it's an Any type URL.
+				messageName := extName[s+1:]
+				mt := MessageType(messageName)
+				if mt == nil {
+					return p.errorf("unrecognized message %q in google.protobuf.Any", messageName)
+				}
+				tok = p.next()
+				if tok.err != nil {
+					return tok.err
+				}
+				// consume an optional colon
+				if tok.value == ":" {
+					tok = p.next()
+					if tok.err != nil {
+						return tok.err
+					}
+				}
+				var terminator string
+				switch tok.value {
+				case "<":
+					terminator = ">"
+				case "{":
+					terminator = "}"
+				default:
+					return p.errorf("expected '{' or '<', found %q", tok.value)
+				}
+				v := reflect.New(mt.Elem())
+				if pe := p.readStruct(v.Elem(), terminator); pe != nil {
+					return pe
+				}
+				b, err := Marshal(v.Interface().(Message))
+				if err != nil {
+					return p.errorf("failed to marshal message of type %q: %v", messageName, err)
+				}
+				if fieldSet["type_url"] {
+					return p.errorf(anyRepeatedlyUnpacked, "type_url")
+				}
+				if fieldSet["value"] {
+					return p.errorf(anyRepeatedlyUnpacked, "value")
+				}
+				sv.FieldByName("TypeUrl").SetString(extName)
+				sv.FieldByName("Value").SetBytes(b)
+				fieldSet["type_url"] = true
+				fieldSet["value"] = true
+				continue
+			}
+
+			var desc *ExtensionDesc
+			// This could be faster, but it's functional.
+			// TODO: Do something smarter than a linear scan.
+			for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) {
+				if d.Name == extName {
+					desc = d
+					break
+				}
+			}
+			if desc == nil {
+				return p.errorf("unrecognized extension %q", extName)
+			}
+
+			props := &Properties{}
+			props.Parse(desc.Tag)
+
+			typ := reflect.TypeOf(desc.ExtensionType)
+			if err := p.checkForColon(props, typ); err != nil {
+				return err
+			}
+
+			rep := desc.repeated()
+
+			// Read the extension structure, and set it in
+			// the value we're constructing.
+			var ext reflect.Value
+			if !rep {
+				ext = reflect.New(typ).Elem()
+			} else {
+				ext = reflect.New(typ.Elem()).Elem()
+			}
+			if err := p.readAny(ext, props); err != nil {
+				if _, ok := err.(*RequiredNotSetError); !ok {
+					return err
+				}
+				reqFieldErr = err
+			}
+			ep := sv.Addr().Interface().(Message)
+			if !rep {
+				SetExtension(ep, desc, ext.Interface())
+			} else {
+				old, err := GetExtension(ep, desc)
+				var sl reflect.Value
+				if err == nil {
+					sl = reflect.ValueOf(old) // existing slice
+				} else {
+					sl = reflect.MakeSlice(typ, 0, 1)
+				}
+				sl = reflect.Append(sl, ext)
+				SetExtension(ep, desc, sl.Interface())
+			}
+			if err := p.consumeOptionalSeparator(); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// This is a normal, non-extension field.
+		name := tok.value
+		var dst reflect.Value
+		fi, props, ok := structFieldByName(sprops, name)
+		if ok {
+			dst = sv.Field(fi)
+		} else if oop, ok := sprops.OneofTypes[name]; ok {
+			// It is a oneof.
+			props = oop.Prop
+			nv := reflect.New(oop.Type.Elem())
+			dst = nv.Elem().Field(0)
+			field := sv.Field(oop.Field)
+			if !field.IsNil() {
+				return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name)
+			}
+			field.Set(nv)
+		}
+		if !dst.IsValid() {
+			return p.errorf("unknown field name %q in %v", name, st)
+		}
+
+		if dst.Kind() == reflect.Map {
+			// Consume any colon.
+			if err := p.checkForColon(props, dst.Type()); err != nil {
+				return err
+			}
+
+			// Construct the map if it doesn't already exist.
+			if dst.IsNil() {
+				dst.Set(reflect.MakeMap(dst.Type()))
+			}
+			key := reflect.New(dst.Type().Key()).Elem()
+			val := reflect.New(dst.Type().Elem()).Elem()
+
+			// The map entry should be this sequence of tokens:
+			//	< key : KEY value : VALUE >
+			// However, implementations may omit key or value, and technically
+			// we should support them in any order.  See b/28924776 for a time
+			// this went wrong.
+
+			tok := p.next()
+			var terminator string
+			switch tok.value {
+			case "<":
+				terminator = ">"
+			case "{":
+				terminator = "}"
+			default:
+				return p.errorf("expected '{' or '<', found %q", tok.value)
+			}
+			for {
+				tok := p.next()
+				if tok.err != nil {
+					return tok.err
+				}
+				if tok.value == terminator {
+					break
+				}
+				switch tok.value {
+				case "key":
+					if err := p.consumeToken(":"); err != nil {
+						return err
+					}
+					if err := p.readAny(key, props.mkeyprop); err != nil {
+						return err
+					}
+					if err := p.consumeOptionalSeparator(); err != nil {
+						return err
+					}
+				case "value":
+					if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {
+						return err
+					}
+					if err := p.readAny(val, props.mvalprop); err != nil {
+						return err
+					}
+					if err := p.consumeOptionalSeparator(); err != nil {
+						return err
+					}
+				default:
+					p.back()
+					return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value)
+				}
+			}
+
+			dst.SetMapIndex(key, val)
+			continue
+		}
+
+		// Check that it's not already set if it's not a repeated field.
+		if !props.Repeated && fieldSet[name] {
+			return p.errorf("non-repeated field %q was repeated", name)
+		}
+
+		if err := p.checkForColon(props, dst.Type()); err != nil {
+			return err
+		}
+
+		// Parse into the field.
+		fieldSet[name] = true
+		if err := p.readAny(dst, props); err != nil {
+			if _, ok := err.(*RequiredNotSetError); !ok {
+				return err
+			}
+			reqFieldErr = err
+		}
+		if props.Required {
+			reqCount--
+		}
+
+		if err := p.consumeOptionalSeparator(); err != nil {
+			return err
+		}
+
+	}
+
+	if reqCount > 0 {
+		return p.missingRequiredFieldError(sv)
+	}
+	return reqFieldErr
+}
+
+// consumeExtName consumes extension name or expanded Any type URL and the
+// following ']'. It returns the name or URL consumed.
+func (p *textParser) consumeExtName() (string, error) {
+	tok := p.next()
+	if tok.err != nil {
+		return "", tok.err
+	}
+
+	// If extension name or type url is quoted, it's a single token.
+	if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] {
+		name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0]))
+		if err != nil {
+			return "", err
+		}
+		return name, p.consumeToken("]")
+	}
+
+	// Consume everything up to "]"
+	var parts []string
+	for tok.value != "]" {
+		parts = append(parts, tok.value)
+		tok = p.next()
+		if tok.err != nil {
+			return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)
+		}
+	}
+	return strings.Join(parts, ""), nil
+}
+
+// consumeOptionalSeparator consumes an optional semicolon or comma.
+// It is used in readStruct to provide backward compatibility.
+func (p *textParser) consumeOptionalSeparator() error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ";" && tok.value != "," {
+		p.back()
+	}
+	return nil
+}
+
+func (p *textParser) readAny(v reflect.Value, props *Properties) error {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value == "" {
+		return p.errorf("unexpected EOF")
+	}
+	if len(props.CustomType) > 0 {
+		if props.Repeated {
+			t := reflect.TypeOf(v.Interface())
+			if t.Kind() == reflect.Slice {
+				tc := reflect.TypeOf(new(Marshaler))
+				ok := t.Elem().Implements(tc.Elem())
+				if ok {
+					fv := v
+					flen := fv.Len()
+					if flen == fv.Cap() {
+						nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1)
+						reflect.Copy(nav, fv)
+						fv.Set(nav)
+					}
+					fv.SetLen(flen + 1)
+
+					// Read one.
+					p.back()
+					return p.readAny(fv.Index(flen), props)
+				}
+			}
+		}
+		if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+			custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler)
+			err := custom.Unmarshal([]byte(tok.unquoted))
+			if err != nil {
+				return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+			}
+			v.Set(reflect.ValueOf(custom))
+		} else {
+			custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler)
+			err := custom.Unmarshal([]byte(tok.unquoted))
+			if err != nil {
+				return p.errorf("%v %v: %v", err, v.Type(), tok.value)
+			}
+			v.Set(reflect.Indirect(reflect.ValueOf(custom)))
+		}
+		return nil
+	}
+	if props.StdTime {
+		fv := v
+		p.back()
+		props.StdTime = false
+		tproto := &timestamp{}
+		err := p.readAny(reflect.ValueOf(tproto).Elem(), props)
+		props.StdTime = true
+		if err != nil {
+			return err
+		}
+		tim, err := timestampFromProto(tproto)
+		if err != nil {
+			return err
+		}
+		if props.Repeated {
+			t := reflect.TypeOf(v.Interface())
+			if t.Kind() == reflect.Slice {
+				if t.Elem().Kind() == reflect.Ptr {
+					ts := fv.Interface().([]*time.Time)
+					ts = append(ts, &tim)
+					fv.Set(reflect.ValueOf(ts))
+					return nil
+				} else {
+					ts := fv.Interface().([]time.Time)
+					ts = append(ts, tim)
+					fv.Set(reflect.ValueOf(ts))
+					return nil
+				}
+			}
+		}
+		if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+			v.Set(reflect.ValueOf(&tim))
+		} else {
+			v.Set(reflect.Indirect(reflect.ValueOf(&tim)))
+		}
+		return nil
+	}
+	if props.StdDuration {
+		fv := v
+		p.back()
+		props.StdDuration = false
+		dproto := &duration{}
+		err := p.readAny(reflect.ValueOf(dproto).Elem(), props)
+		props.StdDuration = true
+		if err != nil {
+			return err
+		}
+		dur, err := durationFromProto(dproto)
+		if err != nil {
+			return err
+		}
+		if props.Repeated {
+			t := reflect.TypeOf(v.Interface())
+			if t.Kind() == reflect.Slice {
+				if t.Elem().Kind() == reflect.Ptr {
+					ds := fv.Interface().([]*time.Duration)
+					ds = append(ds, &dur)
+					fv.Set(reflect.ValueOf(ds))
+					return nil
+				} else {
+					ds := fv.Interface().([]time.Duration)
+					ds = append(ds, dur)
+					fv.Set(reflect.ValueOf(ds))
+					return nil
+				}
+			}
+		}
+		if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr {
+			v.Set(reflect.ValueOf(&dur))
+		} else {
+			v.Set(reflect.Indirect(reflect.ValueOf(&dur)))
+		}
+		return nil
+	}
+	switch fv := v; fv.Kind() {
+	case reflect.Slice:
+		at := v.Type()
+		if at.Elem().Kind() == reflect.Uint8 {
+			// Special case for []byte
+			if tok.value[0] != '"' && tok.value[0] != '\'' {
+				// Deliberately written out here, as the error after
+				// this switch statement would write "invalid []byte: ...",
+				// which is not as user-friendly.
+				return p.errorf("invalid string: %v", tok.value)
+			}
+			bytes := []byte(tok.unquoted)
+			fv.Set(reflect.ValueOf(bytes))
+			return nil
+		}
+		// Repeated field.
+		if tok.value == "[" {
+			// Repeated field with list notation, like [1,2,3].
+			for {
+				fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+				err := p.readAny(fv.Index(fv.Len()-1), props)
+				if err != nil {
+					return err
+				}
+				ntok := p.next()
+				if ntok.err != nil {
+					return ntok.err
+				}
+				if ntok.value == "]" {
+					break
+				}
+				if ntok.value != "," {
+					return p.errorf("Expected ']' or ',' found %q", ntok.value)
+				}
+			}
+			return nil
+		}
+		// One value of the repeated field.
+		p.back()
+		fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem()))
+		return p.readAny(fv.Index(fv.Len()-1), props)
+	case reflect.Bool:
+		// true/1/t/True or false/f/0/False.
+		switch tok.value {
+		case "true", "1", "t", "True":
+			fv.SetBool(true)
+			return nil
+		case "false", "0", "f", "False":
+			fv.SetBool(false)
+			return nil
+		}
+	case reflect.Float32, reflect.Float64:
+		v := tok.value
+		// Ignore 'f' for compatibility with output generated by C++, but don't
+		// remove 'f' when the value is "-inf" or "inf".
+		if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" {
+			v = v[:len(v)-1]
+		}
+		if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil {
+			fv.SetFloat(f)
+			return nil
+		}
+	case reflect.Int32:
+		if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+		if len(props.Enum) == 0 {
+			break
+		}
+		m, ok := enumValueMaps[props.Enum]
+		if !ok {
+			break
+		}
+		x, ok := m[tok.value]
+		if !ok {
+			break
+		}
+		fv.SetInt(int64(x))
+		return nil
+	case reflect.Int64:
+		if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil {
+			fv.SetInt(x)
+			return nil
+		}
+
+	case reflect.Ptr:
+		// A basic field (indirected through pointer), or a repeated message/group
+		p.back()
+		fv.Set(reflect.New(fv.Type().Elem()))
+		return p.readAny(fv.Elem(), props)
+	case reflect.String:
+		if tok.value[0] == '"' || tok.value[0] == '\'' {
+			fv.SetString(tok.unquoted)
+			return nil
+		}
+	case reflect.Struct:
+		var terminator string
+		switch tok.value {
+		case "{":
+			terminator = "}"
+		case "<":
+			terminator = ">"
+		default:
+			return p.errorf("expected '{' or '<', found %q", tok.value)
+		}
+		// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
+		return p.readStruct(fv, terminator)
+	case reflect.Uint32:
+		if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {
+			fv.SetUint(x)
+			return nil
+		}
+	case reflect.Uint64:
+		if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil {
+			fv.SetUint(x)
+			return nil
+		}
+	}
+	return p.errorf("invalid %v: %v", v.Type(), tok.value)
+}
+
+// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
+// before starting to unmarshal, so any existing data in pb is always removed.
+// If a required field is not set and no other error occurs,
+// UnmarshalText returns *RequiredNotSetError.
+func UnmarshalText(s string, pb Message) error {
+	if um, ok := pb.(encoding.TextUnmarshaler); ok {
+		err := um.UnmarshalText([]byte(s))
+		return err
+	}
+	pb.Reset()
+	v := reflect.ValueOf(pb)
+	if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil {
+		return pe
+	}
+	return nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/timestamp.go b/vendor/github.com/gogo/protobuf/proto/timestamp.go
new file mode 100644
index 000000000..9324f6542
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/timestamp.go
@@ -0,0 +1,113 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+// This file implements operations on google.protobuf.Timestamp.
+
+import (
+	"errors"
+	"fmt"
+	"time"
+)
+
+const (
+	// Seconds field of the earliest valid Timestamp.
+	// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+	minValidSeconds = -62135596800
+	// Seconds field just after the latest valid Timestamp.
+	// This is time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+	maxValidSeconds = 253402300800
+)
+
+// validateTimestamp determines whether a Timestamp is valid.
+// A valid timestamp represents a time in the range
+// [0001-01-01, 10000-01-01) and has a Nanos field
+// in the range [0, 1e9).
+//
+// If the Timestamp is valid, validateTimestamp returns nil.
+// Otherwise, it returns an error that describes
+// the problem.
+//
+// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
+func validateTimestamp(ts *timestamp) error {
+	if ts == nil {
+		return errors.New("timestamp: nil Timestamp")
+	}
+	if ts.Seconds < minValidSeconds {
+		return fmt.Errorf("timestamp: %#v before 0001-01-01", ts)
+	}
+	if ts.Seconds >= maxValidSeconds {
+		return fmt.Errorf("timestamp: %#v after 10000-01-01", ts)
+	}
+	if ts.Nanos < 0 || ts.Nanos >= 1e9 {
+		return fmt.Errorf("timestamp: %#v: nanos not in range [0, 1e9)", ts)
+	}
+	return nil
+}
+
+// TimestampFromProto converts a google.protobuf.Timestamp proto to a time.Time.
+// It returns an error if the argument is invalid.
+//
+// Unlike most Go functions, if Timestamp returns an error, the first return value
+// is not the zero time.Time. Instead, it is the value obtained from the
+// time.Unix function when passed the contents of the Timestamp, in the UTC
+// locale. This may or may not be a meaningful time; many invalid Timestamps
+// do map to valid time.Times.
+//
+// A nil Timestamp returns an error. The first return value in that case is
+// undefined.
+func timestampFromProto(ts *timestamp) (time.Time, error) {
+	// Don't return the zero value on error, because corresponds to a valid
+	// timestamp. Instead return whatever time.Unix gives us.
+	var t time.Time
+	if ts == nil {
+		t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
+	} else {
+		t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
+	}
+	return t, validateTimestamp(ts)
+}
+
+// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
+// It returns an error if the resulting Timestamp is invalid.
+func timestampProto(t time.Time) (*timestamp, error) {
+	seconds := t.Unix()
+	nanos := int32(t.Sub(time.Unix(seconds, 0)))
+	ts := &timestamp{
+		Seconds: seconds,
+		Nanos:   nanos,
+	}
+	if err := validateTimestamp(ts); err != nil {
+		return nil, err
+	}
+	return ts, nil
+}
diff --git a/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go b/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go
new file mode 100644
index 000000000..d42764743
--- /dev/null
+++ b/vendor/github.com/gogo/protobuf/proto/timestamp_gogo.go
@@ -0,0 +1,229 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2016, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package proto
+
+import (
+	"reflect"
+	"time"
+)
+
+var timeType = reflect.TypeOf((*time.Time)(nil)).Elem()
+
+type timestamp struct {
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	Nanos   int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+}
+
+func (m *timestamp) Reset()       { *m = timestamp{} }
+func (*timestamp) ProtoMessage()  {}
+func (*timestamp) String() string { return "timestamp<string>" }
+
+func init() {
+	RegisterType((*timestamp)(nil), "gogo.protobuf.proto.timestamp")
+}
+
+func (o *Buffer) decTimestamp() (time.Time, error) {
+	b, err := o.DecodeRawBytes(true)
+	if err != nil {
+		return time.Time{}, err
+	}
+	tproto := &timestamp{}
+	if err := Unmarshal(b, tproto); err != nil {
+		return time.Time{}, err
+	}
+	return timestampFromProto(tproto)
+}
+
+func (o *Buffer) dec_time(p *Properties, base structPointer) error {
+	t, err := o.decTimestamp()
+	if err != nil {
+		return err
+	}
+	setPtrCustomType(base, p.field, &t)
+	return nil
+}
+
+func (o *Buffer) dec_ref_time(p *Properties, base structPointer) error {
+	t, err := o.decTimestamp()
+	if err != nil {
+		return err
+	}
+	setCustomType(base, p.field, &t)
+	return nil
+}
+
+func (o *Buffer) dec_slice_time(p *Properties, base structPointer) error {
+	t, err := o.decTimestamp()
+	if err != nil {
+		return err
+	}
+	newBas := appendStructPointer(base, p.field, reflect.SliceOf(reflect.PtrTo(timeType)))
+	var zero field
+	setPtrCustomType(newBas, zero, &t)
+	return nil
+}
+
+func (o *Buffer) dec_slice_ref_time(p *Properties, base structPointer) error {
+	t, err := o.decTimestamp()
+	if err != nil {
+		return err
+	}
+	newBas := appendStructPointer(base, p.field, reflect.SliceOf(timeType))
+	var zero field
+	setCustomType(newBas, zero, &t)
+	return nil
+}
+
+func size_time(p *Properties, base structPointer) (n int) {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return 0
+	}
+	tim := structPointer_Interface(structp, timeType).(*time.Time)
+	t, err := timestampProto(*tim)
+	if err != nil {
+		return 0
+	}
+	size := Size(t)
+	return size + sizeVarint(uint64(size)) + len(p.tagcode)
+}
+
+func (o *Buffer) enc_time(p *Properties, base structPointer) error {
+	structp := structPointer_GetStructPointer(base, p.field)
+	if structPointer_IsNil(structp) {
+		return ErrNil
+	}
+	tim := structPointer_Interface(structp, timeType).(*time.Time)
+	t, err := timestampProto(*tim)
+	if err != nil {
+		return err
+	}
+	data, err := Marshal(t)
+	if err != nil {
+		return err
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_ref_time(p *Properties, base structPointer) (n int) {
+	tim := structPointer_InterfaceAt(base, p.field, timeType).(*time.Time)
+	t, err := timestampProto(*tim)
+	if err != nil {
+		return 0
+	}
+	size := Size(t)
+	return size + sizeVarint(uint64(size)) + len(p.tagcode)
+}
+
+func (o *Buffer) enc_ref_time(p *Properties, base structPointer) error {
+	tim := structPointer_InterfaceAt(base, p.field, timeType).(*time.Time)
+	t, err := timestampProto(*tim)
+	if err != nil {
+		return err
+	}
+	data, err := Marshal(t)
+	if err != nil {
+		return err
+	}
+	o.buf = append(o.buf, p.tagcode...)
+	o.EncodeRawBytes(data)
+	return nil
+}
+
+func size_slice_time(p *Properties, base structPointer) (n int) {
+	ptims := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(reflect.PtrTo(timeType))).(*[]*time.Time)
+	tims := *ptims
+	for i := 0; i < len(tims); i++ {
+		if tims[i] == nil {
+			return 0
+		}
+		tproto, err := timestampProto(*tims[i])
+		if err != nil {
+			return 0
+		}
+		size := Size(tproto)
+		n += len(p.tagcode) + size + sizeVarint(uint64(size))
+	}
+	return n
+}
+
+func (o *Buffer) enc_slice_time(p *Properties, base structPointer) error {
+	ptims := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(reflect.PtrTo(timeType))).(*[]*time.Time)
+	tims := *ptims
+	for i := 0; i < len(tims); i++ {
+		if tims[i] == nil {
+			return errRepeatedHasNil
+		}
+		tproto, err := timestampProto(*tims[i])
+		if err != nil {
+			return err
+		}
+		data, err := Marshal(tproto)
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
+
+func size_slice_ref_time(p *Properties, base structPointer) (n int) {
+	ptims := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(timeType)).(*[]time.Time)
+	tims := *ptims
+	for i := 0; i < len(tims); i++ {
+		tproto, err := timestampProto(tims[i])
+		if err != nil {
+			return 0
+		}
+		size := Size(tproto)
+		n += len(p.tagcode) + size + sizeVarint(uint64(size))
+	}
+	return n
+}
+
+func (o *Buffer) enc_slice_ref_time(p *Properties, base structPointer) error {
+	ptims := structPointer_InterfaceAt(base, p.field, reflect.SliceOf(timeType)).(*[]time.Time)
+	tims := *ptims
+	for i := 0; i < len(tims); i++ {
+		tproto, err := timestampProto(tims[i])
+		if err != nil {
+			return err
+		}
+		data, err := Marshal(tproto)
+		if err != nil {
+			return err
+		}
+		o.buf = append(o.buf, p.tagcode...)
+		o.EncodeRawBytes(data)
+	}
+	return nil
+}
diff --git a/vendor/github.com/gorilla/websocket/AUTHORS b/vendor/github.com/gorilla/websocket/AUTHORS
new file mode 100644
index 000000000..b003eca0c
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/AUTHORS
@@ -0,0 +1,8 @@
+# This is the official list of Gorilla WebSocket authors for copyright
+# purposes.
+#
+# Please keep the list sorted.
+
+Gary Burd <gary@beagledreams.com>
+Joachim Bauch <mail@joachim-bauch.de>
+
diff --git a/vendor/github.com/gorilla/websocket/LICENSE b/vendor/github.com/gorilla/websocket/LICENSE
new file mode 100644
index 000000000..9171c9722
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2013 The Gorilla WebSocket Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/gorilla/websocket/client.go b/vendor/github.com/gorilla/websocket/client.go
new file mode 100644
index 000000000..43a87c753
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client.go
@@ -0,0 +1,392 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"encoding/base64"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// ErrBadHandshake is returned when the server response to opening handshake is
+// invalid.
+var ErrBadHandshake = errors.New("websocket: bad handshake")
+
+var errInvalidCompression = errors.New("websocket: invalid compression negotiation")
+
+// NewClient creates a new client connection using the given net connection.
+// The URL u specifies the host and request URI. Use requestHeader to specify
+// the origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies
+// (Cookie). Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etc.
+//
+// Deprecated: Use Dialer instead.
+func NewClient(netConn net.Conn, u *url.URL, requestHeader http.Header, readBufSize, writeBufSize int) (c *Conn, response *http.Response, err error) {
+	d := Dialer{
+		ReadBufferSize:  readBufSize,
+		WriteBufferSize: writeBufSize,
+		NetDial: func(net, addr string) (net.Conn, error) {
+			return netConn, nil
+		},
+	}
+	return d.Dial(u.String(), requestHeader)
+}
+
+// A Dialer contains options for connecting to WebSocket server.
+type Dialer struct {
+	// NetDial specifies the dial function for creating TCP connections. If
+	// NetDial is nil, net.Dial is used.
+	NetDial func(network, addr string) (net.Conn, error)
+
+	// Proxy specifies a function to return a proxy for a given
+	// Request. If the function returns a non-nil error, the
+	// request is aborted with the provided error.
+	// If Proxy is nil or returns a nil *URL, no proxy is used.
+	Proxy func(*http.Request) (*url.URL, error)
+
+	// TLSClientConfig specifies the TLS configuration to use with tls.Client.
+	// If nil, the default configuration is used.
+	TLSClientConfig *tls.Config
+
+	// HandshakeTimeout specifies the duration for the handshake to complete.
+	HandshakeTimeout time.Duration
+
+	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
+	// size is zero, then a useful default size is used. The I/O buffer sizes
+	// do not limit the size of the messages that can be sent or received.
+	ReadBufferSize, WriteBufferSize int
+
+	// Subprotocols specifies the client's requested subprotocols.
+	Subprotocols []string
+
+	// EnableCompression specifies if the client should attempt to negotiate
+	// per message compression (RFC 7692). Setting this value to true does not
+	// guarantee that compression will be supported. Currently only "no context
+	// takeover" modes are supported.
+	EnableCompression bool
+
+	// Jar specifies the cookie jar.
+	// If Jar is nil, cookies are not sent in requests and ignored
+	// in responses.
+	Jar http.CookieJar
+}
+
+var errMalformedURL = errors.New("malformed ws or wss URL")
+
+// parseURL parses the URL.
+//
+// This function is a replacement for the standard library url.Parse function.
+// In Go 1.4 and earlier, url.Parse loses information from the path.
+func parseURL(s string) (*url.URL, error) {
+	// From the RFC:
+	//
+	// ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
+	// wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]
+	var u url.URL
+	switch {
+	case strings.HasPrefix(s, "ws://"):
+		u.Scheme = "ws"
+		s = s[len("ws://"):]
+	case strings.HasPrefix(s, "wss://"):
+		u.Scheme = "wss"
+		s = s[len("wss://"):]
+	default:
+		return nil, errMalformedURL
+	}
+
+	if i := strings.Index(s, "?"); i >= 0 {
+		u.RawQuery = s[i+1:]
+		s = s[:i]
+	}
+
+	if i := strings.Index(s, "/"); i >= 0 {
+		u.Opaque = s[i:]
+		s = s[:i]
+	} else {
+		u.Opaque = "/"
+	}
+
+	u.Host = s
+
+	if strings.Contains(u.Host, "@") {
+		// Don't bother parsing user information because user information is
+		// not allowed in websocket URIs.
+		return nil, errMalformedURL
+	}
+
+	return &u, nil
+}
+
+func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
+	hostPort = u.Host
+	hostNoPort = u.Host
+	if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
+		hostNoPort = hostNoPort[:i]
+	} else {
+		switch u.Scheme {
+		case "wss":
+			hostPort += ":443"
+		case "https":
+			hostPort += ":443"
+		default:
+			hostPort += ":80"
+		}
+	}
+	return hostPort, hostNoPort
+}
+
+// DefaultDialer is a dialer with all fields set to the default zero values.
+var DefaultDialer = &Dialer{
+	Proxy: http.ProxyFromEnvironment,
+}
+
+// Dial creates a new client connection. Use requestHeader to specify the
+// origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
+// Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etcetera. The response body may not contain the entire response and does not
+// need to be closed by the application.
+func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+
+	if d == nil {
+		d = &Dialer{
+			Proxy: http.ProxyFromEnvironment,
+		}
+	}
+
+	challengeKey, err := generateChallengeKey()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	u, err := parseURL(urlStr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	switch u.Scheme {
+	case "ws":
+		u.Scheme = "http"
+	case "wss":
+		u.Scheme = "https"
+	default:
+		return nil, nil, errMalformedURL
+	}
+
+	if u.User != nil {
+		// User name and password are not allowed in websocket URIs.
+		return nil, nil, errMalformedURL
+	}
+
+	req := &http.Request{
+		Method:     "GET",
+		URL:        u,
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header:     make(http.Header),
+		Host:       u.Host,
+	}
+
+	// Set the cookies present in the cookie jar of the dialer
+	if d.Jar != nil {
+		for _, cookie := range d.Jar.Cookies(u) {
+			req.AddCookie(cookie)
+		}
+	}
+
+	// Set the request headers using the capitalization for names and values in
+	// RFC examples. Although the capitalization shouldn't matter, there are
+	// servers that depend on it. The Header.Set method is not used because the
+	// method canonicalizes the header names.
+	req.Header["Upgrade"] = []string{"websocket"}
+	req.Header["Connection"] = []string{"Upgrade"}
+	req.Header["Sec-WebSocket-Key"] = []string{challengeKey}
+	req.Header["Sec-WebSocket-Version"] = []string{"13"}
+	if len(d.Subprotocols) > 0 {
+		req.Header["Sec-WebSocket-Protocol"] = []string{strings.Join(d.Subprotocols, ", ")}
+	}
+	for k, vs := range requestHeader {
+		switch {
+		case k == "Host":
+			if len(vs) > 0 {
+				req.Host = vs[0]
+			}
+		case k == "Upgrade" ||
+			k == "Connection" ||
+			k == "Sec-Websocket-Key" ||
+			k == "Sec-Websocket-Version" ||
+			k == "Sec-Websocket-Extensions" ||
+			(k == "Sec-Websocket-Protocol" && len(d.Subprotocols) > 0):
+			return nil, nil, errors.New("websocket: duplicate header not allowed: " + k)
+		default:
+			req.Header[k] = vs
+		}
+	}
+
+	if d.EnableCompression {
+		req.Header.Set("Sec-Websocket-Extensions", "permessage-deflate; server_no_context_takeover; client_no_context_takeover")
+	}
+
+	hostPort, hostNoPort := hostPortNoPort(u)
+
+	var proxyURL *url.URL
+	// Check wether the proxy method has been configured
+	if d.Proxy != nil {
+		proxyURL, err = d.Proxy(req)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var targetHostPort string
+	if proxyURL != nil {
+		targetHostPort, _ = hostPortNoPort(proxyURL)
+	} else {
+		targetHostPort = hostPort
+	}
+
+	var deadline time.Time
+	if d.HandshakeTimeout != 0 {
+		deadline = time.Now().Add(d.HandshakeTimeout)
+	}
+
+	netDial := d.NetDial
+	if netDial == nil {
+		netDialer := &net.Dialer{Deadline: deadline}
+		netDial = netDialer.Dial
+	}
+
+	netConn, err := netDial("tcp", targetHostPort)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	defer func() {
+		if netConn != nil {
+			netConn.Close()
+		}
+	}()
+
+	if err := netConn.SetDeadline(deadline); err != nil {
+		return nil, nil, err
+	}
+
+	if proxyURL != nil {
+		connectHeader := make(http.Header)
+		if user := proxyURL.User; user != nil {
+			proxyUser := user.Username()
+			if proxyPassword, passwordSet := user.Password(); passwordSet {
+				credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
+				connectHeader.Set("Proxy-Authorization", "Basic "+credential)
+			}
+		}
+		connectReq := &http.Request{
+			Method: "CONNECT",
+			URL:    &url.URL{Opaque: hostPort},
+			Host:   hostPort,
+			Header: connectHeader,
+		}
+
+		connectReq.Write(netConn)
+
+		// Read response.
+		// Okay to use and discard buffered reader here, because
+		// TLS server will not speak until spoken to.
+		br := bufio.NewReader(netConn)
+		resp, err := http.ReadResponse(br, connectReq)
+		if err != nil {
+			return nil, nil, err
+		}
+		if resp.StatusCode != 200 {
+			f := strings.SplitN(resp.Status, " ", 2)
+			return nil, nil, errors.New(f[1])
+		}
+	}
+
+	if u.Scheme == "https" {
+		cfg := cloneTLSConfig(d.TLSClientConfig)
+		if cfg.ServerName == "" {
+			cfg.ServerName = hostNoPort
+		}
+		tlsConn := tls.Client(netConn, cfg)
+		netConn = tlsConn
+		if err := tlsConn.Handshake(); err != nil {
+			return nil, nil, err
+		}
+		if !cfg.InsecureSkipVerify {
+			if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+				return nil, nil, err
+			}
+		}
+	}
+
+	conn := newConn(netConn, false, d.ReadBufferSize, d.WriteBufferSize)
+
+	if err := req.Write(netConn); err != nil {
+		return nil, nil, err
+	}
+
+	resp, err := http.ReadResponse(conn.br, req)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if d.Jar != nil {
+		if rc := resp.Cookies(); len(rc) > 0 {
+			d.Jar.SetCookies(u, rc)
+		}
+	}
+
+	if resp.StatusCode != 101 ||
+		!strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
+		!strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
+		resp.Header.Get("Sec-Websocket-Accept") != computeAcceptKey(challengeKey) {
+		// Before closing the network connection on return from this
+		// function, slurp up some of the response to aid application
+		// debugging.
+		buf := make([]byte, 1024)
+		n, _ := io.ReadFull(resp.Body, buf)
+		resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
+		return nil, resp, ErrBadHandshake
+	}
+
+	for _, ext := range parseExtensions(resp.Header) {
+		if ext[""] != "permessage-deflate" {
+			continue
+		}
+		_, snct := ext["server_no_context_takeover"]
+		_, cnct := ext["client_no_context_takeover"]
+		if !snct || !cnct {
+			return nil, resp, errInvalidCompression
+		}
+		conn.newCompressionWriter = compressNoContextTakeover
+		conn.newDecompressionReader = decompressNoContextTakeover
+		break
+	}
+
+	resp.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
+	conn.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
+
+	netConn.SetDeadline(time.Time{})
+	netConn = nil // to avoid close in defer.
+	return conn, resp, nil
+}
diff --git a/vendor/github.com/gorilla/websocket/client_clone.go b/vendor/github.com/gorilla/websocket/client_clone.go
new file mode 100644
index 000000000..4f0d94372
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone.go
@@ -0,0 +1,16 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.8
+
+package websocket
+
+import "crypto/tls"
+
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+	if cfg == nil {
+		return &tls.Config{}
+	}
+	return cfg.Clone()
+}
diff --git a/vendor/github.com/gorilla/websocket/client_clone_legacy.go b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
new file mode 100644
index 000000000..babb007fb
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
@@ -0,0 +1,38 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.8
+
+package websocket
+
+import "crypto/tls"
+
+// cloneTLSConfig clones all public fields except the fields
+// SessionTicketsDisabled and SessionTicketKey. This avoids copying the
+// sync.Mutex in the sync.Once and makes it safe to call cloneTLSConfig on a
+// config in active use.
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+	if cfg == nil {
+		return &tls.Config{}
+	}
+	return &tls.Config{
+		Rand:                     cfg.Rand,
+		Time:                     cfg.Time,
+		Certificates:             cfg.Certificates,
+		NameToCertificate:        cfg.NameToCertificate,
+		GetCertificate:           cfg.GetCertificate,
+		RootCAs:                  cfg.RootCAs,
+		NextProtos:               cfg.NextProtos,
+		ServerName:               cfg.ServerName,
+		ClientAuth:               cfg.ClientAuth,
+		ClientCAs:                cfg.ClientCAs,
+		InsecureSkipVerify:       cfg.InsecureSkipVerify,
+		CipherSuites:             cfg.CipherSuites,
+		PreferServerCipherSuites: cfg.PreferServerCipherSuites,
+		ClientSessionCache:       cfg.ClientSessionCache,
+		MinVersion:               cfg.MinVersion,
+		MaxVersion:               cfg.MaxVersion,
+		CurvePreferences:         cfg.CurvePreferences,
+	}
+}
diff --git a/vendor/github.com/gorilla/websocket/compression.go b/vendor/github.com/gorilla/websocket/compression.go
new file mode 100644
index 000000000..813ffb1e8
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/compression.go
@@ -0,0 +1,148 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"compress/flate"
+	"errors"
+	"io"
+	"strings"
+	"sync"
+)
+
+const (
+	minCompressionLevel     = -2 // flate.HuffmanOnly not defined in Go < 1.6
+	maxCompressionLevel     = flate.BestCompression
+	defaultCompressionLevel = 1
+)
+
+var (
+	flateWriterPools [maxCompressionLevel - minCompressionLevel + 1]sync.Pool
+	flateReaderPool  = sync.Pool{New: func() interface{} {
+		return flate.NewReader(nil)
+	}}
+)
+
+func decompressNoContextTakeover(r io.Reader) io.ReadCloser {
+	const tail =
+	// Add four bytes as specified in RFC
+	"\x00\x00\xff\xff" +
+		// Add final block to squelch unexpected EOF error from flate reader.
+		"\x01\x00\x00\xff\xff"
+
+	fr, _ := flateReaderPool.Get().(io.ReadCloser)
+	fr.(flate.Resetter).Reset(io.MultiReader(r, strings.NewReader(tail)), nil)
+	return &flateReadWrapper{fr}
+}
+
+func isValidCompressionLevel(level int) bool {
+	return minCompressionLevel <= level && level <= maxCompressionLevel
+}
+
+func compressNoContextTakeover(w io.WriteCloser, level int) io.WriteCloser {
+	p := &flateWriterPools[level-minCompressionLevel]
+	tw := &truncWriter{w: w}
+	fw, _ := p.Get().(*flate.Writer)
+	if fw == nil {
+		fw, _ = flate.NewWriter(tw, level)
+	} else {
+		fw.Reset(tw)
+	}
+	return &flateWriteWrapper{fw: fw, tw: tw, p: p}
+}
+
+// truncWriter is an io.Writer that writes all but the last four bytes of the
+// stream to another io.Writer.
+type truncWriter struct {
+	w io.WriteCloser
+	n int
+	p [4]byte
+}
+
+func (w *truncWriter) Write(p []byte) (int, error) {
+	n := 0
+
+	// fill buffer first for simplicity.
+	if w.n < len(w.p) {
+		n = copy(w.p[w.n:], p)
+		p = p[n:]
+		w.n += n
+		if len(p) == 0 {
+			return n, nil
+		}
+	}
+
+	m := len(p)
+	if m > len(w.p) {
+		m = len(w.p)
+	}
+
+	if nn, err := w.w.Write(w.p[:m]); err != nil {
+		return n + nn, err
+	}
+
+	copy(w.p[:], w.p[m:])
+	copy(w.p[len(w.p)-m:], p[len(p)-m:])
+	nn, err := w.w.Write(p[:len(p)-m])
+	return n + nn, err
+}
+
+type flateWriteWrapper struct {
+	fw *flate.Writer
+	tw *truncWriter
+	p  *sync.Pool
+}
+
+func (w *flateWriteWrapper) Write(p []byte) (int, error) {
+	if w.fw == nil {
+		return 0, errWriteClosed
+	}
+	return w.fw.Write(p)
+}
+
+func (w *flateWriteWrapper) Close() error {
+	if w.fw == nil {
+		return errWriteClosed
+	}
+	err1 := w.fw.Flush()
+	w.p.Put(w.fw)
+	w.fw = nil
+	if w.tw.p != [4]byte{0, 0, 0xff, 0xff} {
+		return errors.New("websocket: internal error, unexpected bytes at end of flate stream")
+	}
+	err2 := w.tw.w.Close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+type flateReadWrapper struct {
+	fr io.ReadCloser
+}
+
+func (r *flateReadWrapper) Read(p []byte) (int, error) {
+	if r.fr == nil {
+		return 0, io.ErrClosedPipe
+	}
+	n, err := r.fr.Read(p)
+	if err == io.EOF {
+		// Preemptively place the reader back in the pool. This helps with
+		// scenarios where the application does not call NextReader() soon after
+		// this final read.
+		r.Close()
+	}
+	return n, err
+}
+
+func (r *flateReadWrapper) Close() error {
+	if r.fr == nil {
+		return io.ErrClosedPipe
+	}
+	err := r.fr.Close()
+	flateReaderPool.Put(r.fr)
+	r.fr = nil
+	return err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn.go b/vendor/github.com/gorilla/websocket/conn.go
new file mode 100644
index 000000000..97e1dbacb
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn.go
@@ -0,0 +1,1149 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"io"
+	"io/ioutil"
+	"math/rand"
+	"net"
+	"strconv"
+	"sync"
+	"time"
+	"unicode/utf8"
+)
+
+const (
+	// Frame header byte 0 bits from Section 5.2 of RFC 6455
+	finalBit = 1 << 7
+	rsv1Bit  = 1 << 6
+	rsv2Bit  = 1 << 5
+	rsv3Bit  = 1 << 4
+
+	// Frame header byte 1 bits from Section 5.2 of RFC 6455
+	maskBit = 1 << 7
+
+	maxFrameHeaderSize         = 2 + 8 + 4 // Fixed header + length + mask
+	maxControlFramePayloadSize = 125
+
+	writeWait = time.Second
+
+	defaultReadBufferSize  = 4096
+	defaultWriteBufferSize = 4096
+
+	continuationFrame = 0
+	noFrame           = -1
+)
+
+// Close codes defined in RFC 6455, section 11.7.
+const (
+	CloseNormalClosure           = 1000
+	CloseGoingAway               = 1001
+	CloseProtocolError           = 1002
+	CloseUnsupportedData         = 1003
+	CloseNoStatusReceived        = 1005
+	CloseAbnormalClosure         = 1006
+	CloseInvalidFramePayloadData = 1007
+	ClosePolicyViolation         = 1008
+	CloseMessageTooBig           = 1009
+	CloseMandatoryExtension      = 1010
+	CloseInternalServerErr       = 1011
+	CloseServiceRestart          = 1012
+	CloseTryAgainLater           = 1013
+	CloseTLSHandshake            = 1015
+)
+
+// The message types are defined in RFC 6455, section 11.8.
+const (
+	// TextMessage denotes a text data message. The text message payload is
+	// interpreted as UTF-8 encoded text data.
+	TextMessage = 1
+
+	// BinaryMessage denotes a binary data message.
+	BinaryMessage = 2
+
+	// CloseMessage denotes a close control message. The optional message
+	// payload contains a numeric code and text. Use the FormatCloseMessage
+	// function to format a close message payload.
+	CloseMessage = 8
+
+	// PingMessage denotes a ping control message. The optional message payload
+	// is UTF-8 encoded text.
+	PingMessage = 9
+
+	// PongMessage denotes a ping control message. The optional message payload
+	// is UTF-8 encoded text.
+	PongMessage = 10
+)
+
+// ErrCloseSent is returned when the application writes a message to the
+// connection after sending a close message.
+var ErrCloseSent = errors.New("websocket: close sent")
+
+// ErrReadLimit is returned when reading a message that is larger than the
+// read limit set for the connection.
+var ErrReadLimit = errors.New("websocket: read limit exceeded")
+
+// netError satisfies the net Error interface.
+type netError struct {
+	msg       string
+	temporary bool
+	timeout   bool
+}
+
+func (e *netError) Error() string   { return e.msg }
+func (e *netError) Temporary() bool { return e.temporary }
+func (e *netError) Timeout() bool   { return e.timeout }
+
+// CloseError represents close frame.
+type CloseError struct {
+
+	// Code is defined in RFC 6455, section 11.7.
+	Code int
+
+	// Text is the optional text payload.
+	Text string
+}
+
+func (e *CloseError) Error() string {
+	s := []byte("websocket: close ")
+	s = strconv.AppendInt(s, int64(e.Code), 10)
+	switch e.Code {
+	case CloseNormalClosure:
+		s = append(s, " (normal)"...)
+	case CloseGoingAway:
+		s = append(s, " (going away)"...)
+	case CloseProtocolError:
+		s = append(s, " (protocol error)"...)
+	case CloseUnsupportedData:
+		s = append(s, " (unsupported data)"...)
+	case CloseNoStatusReceived:
+		s = append(s, " (no status)"...)
+	case CloseAbnormalClosure:
+		s = append(s, " (abnormal closure)"...)
+	case CloseInvalidFramePayloadData:
+		s = append(s, " (invalid payload data)"...)
+	case ClosePolicyViolation:
+		s = append(s, " (policy violation)"...)
+	case CloseMessageTooBig:
+		s = append(s, " (message too big)"...)
+	case CloseMandatoryExtension:
+		s = append(s, " (mandatory extension missing)"...)
+	case CloseInternalServerErr:
+		s = append(s, " (internal server error)"...)
+	case CloseTLSHandshake:
+		s = append(s, " (TLS handshake error)"...)
+	}
+	if e.Text != "" {
+		s = append(s, ": "...)
+		s = append(s, e.Text...)
+	}
+	return string(s)
+}
+
+// IsCloseError returns boolean indicating whether the error is a *CloseError
+// with one of the specified codes.
+func IsCloseError(err error, codes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range codes {
+			if e.Code == code {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// IsUnexpectedCloseError returns boolean indicating whether the error is a
+// *CloseError with a code not in the list of expected codes.
+func IsUnexpectedCloseError(err error, expectedCodes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range expectedCodes {
+			if e.Code == code {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+var (
+	errWriteTimeout        = &netError{msg: "websocket: write timeout", timeout: true, temporary: true}
+	errUnexpectedEOF       = &CloseError{Code: CloseAbnormalClosure, Text: io.ErrUnexpectedEOF.Error()}
+	errBadWriteOpCode      = errors.New("websocket: bad write message type")
+	errWriteClosed         = errors.New("websocket: write closed")
+	errInvalidControlFrame = errors.New("websocket: invalid control frame")
+)
+
+func newMaskKey() [4]byte {
+	n := rand.Uint32()
+	return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
+}
+
+func hideTempErr(err error) error {
+	if e, ok := err.(net.Error); ok && e.Temporary() {
+		err = &netError{msg: e.Error(), timeout: e.Timeout()}
+	}
+	return err
+}
+
+func isControl(frameType int) bool {
+	return frameType == CloseMessage || frameType == PingMessage || frameType == PongMessage
+}
+
+func isData(frameType int) bool {
+	return frameType == TextMessage || frameType == BinaryMessage
+}
+
+var validReceivedCloseCodes = map[int]bool{
+	// see http://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
+
+	CloseNormalClosure:           true,
+	CloseGoingAway:               true,
+	CloseProtocolError:           true,
+	CloseUnsupportedData:         true,
+	CloseNoStatusReceived:        false,
+	CloseAbnormalClosure:         false,
+	CloseInvalidFramePayloadData: true,
+	ClosePolicyViolation:         true,
+	CloseMessageTooBig:           true,
+	CloseMandatoryExtension:      true,
+	CloseInternalServerErr:       true,
+	CloseServiceRestart:          true,
+	CloseTryAgainLater:           true,
+	CloseTLSHandshake:            false,
+}
+
+func isValidReceivedCloseCode(code int) bool {
+	return validReceivedCloseCodes[code] || (code >= 3000 && code <= 4999)
+}
+
+// The Conn type represents a WebSocket connection.
+type Conn struct {
+	conn        net.Conn
+	isServer    bool
+	subprotocol string
+
+	// Write fields
+	mu            chan bool // used as mutex to protect write to conn
+	writeBuf      []byte    // frame is constructed in this buffer.
+	writeDeadline time.Time
+	writer        io.WriteCloser // the current writer returned to the application
+	isWriting     bool           // for best-effort concurrent write detection
+
+	writeErrMu sync.Mutex
+	writeErr   error
+
+	enableWriteCompression bool
+	compressionLevel       int
+	newCompressionWriter   func(io.WriteCloser, int) io.WriteCloser
+
+	// Read fields
+	reader        io.ReadCloser // the current reader returned to the application
+	readErr       error
+	br            *bufio.Reader
+	readRemaining int64 // bytes remaining in current frame.
+	readFinal     bool  // true the current message has more frames.
+	readLength    int64 // Message size.
+	readLimit     int64 // Maximum message size.
+	readMaskPos   int
+	readMaskKey   [4]byte
+	handlePong    func(string) error
+	handlePing    func(string) error
+	handleClose   func(int, string) error
+	readErrCount  int
+	messageReader *messageReader // the current low-level reader
+
+	readDecompress         bool // whether last read frame had RSV1 set
+	newDecompressionReader func(io.Reader) io.ReadCloser
+}
+
+func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int) *Conn {
+	return newConnBRW(conn, isServer, readBufferSize, writeBufferSize, nil)
+}
+
+type writeHook struct {
+	p []byte
+}
+
+func (wh *writeHook) Write(p []byte) (int, error) {
+	wh.p = p
+	return len(p), nil
+}
+
+func newConnBRW(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int, brw *bufio.ReadWriter) *Conn {
+	mu := make(chan bool, 1)
+	mu <- true
+
+	var br *bufio.Reader
+	if readBufferSize == 0 && brw != nil && brw.Reader != nil {
+		// Reuse the supplied bufio.Reader if the buffer has a useful size.
+		// This code assumes that peek on a reader returns
+		// bufio.Reader.buf[:0].
+		brw.Reader.Reset(conn)
+		if p, err := brw.Reader.Peek(0); err == nil && cap(p) >= 256 {
+			br = brw.Reader
+		}
+	}
+	if br == nil {
+		if readBufferSize == 0 {
+			readBufferSize = defaultReadBufferSize
+		}
+		if readBufferSize < maxControlFramePayloadSize {
+			readBufferSize = maxControlFramePayloadSize
+		}
+		br = bufio.NewReaderSize(conn, readBufferSize)
+	}
+
+	var writeBuf []byte
+	if writeBufferSize == 0 && brw != nil && brw.Writer != nil {
+		// Use the bufio.Writer's buffer if the buffer has a useful size. This
+		// code assumes that bufio.Writer.buf[:1] is passed to the
+		// bufio.Writer's underlying writer.
+		var wh writeHook
+		brw.Writer.Reset(&wh)
+		brw.Writer.WriteByte(0)
+		brw.Flush()
+		if cap(wh.p) >= maxFrameHeaderSize+256 {
+			writeBuf = wh.p[:cap(wh.p)]
+		}
+	}
+
+	if writeBuf == nil {
+		if writeBufferSize == 0 {
+			writeBufferSize = defaultWriteBufferSize
+		}
+		writeBuf = make([]byte, writeBufferSize+maxFrameHeaderSize)
+	}
+
+	c := &Conn{
+		isServer:               isServer,
+		br:                     br,
+		conn:                   conn,
+		mu:                     mu,
+		readFinal:              true,
+		writeBuf:               writeBuf,
+		enableWriteCompression: true,
+		compressionLevel:       defaultCompressionLevel,
+	}
+	c.SetCloseHandler(nil)
+	c.SetPingHandler(nil)
+	c.SetPongHandler(nil)
+	return c
+}
+
+// Subprotocol returns the negotiated protocol for the connection.
+func (c *Conn) Subprotocol() string {
+	return c.subprotocol
+}
+
+// Close closes the underlying network connection without sending or waiting for a close frame.
+func (c *Conn) Close() error {
+	return c.conn.Close()
+}
+
+// LocalAddr returns the local network address.
+func (c *Conn) LocalAddr() net.Addr {
+	return c.conn.LocalAddr()
+}
+
+// RemoteAddr returns the remote network address.
+func (c *Conn) RemoteAddr() net.Addr {
+	return c.conn.RemoteAddr()
+}
+
+// Write methods
+
+func (c *Conn) writeFatal(err error) error {
+	err = hideTempErr(err)
+	c.writeErrMu.Lock()
+	if c.writeErr == nil {
+		c.writeErr = err
+	}
+	c.writeErrMu.Unlock()
+	return err
+}
+
+func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
+	<-c.mu
+	defer func() { c.mu <- true }()
+
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	if err != nil {
+		return err
+	}
+
+	c.conn.SetWriteDeadline(deadline)
+	for _, buf := range bufs {
+		if len(buf) > 0 {
+			_, err := c.conn.Write(buf)
+			if err != nil {
+				return c.writeFatal(err)
+			}
+		}
+	}
+
+	if frameType == CloseMessage {
+		c.writeFatal(ErrCloseSent)
+	}
+	return nil
+}
+
+// WriteControl writes a control message with the given deadline. The allowed
+// message types are CloseMessage, PingMessage and PongMessage.
+func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) error {
+	if !isControl(messageType) {
+		return errBadWriteOpCode
+	}
+	if len(data) > maxControlFramePayloadSize {
+		return errInvalidControlFrame
+	}
+
+	b0 := byte(messageType) | finalBit
+	b1 := byte(len(data))
+	if !c.isServer {
+		b1 |= maskBit
+	}
+
+	buf := make([]byte, 0, maxFrameHeaderSize+maxControlFramePayloadSize)
+	buf = append(buf, b0, b1)
+
+	if c.isServer {
+		buf = append(buf, data...)
+	} else {
+		key := newMaskKey()
+		buf = append(buf, key[:]...)
+		buf = append(buf, data...)
+		maskBytes(key, 0, buf[6:])
+	}
+
+	d := time.Hour * 1000
+	if !deadline.IsZero() {
+		d = deadline.Sub(time.Now())
+		if d < 0 {
+			return errWriteTimeout
+		}
+	}
+
+	timer := time.NewTimer(d)
+	select {
+	case <-c.mu:
+		timer.Stop()
+	case <-timer.C:
+		return errWriteTimeout
+	}
+	defer func() { c.mu <- true }()
+
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	if err != nil {
+		return err
+	}
+
+	c.conn.SetWriteDeadline(deadline)
+	_, err = c.conn.Write(buf)
+	if err != nil {
+		return c.writeFatal(err)
+	}
+	if messageType == CloseMessage {
+		c.writeFatal(ErrCloseSent)
+	}
+	return err
+}
+
+func (c *Conn) prepWrite(messageType int) error {
+	// Close previous writer if not already closed by the application. It's
+	// probably better to return an error in this situation, but we cannot
+	// change this without breaking existing applications.
+	if c.writer != nil {
+		c.writer.Close()
+		c.writer = nil
+	}
+
+	if !isControl(messageType) && !isData(messageType) {
+		return errBadWriteOpCode
+	}
+
+	c.writeErrMu.Lock()
+	err := c.writeErr
+	c.writeErrMu.Unlock()
+	return err
+}
+
+// NextWriter returns a writer for the next message to send. The writer's Close
+// method flushes the complete message to the network.
+//
+// There can be at most one open writer on a connection. NextWriter closes the
+// previous writer if the application has not already done so.
+func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
+	if err := c.prepWrite(messageType); err != nil {
+		return nil, err
+	}
+
+	mw := &messageWriter{
+		c:         c,
+		frameType: messageType,
+		pos:       maxFrameHeaderSize,
+	}
+	c.writer = mw
+	if c.newCompressionWriter != nil && c.enableWriteCompression && isData(messageType) {
+		w := c.newCompressionWriter(c.writer, c.compressionLevel)
+		mw.compress = true
+		c.writer = w
+	}
+	return c.writer, nil
+}
+
+type messageWriter struct {
+	c         *Conn
+	compress  bool // whether next call to flushFrame should set RSV1
+	pos       int  // end of data in writeBuf.
+	frameType int  // type of the current frame.
+	err       error
+}
+
+func (w *messageWriter) fatal(err error) error {
+	if w.err != nil {
+		w.err = err
+		w.c.writer = nil
+	}
+	return err
+}
+
+// flushFrame writes buffered data and extra as a frame to the network. The
+// final argument indicates that this is the last frame in the message.
+func (w *messageWriter) flushFrame(final bool, extra []byte) error {
+	c := w.c
+	length := w.pos - maxFrameHeaderSize + len(extra)
+
+	// Check for invalid control frames.
+	if isControl(w.frameType) &&
+		(!final || length > maxControlFramePayloadSize) {
+		return w.fatal(errInvalidControlFrame)
+	}
+
+	b0 := byte(w.frameType)
+	if final {
+		b0 |= finalBit
+	}
+	if w.compress {
+		b0 |= rsv1Bit
+	}
+	w.compress = false
+
+	b1 := byte(0)
+	if !c.isServer {
+		b1 |= maskBit
+	}
+
+	// Assume that the frame starts at beginning of c.writeBuf.
+	framePos := 0
+	if c.isServer {
+		// Adjust up if mask not included in the header.
+		framePos = 4
+	}
+
+	switch {
+	case length >= 65536:
+		c.writeBuf[framePos] = b0
+		c.writeBuf[framePos+1] = b1 | 127
+		binary.BigEndian.PutUint64(c.writeBuf[framePos+2:], uint64(length))
+	case length > 125:
+		framePos += 6
+		c.writeBuf[framePos] = b0
+		c.writeBuf[framePos+1] = b1 | 126
+		binary.BigEndian.PutUint16(c.writeBuf[framePos+2:], uint16(length))
+	default:
+		framePos += 8
+		c.writeBuf[framePos] = b0
+		c.writeBuf[framePos+1] = b1 | byte(length)
+	}
+
+	if !c.isServer {
+		key := newMaskKey()
+		copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
+		maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:w.pos])
+		if len(extra) > 0 {
+			return c.writeFatal(errors.New("websocket: internal error, extra used in client mode"))
+		}
+	}
+
+	// Write the buffers to the connection with best-effort detection of
+	// concurrent writes. See the concurrency section in the package
+	// documentation for more info.
+
+	if c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = true
+
+	err := c.write(w.frameType, c.writeDeadline, c.writeBuf[framePos:w.pos], extra)
+
+	if !c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = false
+
+	if err != nil {
+		return w.fatal(err)
+	}
+
+	if final {
+		c.writer = nil
+		return nil
+	}
+
+	// Setup for next frame.
+	w.pos = maxFrameHeaderSize
+	w.frameType = continuationFrame
+	return nil
+}
+
+func (w *messageWriter) ncopy(max int) (int, error) {
+	n := len(w.c.writeBuf) - w.pos
+	if n <= 0 {
+		if err := w.flushFrame(false, nil); err != nil {
+			return 0, err
+		}
+		n = len(w.c.writeBuf) - w.pos
+	}
+	if n > max {
+		n = max
+	}
+	return n, nil
+}
+
+func (w *messageWriter) Write(p []byte) (int, error) {
+	if w.err != nil {
+		return 0, w.err
+	}
+
+	if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
+		// Don't buffer large messages.
+		err := w.flushFrame(false, p)
+		if err != nil {
+			return 0, err
+		}
+		return len(p), nil
+	}
+
+	nn := len(p)
+	for len(p) > 0 {
+		n, err := w.ncopy(len(p))
+		if err != nil {
+			return 0, err
+		}
+		copy(w.c.writeBuf[w.pos:], p[:n])
+		w.pos += n
+		p = p[n:]
+	}
+	return nn, nil
+}
+
+func (w *messageWriter) WriteString(p string) (int, error) {
+	if w.err != nil {
+		return 0, w.err
+	}
+
+	nn := len(p)
+	for len(p) > 0 {
+		n, err := w.ncopy(len(p))
+		if err != nil {
+			return 0, err
+		}
+		copy(w.c.writeBuf[w.pos:], p[:n])
+		w.pos += n
+		p = p[n:]
+	}
+	return nn, nil
+}
+
+func (w *messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
+	if w.err != nil {
+		return 0, w.err
+	}
+	for {
+		if w.pos == len(w.c.writeBuf) {
+			err = w.flushFrame(false, nil)
+			if err != nil {
+				break
+			}
+		}
+		var n int
+		n, err = r.Read(w.c.writeBuf[w.pos:])
+		w.pos += n
+		nn += int64(n)
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+			}
+			break
+		}
+	}
+	return nn, err
+}
+
+func (w *messageWriter) Close() error {
+	if w.err != nil {
+		return w.err
+	}
+	if err := w.flushFrame(true, nil); err != nil {
+		return err
+	}
+	w.err = errWriteClosed
+	return nil
+}
+
+// WritePreparedMessage writes prepared message into connection.
+func (c *Conn) WritePreparedMessage(pm *PreparedMessage) error {
+	frameType, frameData, err := pm.frame(prepareKey{
+		isServer:         c.isServer,
+		compress:         c.newCompressionWriter != nil && c.enableWriteCompression && isData(pm.messageType),
+		compressionLevel: c.compressionLevel,
+	})
+	if err != nil {
+		return err
+	}
+	if c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = true
+	err = c.write(frameType, c.writeDeadline, frameData, nil)
+	if !c.isWriting {
+		panic("concurrent write to websocket connection")
+	}
+	c.isWriting = false
+	return err
+}
+
+// WriteMessage is a helper method for getting a writer using NextWriter,
+// writing the message and closing the writer.
+func (c *Conn) WriteMessage(messageType int, data []byte) error {
+
+	if c.isServer && (c.newCompressionWriter == nil || !c.enableWriteCompression) {
+		// Fast path with no allocations and single frame.
+
+		if err := c.prepWrite(messageType); err != nil {
+			return err
+		}
+		mw := messageWriter{c: c, frameType: messageType, pos: maxFrameHeaderSize}
+		n := copy(c.writeBuf[mw.pos:], data)
+		mw.pos += n
+		data = data[n:]
+		return mw.flushFrame(true, data)
+	}
+
+	w, err := c.NextWriter(messageType)
+	if err != nil {
+		return err
+	}
+	if _, err = w.Write(data); err != nil {
+		return err
+	}
+	return w.Close()
+}
+
+// SetWriteDeadline sets the write deadline on the underlying network
+// connection. After a write has timed out, the websocket state is corrupt and
+// all future writes will return an error. A zero value for t means writes will
+// not time out.
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+	c.writeDeadline = t
+	return nil
+}
+
+// Read methods
+
+func (c *Conn) advanceFrame() (int, error) {
+
+	// 1. Skip remainder of previous frame.
+
+	if c.readRemaining > 0 {
+		if _, err := io.CopyN(ioutil.Discard, c.br, c.readRemaining); err != nil {
+			return noFrame, err
+		}
+	}
+
+	// 2. Read and parse first two bytes of frame header.
+
+	p, err := c.read(2)
+	if err != nil {
+		return noFrame, err
+	}
+
+	final := p[0]&finalBit != 0
+	frameType := int(p[0] & 0xf)
+	mask := p[1]&maskBit != 0
+	c.readRemaining = int64(p[1] & 0x7f)
+
+	c.readDecompress = false
+	if c.newDecompressionReader != nil && (p[0]&rsv1Bit) != 0 {
+		c.readDecompress = true
+		p[0] &^= rsv1Bit
+	}
+
+	if rsv := p[0] & (rsv1Bit | rsv2Bit | rsv3Bit); rsv != 0 {
+		return noFrame, c.handleProtocolError("unexpected reserved bits 0x" + strconv.FormatInt(int64(rsv), 16))
+	}
+
+	switch frameType {
+	case CloseMessage, PingMessage, PongMessage:
+		if c.readRemaining > maxControlFramePayloadSize {
+			return noFrame, c.handleProtocolError("control frame length > 125")
+		}
+		if !final {
+			return noFrame, c.handleProtocolError("control frame not final")
+		}
+	case TextMessage, BinaryMessage:
+		if !c.readFinal {
+			return noFrame, c.handleProtocolError("message start before final message frame")
+		}
+		c.readFinal = final
+	case continuationFrame:
+		if c.readFinal {
+			return noFrame, c.handleProtocolError("continuation after final message frame")
+		}
+		c.readFinal = final
+	default:
+		return noFrame, c.handleProtocolError("unknown opcode " + strconv.Itoa(frameType))
+	}
+
+	// 3. Read and parse frame length.
+
+	switch c.readRemaining {
+	case 126:
+		p, err := c.read(2)
+		if err != nil {
+			return noFrame, err
+		}
+		c.readRemaining = int64(binary.BigEndian.Uint16(p))
+	case 127:
+		p, err := c.read(8)
+		if err != nil {
+			return noFrame, err
+		}
+		c.readRemaining = int64(binary.BigEndian.Uint64(p))
+	}
+
+	// 4. Handle frame masking.
+
+	if mask != c.isServer {
+		return noFrame, c.handleProtocolError("incorrect mask flag")
+	}
+
+	if mask {
+		c.readMaskPos = 0
+		p, err := c.read(len(c.readMaskKey))
+		if err != nil {
+			return noFrame, err
+		}
+		copy(c.readMaskKey[:], p)
+	}
+
+	// 5. For text and binary messages, enforce read limit and return.
+
+	if frameType == continuationFrame || frameType == TextMessage || frameType == BinaryMessage {
+
+		c.readLength += c.readRemaining
+		if c.readLimit > 0 && c.readLength > c.readLimit {
+			c.WriteControl(CloseMessage, FormatCloseMessage(CloseMessageTooBig, ""), time.Now().Add(writeWait))
+			return noFrame, ErrReadLimit
+		}
+
+		return frameType, nil
+	}
+
+	// 6. Read control frame payload.
+
+	var payload []byte
+	if c.readRemaining > 0 {
+		payload, err = c.read(int(c.readRemaining))
+		c.readRemaining = 0
+		if err != nil {
+			return noFrame, err
+		}
+		if c.isServer {
+			maskBytes(c.readMaskKey, 0, payload)
+		}
+	}
+
+	// 7. Process control frame payload.
+
+	switch frameType {
+	case PongMessage:
+		if err := c.handlePong(string(payload)); err != nil {
+			return noFrame, err
+		}
+	case PingMessage:
+		if err := c.handlePing(string(payload)); err != nil {
+			return noFrame, err
+		}
+	case CloseMessage:
+		closeCode := CloseNoStatusReceived
+		closeText := ""
+		if len(payload) >= 2 {
+			closeCode = int(binary.BigEndian.Uint16(payload))
+			if !isValidReceivedCloseCode(closeCode) {
+				return noFrame, c.handleProtocolError("invalid close code")
+			}
+			closeText = string(payload[2:])
+			if !utf8.ValidString(closeText) {
+				return noFrame, c.handleProtocolError("invalid utf8 payload in close frame")
+			}
+		}
+		if err := c.handleClose(closeCode, closeText); err != nil {
+			return noFrame, err
+		}
+		return noFrame, &CloseError{Code: closeCode, Text: closeText}
+	}
+
+	return frameType, nil
+}
+
+func (c *Conn) handleProtocolError(message string) error {
+	c.WriteControl(CloseMessage, FormatCloseMessage(CloseProtocolError, message), time.Now().Add(writeWait))
+	return errors.New("websocket: " + message)
+}
+
+// NextReader returns the next data message received from the peer. The
+// returned messageType is either TextMessage or BinaryMessage.
+//
+// There can be at most one open reader on a connection. NextReader discards
+// the previous message if the application has not already consumed it.
+//
+// Applications must break out of the application's read loop when this method
+// returns a non-nil error value. Errors returned from this method are
+// permanent. Once this method returns a non-nil error, all subsequent calls to
+// this method return the same error.
+func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
+	// Close previous reader, only relevant for decompression.
+	if c.reader != nil {
+		c.reader.Close()
+		c.reader = nil
+	}
+
+	c.messageReader = nil
+	c.readLength = 0
+
+	for c.readErr == nil {
+		frameType, err := c.advanceFrame()
+		if err != nil {
+			c.readErr = hideTempErr(err)
+			break
+		}
+		if frameType == TextMessage || frameType == BinaryMessage {
+			c.messageReader = &messageReader{c}
+			c.reader = c.messageReader
+			if c.readDecompress {
+				c.reader = c.newDecompressionReader(c.reader)
+			}
+			return frameType, c.reader, nil
+		}
+	}
+
+	// Applications that do handle the error returned from this method spin in
+	// tight loop on connection failure. To help application developers detect
+	// this error, panic on repeated reads to the failed connection.
+	c.readErrCount++
+	if c.readErrCount >= 1000 {
+		panic("repeated read on failed websocket connection")
+	}
+
+	return noFrame, nil, c.readErr
+}
+
+type messageReader struct{ c *Conn }
+
+func (r *messageReader) Read(b []byte) (int, error) {
+	c := r.c
+	if c.messageReader != r {
+		return 0, io.EOF
+	}
+
+	for c.readErr == nil {
+
+		if c.readRemaining > 0 {
+			if int64(len(b)) > c.readRemaining {
+				b = b[:c.readRemaining]
+			}
+			n, err := c.br.Read(b)
+			c.readErr = hideTempErr(err)
+			if c.isServer {
+				c.readMaskPos = maskBytes(c.readMaskKey, c.readMaskPos, b[:n])
+			}
+			c.readRemaining -= int64(n)
+			if c.readRemaining > 0 && c.readErr == io.EOF {
+				c.readErr = errUnexpectedEOF
+			}
+			return n, c.readErr
+		}
+
+		if c.readFinal {
+			c.messageReader = nil
+			return 0, io.EOF
+		}
+
+		frameType, err := c.advanceFrame()
+		switch {
+		case err != nil:
+			c.readErr = hideTempErr(err)
+		case frameType == TextMessage || frameType == BinaryMessage:
+			c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
+		}
+	}
+
+	err := c.readErr
+	if err == io.EOF && c.messageReader == r {
+		err = errUnexpectedEOF
+	}
+	return 0, err
+}
+
+func (r *messageReader) Close() error {
+	return nil
+}
+
+// ReadMessage is a helper method for getting a reader using NextReader and
+// reading from that reader to a buffer.
+func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
+	var r io.Reader
+	messageType, r, err = c.NextReader()
+	if err != nil {
+		return messageType, nil, err
+	}
+	p, err = ioutil.ReadAll(r)
+	return messageType, p, err
+}
+
+// SetReadDeadline sets the read deadline on the underlying network connection.
+// After a read has timed out, the websocket connection state is corrupt and
+// all future reads will return an error. A zero value for t means reads will
+// not time out.
+func (c *Conn) SetReadDeadline(t time.Time) error {
+	return c.conn.SetReadDeadline(t)
+}
+
+// SetReadLimit sets the maximum size for a message read from the peer. If a
+// message exceeds the limit, the connection sends a close frame to the peer
+// and returns ErrReadLimit to the application.
+func (c *Conn) SetReadLimit(limit int64) {
+	c.readLimit = limit
+}
+
+// CloseHandler returns the current close handler
+func (c *Conn) CloseHandler() func(code int, text string) error {
+	return c.handleClose
+}
+
+// SetCloseHandler sets the handler for close messages received from the peer.
+// The code argument to h is the received close code or CloseNoStatusReceived
+// if the close message is empty. The default close handler sends a close frame
+// back to the peer.
+//
+// The application must read the connection to process close messages as
+// described in the section on Control Frames above.
+//
+// The connection read methods return a CloseError when a close frame is
+// received. Most applications should handle close messages as part of their
+// normal error handling. Applications should only set a close handler when the
+// application must perform some action before sending a close frame back to
+// the peer.
+func (c *Conn) SetCloseHandler(h func(code int, text string) error) {
+	if h == nil {
+		h = func(code int, text string) error {
+			message := []byte{}
+			if code != CloseNoStatusReceived {
+				message = FormatCloseMessage(code, "")
+			}
+			c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
+			return nil
+		}
+	}
+	c.handleClose = h
+}
+
+// PingHandler returns the current ping handler
+func (c *Conn) PingHandler() func(appData string) error {
+	return c.handlePing
+}
+
+// SetPingHandler sets the handler for ping messages received from the peer.
+// The appData argument to h is the PING frame application data. The default
+// ping handler sends a pong to the peer.
+//
+// The application must read the connection to process ping messages as
+// described in the section on Control Frames above.
+func (c *Conn) SetPingHandler(h func(appData string) error) {
+	if h == nil {
+		h = func(message string) error {
+			err := c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
+			if err == ErrCloseSent {
+				return nil
+			} else if e, ok := err.(net.Error); ok && e.Temporary() {
+				return nil
+			}
+			return err
+		}
+	}
+	c.handlePing = h
+}
+
+// PongHandler returns the current pong handler
+func (c *Conn) PongHandler() func(appData string) error {
+	return c.handlePong
+}
+
+// SetPongHandler sets the handler for pong messages received from the peer.
+// The appData argument to h is the PONG frame application data. The default
+// pong handler does nothing.
+//
+// The application must read the connection to process ping messages as
+// described in the section on Control Frames above.
+func (c *Conn) SetPongHandler(h func(appData string) error) {
+	if h == nil {
+		h = func(string) error { return nil }
+	}
+	c.handlePong = h
+}
+
+// UnderlyingConn returns the internal net.Conn. This can be used to further
+// modifications to connection specific flags.
+func (c *Conn) UnderlyingConn() net.Conn {
+	return c.conn
+}
+
+// EnableWriteCompression enables and disables write compression of
+// subsequent text and binary messages. This function is a noop if
+// compression was not negotiated with the peer.
+func (c *Conn) EnableWriteCompression(enable bool) {
+	c.enableWriteCompression = enable
+}
+
+// SetCompressionLevel sets the flate compression level for subsequent text and
+// binary messages. This function is a noop if compression was not negotiated
+// with the peer. See the compress/flate package for a description of
+// compression levels.
+func (c *Conn) SetCompressionLevel(level int) error {
+	if !isValidCompressionLevel(level) {
+		return errors.New("websocket: invalid compression level")
+	}
+	c.compressionLevel = level
+	return nil
+}
+
+// FormatCloseMessage formats closeCode and text as a WebSocket close message.
+func FormatCloseMessage(closeCode int, text string) []byte {
+	buf := make([]byte, 2+len(text))
+	binary.BigEndian.PutUint16(buf, uint16(closeCode))
+	copy(buf[2:], text)
+	return buf
+}
diff --git a/vendor/github.com/gorilla/websocket/conn_read.go b/vendor/github.com/gorilla/websocket/conn_read.go
new file mode 100644
index 000000000..1ea15059e
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_read.go
@@ -0,0 +1,18 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.5
+
+package websocket
+
+import "io"
+
+func (c *Conn) read(n int) ([]byte, error) {
+	p, err := c.br.Peek(n)
+	if err == io.EOF {
+		err = errUnexpectedEOF
+	}
+	c.br.Discard(len(p))
+	return p, err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn_read_legacy.go b/vendor/github.com/gorilla/websocket/conn_read_legacy.go
new file mode 100644
index 000000000..018541cf6
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_read_legacy.go
@@ -0,0 +1,21 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.5
+
+package websocket
+
+import "io"
+
+func (c *Conn) read(n int) ([]byte, error) {
+	p, err := c.br.Peek(n)
+	if err == io.EOF {
+		err = errUnexpectedEOF
+	}
+	if len(p) > 0 {
+		// advance over the bytes just read
+		io.ReadFull(c.br, p)
+	}
+	return p, err
+}
diff --git a/vendor/github.com/gorilla/websocket/doc.go b/vendor/github.com/gorilla/websocket/doc.go
new file mode 100644
index 000000000..e291a952c
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/doc.go
@@ -0,0 +1,180 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package websocket implements the WebSocket protocol defined in RFC 6455.
+//
+// Overview
+//
+// The Conn type represents a WebSocket connection. A server application uses
+// the Upgrade function from an Upgrader object with a HTTP request handler
+// to get a pointer to a Conn:
+//
+//  var upgrader = websocket.Upgrader{
+//      ReadBufferSize:  1024,
+//      WriteBufferSize: 1024,
+//  }
+//
+//  func handler(w http.ResponseWriter, r *http.Request) {
+//      conn, err := upgrader.Upgrade(w, r, nil)
+//      if err != nil {
+//          log.Println(err)
+//          return
+//      }
+//      ... Use conn to send and receive messages.
+//  }
+//
+// Call the connection's WriteMessage and ReadMessage methods to send and
+// receive messages as a slice of bytes. This snippet of code shows how to echo
+// messages using these methods:
+//
+//  for {
+//      messageType, p, err := conn.ReadMessage()
+//      if err != nil {
+//          return
+//      }
+//      if err = conn.WriteMessage(messageType, p); err != nil {
+//          return err
+//      }
+//  }
+//
+// In above snippet of code, p is a []byte and messageType is an int with value
+// websocket.BinaryMessage or websocket.TextMessage.
+//
+// An application can also send and receive messages using the io.WriteCloser
+// and io.Reader interfaces. To send a message, call the connection NextWriter
+// method to get an io.WriteCloser, write the message to the writer and close
+// the writer when done. To receive a message, call the connection NextReader
+// method to get an io.Reader and read until io.EOF is returned. This snippet
+// shows how to echo messages using the NextWriter and NextReader methods:
+//
+//  for {
+//      messageType, r, err := conn.NextReader()
+//      if err != nil {
+//          return
+//      }
+//      w, err := conn.NextWriter(messageType)
+//      if err != nil {
+//          return err
+//      }
+//      if _, err := io.Copy(w, r); err != nil {
+//          return err
+//      }
+//      if err := w.Close(); err != nil {
+//          return err
+//      }
+//  }
+//
+// Data Messages
+//
+// The WebSocket protocol distinguishes between text and binary data messages.
+// Text messages are interpreted as UTF-8 encoded text. The interpretation of
+// binary messages is left to the application.
+//
+// This package uses the TextMessage and BinaryMessage integer constants to
+// identify the two data message types. The ReadMessage and NextReader methods
+// return the type of the received message. The messageType argument to the
+// WriteMessage and NextWriter methods specifies the type of a sent message.
+//
+// It is the application's responsibility to ensure that text messages are
+// valid UTF-8 encoded text.
+//
+// Control Messages
+//
+// The WebSocket protocol defines three types of control messages: close, ping
+// and pong. Call the connection WriteControl, WriteMessage or NextWriter
+// methods to send a control message to the peer.
+//
+// Connections handle received close messages by sending a close message to the
+// peer and returning a *CloseError from the the NextReader, ReadMessage or the
+// message Read method.
+//
+// Connections handle received ping and pong messages by invoking callback
+// functions set with SetPingHandler and SetPongHandler methods. The callback
+// functions are called from the NextReader, ReadMessage and the message Read
+// methods.
+//
+// The default ping handler sends a pong to the peer. The application's reading
+// goroutine can block for a short time while the handler writes the pong data
+// to the connection.
+//
+// The application must read the connection to process ping, pong and close
+// messages sent from the peer. If the application is not otherwise interested
+// in messages from the peer, then the application should start a goroutine to
+// read and discard messages from the peer. A simple example is:
+//
+//  func readLoop(c *websocket.Conn) {
+//      for {
+//          if _, _, err := c.NextReader(); err != nil {
+//              c.Close()
+//              break
+//          }
+//      }
+//  }
+//
+// Concurrency
+//
+// Connections support one concurrent reader and one concurrent writer.
+//
+// Applications are responsible for ensuring that no more than one goroutine
+// calls the write methods (NextWriter, SetWriteDeadline, WriteMessage,
+// WriteJSON, EnableWriteCompression, SetCompressionLevel) concurrently and
+// that no more than one goroutine calls the read methods (NextReader,
+// SetReadDeadline, ReadMessage, ReadJSON, SetPongHandler, SetPingHandler)
+// concurrently.
+//
+// The Close and WriteControl methods can be called concurrently with all other
+// methods.
+//
+// Origin Considerations
+//
+// Web browsers allow Javascript applications to open a WebSocket connection to
+// any host. It's up to the server to enforce an origin policy using the Origin
+// request header sent by the browser.
+//
+// The Upgrader calls the function specified in the CheckOrigin field to check
+// the origin. If the CheckOrigin function returns false, then the Upgrade
+// method fails the WebSocket handshake with HTTP status 403.
+//
+// If the CheckOrigin field is nil, then the Upgrader uses a safe default: fail
+// the handshake if the Origin request header is present and not equal to the
+// Host request header.
+//
+// An application can allow connections from any origin by specifying a
+// function that always returns true:
+//
+//  var upgrader = websocket.Upgrader{
+//      CheckOrigin: func(r *http.Request) bool { return true },
+//  }
+//
+// The deprecated Upgrade function does not enforce an origin policy. It's the
+// application's responsibility to check the Origin header before calling
+// Upgrade.
+//
+// Compression EXPERIMENTAL
+//
+// Per message compression extensions (RFC 7692) are experimentally supported
+// by this package in a limited capacity. Setting the EnableCompression option
+// to true in Dialer or Upgrader will attempt to negotiate per message deflate
+// support.
+//
+//  var upgrader = websocket.Upgrader{
+//      EnableCompression: true,
+//  }
+//
+// If compression was successfully negotiated with the connection's peer, any
+// message received in compressed form will be automatically decompressed.
+// All Read methods will return uncompressed bytes.
+//
+// Per message compression of messages written to a connection can be enabled
+// or disabled by calling the corresponding Conn method:
+//
+//  conn.EnableWriteCompression(false)
+//
+// Currently this package does not support compression with "context takeover".
+// This means that messages must be compressed and decompressed in isolation,
+// without retaining sliding window or dictionary state across messages. For
+// more details refer to RFC 7692.
+//
+// Use of compression is experimental and may result in decreased performance.
+package websocket
diff --git a/vendor/github.com/gorilla/websocket/json.go b/vendor/github.com/gorilla/websocket/json.go
new file mode 100644
index 000000000..4f0e36875
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/json.go
@@ -0,0 +1,55 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"encoding/json"
+	"io"
+)
+
+// WriteJSON is deprecated, use c.WriteJSON instead.
+func WriteJSON(c *Conn, v interface{}) error {
+	return c.WriteJSON(v)
+}
+
+// WriteJSON writes the JSON encoding of v to the connection.
+//
+// See the documentation for encoding/json Marshal for details about the
+// conversion of Go values to JSON.
+func (c *Conn) WriteJSON(v interface{}) error {
+	w, err := c.NextWriter(TextMessage)
+	if err != nil {
+		return err
+	}
+	err1 := json.NewEncoder(w).Encode(v)
+	err2 := w.Close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+// ReadJSON is deprecated, use c.ReadJSON instead.
+func ReadJSON(c *Conn, v interface{}) error {
+	return c.ReadJSON(v)
+}
+
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// See the documentation for the encoding/json Unmarshal function for details
+// about the conversion of JSON to a Go value.
+func (c *Conn) ReadJSON(v interface{}) error {
+	_, r, err := c.NextReader()
+	if err != nil {
+		return err
+	}
+	err = json.NewDecoder(r).Decode(v)
+	if err == io.EOF {
+		// One value is expected in the message.
+		err = io.ErrUnexpectedEOF
+	}
+	return err
+}
diff --git a/vendor/github.com/gorilla/websocket/mask.go b/vendor/github.com/gorilla/websocket/mask.go
new file mode 100644
index 000000000..6a88bbc74
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask.go
@@ -0,0 +1,55 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.  Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build !appengine
+
+package websocket
+
+import "unsafe"
+
+const wordSize = int(unsafe.Sizeof(uintptr(0)))
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+
+	// Mask one byte at a time for small buffers.
+	if len(b) < 2*wordSize {
+		for i := range b {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		return pos & 3
+	}
+
+	// Mask one byte at a time to word boundary.
+	if n := int(uintptr(unsafe.Pointer(&b[0]))) % wordSize; n != 0 {
+		n = wordSize - n
+		for i := range b[:n] {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		b = b[n:]
+	}
+
+	// Create aligned word size key.
+	var k [wordSize]byte
+	for i := range k {
+		k[i] = key[(pos+i)&3]
+	}
+	kw := *(*uintptr)(unsafe.Pointer(&k))
+
+	// Mask one word at a time.
+	n := (len(b) / wordSize) * wordSize
+	for i := 0; i < n; i += wordSize {
+		*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(i))) ^= kw
+	}
+
+	// Mask one byte at a time for remaining bytes.
+	b = b[n:]
+	for i := range b {
+		b[i] ^= key[pos&3]
+		pos++
+	}
+
+	return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/mask_safe.go b/vendor/github.com/gorilla/websocket/mask_safe.go
new file mode 100644
index 000000000..2aac060e5
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask_safe.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.  Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build appengine
+
+package websocket
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+	for i := range b {
+		b[i] ^= key[pos&3]
+		pos++
+	}
+	return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/prepared.go b/vendor/github.com/gorilla/websocket/prepared.go
new file mode 100644
index 000000000..1efffbd1e
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/prepared.go
@@ -0,0 +1,103 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"time"
+)
+
+// PreparedMessage caches on the wire representations of a message payload.
+// Use PreparedMessage to efficiently send a message payload to multiple
+// connections. PreparedMessage is especially useful when compression is used
+// because the CPU and memory expensive compression operation can be executed
+// once for a given set of compression options.
+type PreparedMessage struct {
+	messageType int
+	data        []byte
+	err         error
+	mu          sync.Mutex
+	frames      map[prepareKey]*preparedFrame
+}
+
+// prepareKey defines a unique set of options to cache prepared frames in PreparedMessage.
+type prepareKey struct {
+	isServer         bool
+	compress         bool
+	compressionLevel int
+}
+
+// preparedFrame contains data in wire representation.
+type preparedFrame struct {
+	once sync.Once
+	data []byte
+}
+
+// NewPreparedMessage returns an initialized PreparedMessage. You can then send
+// it to connection using WritePreparedMessage method. Valid wire
+// representation will be calculated lazily only once for a set of current
+// connection options.
+func NewPreparedMessage(messageType int, data []byte) (*PreparedMessage, error) {
+	pm := &PreparedMessage{
+		messageType: messageType,
+		frames:      make(map[prepareKey]*preparedFrame),
+		data:        data,
+	}
+
+	// Prepare a plain server frame.
+	_, frameData, err := pm.frame(prepareKey{isServer: true, compress: false})
+	if err != nil {
+		return nil, err
+	}
+
+	// To protect against caller modifying the data argument, remember the data
+	// copied to the plain server frame.
+	pm.data = frameData[len(frameData)-len(data):]
+	return pm, nil
+}
+
+func (pm *PreparedMessage) frame(key prepareKey) (int, []byte, error) {
+	pm.mu.Lock()
+	frame, ok := pm.frames[key]
+	if !ok {
+		frame = &preparedFrame{}
+		pm.frames[key] = frame
+	}
+	pm.mu.Unlock()
+
+	var err error
+	frame.once.Do(func() {
+		// Prepare a frame using a 'fake' connection.
+		// TODO: Refactor code in conn.go to allow more direct construction of
+		// the frame.
+		mu := make(chan bool, 1)
+		mu <- true
+		var nc prepareConn
+		c := &Conn{
+			conn:                   &nc,
+			mu:                     mu,
+			isServer:               key.isServer,
+			compressionLevel:       key.compressionLevel,
+			enableWriteCompression: true,
+			writeBuf:               make([]byte, defaultWriteBufferSize+maxFrameHeaderSize),
+		}
+		if key.compress {
+			c.newCompressionWriter = compressNoContextTakeover
+		}
+		err = c.WriteMessage(pm.messageType, pm.data)
+		frame.data = nc.buf.Bytes()
+	})
+	return pm.messageType, frame.data, err
+}
+
+type prepareConn struct {
+	buf bytes.Buffer
+	net.Conn
+}
+
+func (pc *prepareConn) Write(p []byte) (int, error)        { return pc.buf.Write(p) }
+func (pc *prepareConn) SetWriteDeadline(t time.Time) error { return nil }
diff --git a/vendor/github.com/gorilla/websocket/server.go b/vendor/github.com/gorilla/websocket/server.go
new file mode 100644
index 000000000..3495e0f1a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/server.go
@@ -0,0 +1,291 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"bufio"
+	"errors"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// HandshakeError describes an error with the handshake from the peer.
+type HandshakeError struct {
+	message string
+}
+
+func (e HandshakeError) Error() string { return e.message }
+
+// Upgrader specifies parameters for upgrading an HTTP connection to a
+// WebSocket connection.
+type Upgrader struct {
+	// HandshakeTimeout specifies the duration for the handshake to complete.
+	HandshakeTimeout time.Duration
+
+	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
+	// size is zero, then buffers allocated by the HTTP server are used. The
+	// I/O buffer sizes do not limit the size of the messages that can be sent
+	// or received.
+	ReadBufferSize, WriteBufferSize int
+
+	// Subprotocols specifies the server's supported protocols in order of
+	// preference. If this field is set, then the Upgrade method negotiates a
+	// subprotocol by selecting the first match in this list with a protocol
+	// requested by the client.
+	Subprotocols []string
+
+	// Error specifies the function for generating HTTP error responses. If Error
+	// is nil, then http.Error is used to generate the HTTP response.
+	Error func(w http.ResponseWriter, r *http.Request, status int, reason error)
+
+	// CheckOrigin returns true if the request Origin header is acceptable. If
+	// CheckOrigin is nil, the host in the Origin header must not be set or
+	// must match the host of the request.
+	CheckOrigin func(r *http.Request) bool
+
+	// EnableCompression specify if the server should attempt to negotiate per
+	// message compression (RFC 7692). Setting this value to true does not
+	// guarantee that compression will be supported. Currently only "no context
+	// takeover" modes are supported.
+	EnableCompression bool
+}
+
+func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status int, reason string) (*Conn, error) {
+	err := HandshakeError{reason}
+	if u.Error != nil {
+		u.Error(w, r, status, err)
+	} else {
+		w.Header().Set("Sec-Websocket-Version", "13")
+		http.Error(w, http.StatusText(status), status)
+	}
+	return nil, err
+}
+
+// checkSameOrigin returns true if the origin is not set or is equal to the request host.
+func checkSameOrigin(r *http.Request) bool {
+	origin := r.Header["Origin"]
+	if len(origin) == 0 {
+		return true
+	}
+	u, err := url.Parse(origin[0])
+	if err != nil {
+		return false
+	}
+	return u.Host == r.Host
+}
+
+func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header) string {
+	if u.Subprotocols != nil {
+		clientProtocols := Subprotocols(r)
+		for _, serverProtocol := range u.Subprotocols {
+			for _, clientProtocol := range clientProtocols {
+				if clientProtocol == serverProtocol {
+					return clientProtocol
+				}
+			}
+		}
+	} else if responseHeader != nil {
+		return responseHeader.Get("Sec-Websocket-Protocol")
+	}
+	return ""
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// application negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// If the upgrade fails, then Upgrade replies to the client with an HTTP error
+// response.
+func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
+	if r.Method != "GET" {
+		return u.returnError(w, r, http.StatusMethodNotAllowed, "websocket: not a websocket handshake: request method is not GET")
+	}
+
+	if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
+		return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-Websocket-Extensions' headers are unsupported")
+	}
+
+	if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'upgrade' token not found in 'Connection' header")
+	}
+
+	if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'websocket' token not found in 'Upgrade' header")
+	}
+
+	if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
+	}
+
+	checkOrigin := u.CheckOrigin
+	if checkOrigin == nil {
+		checkOrigin = checkSameOrigin
+	}
+	if !checkOrigin(r) {
+		return u.returnError(w, r, http.StatusForbidden, "websocket: 'Origin' header value not allowed")
+	}
+
+	challengeKey := r.Header.Get("Sec-Websocket-Key")
+	if challengeKey == "" {
+		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: `Sec-Websocket-Key' header is missing or blank")
+	}
+
+	subprotocol := u.selectSubprotocol(r, responseHeader)
+
+	// Negotiate PMCE
+	var compress bool
+	if u.EnableCompression {
+		for _, ext := range parseExtensions(r.Header) {
+			if ext[""] != "permessage-deflate" {
+				continue
+			}
+			compress = true
+			break
+		}
+	}
+
+	var (
+		netConn net.Conn
+		err     error
+	)
+
+	h, ok := w.(http.Hijacker)
+	if !ok {
+		return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
+	}
+	var brw *bufio.ReadWriter
+	netConn, brw, err = h.Hijack()
+	if err != nil {
+		return u.returnError(w, r, http.StatusInternalServerError, err.Error())
+	}
+
+	if brw.Reader.Buffered() > 0 {
+		netConn.Close()
+		return nil, errors.New("websocket: client sent data before handshake is complete")
+	}
+
+	c := newConnBRW(netConn, true, u.ReadBufferSize, u.WriteBufferSize, brw)
+	c.subprotocol = subprotocol
+
+	if compress {
+		c.newCompressionWriter = compressNoContextTakeover
+		c.newDecompressionReader = decompressNoContextTakeover
+	}
+
+	p := c.writeBuf[:0]
+	p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
+	p = append(p, computeAcceptKey(challengeKey)...)
+	p = append(p, "\r\n"...)
+	if c.subprotocol != "" {
+		p = append(p, "Sec-Websocket-Protocol: "...)
+		p = append(p, c.subprotocol...)
+		p = append(p, "\r\n"...)
+	}
+	if compress {
+		p = append(p, "Sec-Websocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
+	}
+	for k, vs := range responseHeader {
+		if k == "Sec-Websocket-Protocol" {
+			continue
+		}
+		for _, v := range vs {
+			p = append(p, k...)
+			p = append(p, ": "...)
+			for i := 0; i < len(v); i++ {
+				b := v[i]
+				if b <= 31 {
+					// prevent response splitting.
+					b = ' '
+				}
+				p = append(p, b)
+			}
+			p = append(p, "\r\n"...)
+		}
+	}
+	p = append(p, "\r\n"...)
+
+	// Clear deadlines set by HTTP server.
+	netConn.SetDeadline(time.Time{})
+
+	if u.HandshakeTimeout > 0 {
+		netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
+	}
+	if _, err = netConn.Write(p); err != nil {
+		netConn.Close()
+		return nil, err
+	}
+	if u.HandshakeTimeout > 0 {
+		netConn.SetWriteDeadline(time.Time{})
+	}
+
+	return c, nil
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// This function is deprecated, use websocket.Upgrader instead.
+//
+// The application is responsible for checking the request origin before
+// calling Upgrade. An example implementation of the same origin policy is:
+//
+//	if req.Header.Get("Origin") != "http://"+req.Host {
+//		http.Error(w, "Origin not allowed", 403)
+//		return
+//	}
+//
+// If the endpoint supports subprotocols, then the application is responsible
+// for negotiating the protocol used on the connection. Use the Subprotocols()
+// function to get the subprotocols requested by the client. Use the
+// Sec-Websocket-Protocol response header to specify the subprotocol selected
+// by the application.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// The connection buffers IO to the underlying network connection. The
+// readBufSize and writeBufSize parameters specify the size of the buffers to
+// use. Messages can be larger than the buffers.
+//
+// If the request is not a valid WebSocket handshake, then Upgrade returns an
+// error of type HandshakeError. Applications should handle this error by
+// replying to the client with an HTTP error response.
+func Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header, readBufSize, writeBufSize int) (*Conn, error) {
+	u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
+	u.Error = func(w http.ResponseWriter, r *http.Request, status int, reason error) {
+		// don't return errors to maintain backwards compatibility
+	}
+	u.CheckOrigin = func(r *http.Request) bool {
+		// allow all connections by default
+		return true
+	}
+	return u.Upgrade(w, r, responseHeader)
+}
+
+// Subprotocols returns the subprotocols requested by the client in the
+// Sec-Websocket-Protocol header.
+func Subprotocols(r *http.Request) []string {
+	h := strings.TrimSpace(r.Header.Get("Sec-Websocket-Protocol"))
+	if h == "" {
+		return nil
+	}
+	protocols := strings.Split(h, ",")
+	for i := range protocols {
+		protocols[i] = strings.TrimSpace(protocols[i])
+	}
+	return protocols
+}
+
+// IsWebSocketUpgrade returns true if the client requested upgrade to the
+// WebSocket protocol.
+func IsWebSocketUpgrade(r *http.Request) bool {
+	return tokenListContainsValue(r.Header, "Connection", "upgrade") &&
+		tokenListContainsValue(r.Header, "Upgrade", "websocket")
+}
diff --git a/vendor/github.com/gorilla/websocket/util.go b/vendor/github.com/gorilla/websocket/util.go
new file mode 100644
index 000000000..9a4908df2
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/util.go
@@ -0,0 +1,214 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding/base64"
+	"io"
+	"net/http"
+	"strings"
+)
+
+var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+
+func computeAcceptKey(challengeKey string) string {
+	h := sha1.New()
+	h.Write([]byte(challengeKey))
+	h.Write(keyGUID)
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func generateChallengeKey() (string, error) {
+	p := make([]byte, 16)
+	if _, err := io.ReadFull(rand.Reader, p); err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(p), nil
+}
+
+// Octet types from RFC 2616.
+var octetTypes [256]byte
+
+const (
+	isTokenOctet = 1 << iota
+	isSpaceOctet
+)
+
+func init() {
+	// From RFC 2616
+	//
+	// OCTET      = <any 8-bit sequence of data>
+	// CHAR       = <any US-ASCII character (octets 0 - 127)>
+	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
+	// CR         = <US-ASCII CR, carriage return (13)>
+	// LF         = <US-ASCII LF, linefeed (10)>
+	// SP         = <US-ASCII SP, space (32)>
+	// HT         = <US-ASCII HT, horizontal-tab (9)>
+	// <">        = <US-ASCII double-quote mark (34)>
+	// CRLF       = CR LF
+	// LWS        = [CRLF] 1*( SP | HT )
+	// TEXT       = <any OCTET except CTLs, but including LWS>
+	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
+	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
+	// token      = 1*<any CHAR except CTLs or separators>
+	// qdtext     = <any TEXT except <">>
+
+	for c := 0; c < 256; c++ {
+		var t byte
+		isCtl := c <= 31 || c == 127
+		isChar := 0 <= c && c <= 127
+		isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0
+		if strings.IndexRune(" \t\r\n", rune(c)) >= 0 {
+			t |= isSpaceOctet
+		}
+		if isChar && !isCtl && !isSeparator {
+			t |= isTokenOctet
+		}
+		octetTypes[c] = t
+	}
+}
+
+func skipSpace(s string) (rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isSpaceOctet == 0 {
+			break
+		}
+	}
+	return s[i:]
+}
+
+func nextToken(s string) (token, rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isTokenOctet == 0 {
+			break
+		}
+	}
+	return s[:i], s[i:]
+}
+
+func nextTokenOrQuoted(s string) (value string, rest string) {
+	if !strings.HasPrefix(s, "\"") {
+		return nextToken(s)
+	}
+	s = s[1:]
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '"':
+			return s[:i], s[i+1:]
+		case '\\':
+			p := make([]byte, len(s)-1)
+			j := copy(p, s[:i])
+			escape := true
+			for i = i + 1; i < len(s); i++ {
+				b := s[i]
+				switch {
+				case escape:
+					escape = false
+					p[j] = b
+					j += 1
+				case b == '\\':
+					escape = true
+				case b == '"':
+					return string(p[:j]), s[i+1:]
+				default:
+					p[j] = b
+					j += 1
+				}
+			}
+			return "", ""
+		}
+	}
+	return "", ""
+}
+
+// tokenListContainsValue returns true if the 1#token header with the given
+// name contains token.
+func tokenListContainsValue(header http.Header, name string, value string) bool {
+headers:
+	for _, s := range header[name] {
+		for {
+			var t string
+			t, s = nextToken(skipSpace(s))
+			if t == "" {
+				continue headers
+			}
+			s = skipSpace(s)
+			if s != "" && s[0] != ',' {
+				continue headers
+			}
+			if strings.EqualFold(t, value) {
+				return true
+			}
+			if s == "" {
+				continue headers
+			}
+			s = s[1:]
+		}
+	}
+	return false
+}
+
+// parseExtensiosn parses WebSocket extensions from a header.
+func parseExtensions(header http.Header) []map[string]string {
+
+	// From RFC 6455:
+	//
+	//  Sec-WebSocket-Extensions = extension-list
+	//  extension-list = 1#extension
+	//  extension = extension-token *( ";" extension-param )
+	//  extension-token = registered-token
+	//  registered-token = token
+	//  extension-param = token [ "=" (token | quoted-string) ]
+	//     ;When using the quoted-string syntax variant, the value
+	//     ;after quoted-string unescaping MUST conform to the
+	//     ;'token' ABNF.
+
+	var result []map[string]string
+headers:
+	for _, s := range header["Sec-Websocket-Extensions"] {
+		for {
+			var t string
+			t, s = nextToken(skipSpace(s))
+			if t == "" {
+				continue headers
+			}
+			ext := map[string]string{"": t}
+			for {
+				s = skipSpace(s)
+				if !strings.HasPrefix(s, ";") {
+					break
+				}
+				var k string
+				k, s = nextToken(skipSpace(s[1:]))
+				if k == "" {
+					continue headers
+				}
+				s = skipSpace(s)
+				var v string
+				if strings.HasPrefix(s, "=") {
+					v, s = nextTokenOrQuoted(skipSpace(s[1:]))
+					s = skipSpace(s)
+				}
+				if s != "" && s[0] != ',' && s[0] != ';' {
+					continue headers
+				}
+				ext[k] = v
+			}
+			if s != "" && s[0] != ',' {
+				continue headers
+			}
+			result = append(result, ext)
+			if s == "" {
+				continue headers
+			}
+			s = s[1:]
+		}
+	}
+	return result
+}
diff --git a/vendor/github.com/gxed/GoEndian/LICENSE b/vendor/github.com/gxed/GoEndian/LICENSE
new file mode 100644
index 000000000..abd540fd6
--- /dev/null
+++ b/vendor/github.com/gxed/GoEndian/LICENSE
@@ -0,0 +1,201 @@
+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.
\ No newline at end of file
diff --git a/vendor/github.com/gxed/GoEndian/endian.go b/vendor/github.com/gxed/GoEndian/endian.go
new file mode 100644
index 000000000..c37da846d
--- /dev/null
+++ b/vendor/github.com/gxed/GoEndian/endian.go
@@ -0,0 +1,43 @@
+package endian
+
+import (
+	"encoding/binary"
+	"unsafe"
+)
+
+//保存机器大小端
+var Endian binary.ByteOrder
+var bigEndian bool
+
+func IsBigEndian() bool {
+	return bigEndian
+}
+
+func IsLittleEndian() bool {
+	return !bigEndian
+}
+
+func init() {
+	if getEndian() {
+		Endian = binary.BigEndian
+		bigEndian = true
+	} else {
+		Endian = binary.LittleEndian
+		bigEndian = false
+	}
+}
+
+//以下代码判断机器大小端
+const INT_SIZE int = int(unsafe.Sizeof(0))
+
+//true = big endian, false = little endian
+func getEndian() (ret bool) {
+	var i int = 0x1
+	bs := (*[INT_SIZE]byte)(unsafe.Pointer(&i))
+	if bs[0] == 0 {
+		return true
+	} else {
+		return false
+	}
+
+}
diff --git a/vendor/github.com/gxed/eventfd/LICENSE b/vendor/github.com/gxed/eventfd/LICENSE
new file mode 100644
index 000000000..d2688ec77
--- /dev/null
+++ b/vendor/github.com/gxed/eventfd/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) 2014, Daniel Walter
+All rights resevered.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/gxed/eventfd/eventfd.go b/vendor/github.com/gxed/eventfd/eventfd.go
new file mode 100644
index 000000000..68a59ff52
--- /dev/null
+++ b/vendor/github.com/gxed/eventfd/eventfd.go
@@ -0,0 +1,108 @@
+package eventfd
+
+/*
+ * eventfd wrapper for go
+ * Provides a ReadWriteCloser interface for handling eventfd()'s
+ * Eventfd provides a simple filedescriptor with very low overhead.
+ * It stores a bitfield of 64 bits which are added when written to
+ * the fd.
+ *
+ * For more information on eventfd() see `man eventfd`.
+ */
+
+import (
+	"fmt"
+	"syscall"
+
+	"github.com/gxed/GoEndian"
+)
+
+type EventFD struct {
+	fd    int
+	valid bool
+}
+
+/* Create a new EventFD. */
+func New() (*EventFD, error) {
+	fd, _, err := syscall.Syscall(syscall.SYS_EVENTFD2, 0, uintptr(syscall.O_CLOEXEC), 0)
+	if err != 0 {
+		return nil, err
+	}
+
+	e := &EventFD{
+		fd:    int(fd),
+		valid: true,
+	}
+	return e, nil
+}
+
+/* Read events from Eventfd. p should be at max 8 bytes.
+ * Returns the number of read bytes or 0 and error is set.
+ */
+func (e *EventFD) Read(p []byte) (int, error) {
+	n, err := syscall.Read(e.fd, p[:])
+	if err != nil {
+		return 0, err
+	}
+	return n, nil
+}
+
+/* Read events into a uint64 and return it. Returns 0 and error
+ * if an error occured
+ */
+func (e *EventFD) ReadEvents() (uint64, error) {
+	buf := make([]byte, 8)
+	n, err := syscall.Read(e.fd, buf[:])
+	if err != nil {
+		return 0, err
+	}
+	if n != 8 {
+		return 0, fmt.Errorf("could not read for eventfd")
+	}
+
+	val := endian.Endian.Uint64(buf)
+	return val, nil
+}
+
+/* Write bytes to eventfd. Will be added to the current
+ * value of the internal uint64 of the eventfd().
+ */
+func (e *EventFD) Write(p []byte) (int, error) {
+	n, err := syscall.Write(e.fd, p[:])
+	if err != nil {
+		return 0, err
+	}
+	return n, nil
+}
+
+/* Write a uint64 to eventfd. Value will be added to current value
+ * of the eventfd
+ */
+func (e *EventFD) WriteEvents(val uint64) error {
+	buf := make([]byte, 8)
+	endian.Endian.PutUint64(buf, val)
+
+	n, err := syscall.Write(e.fd, buf[:])
+	if err != nil {
+		return err
+	}
+	if n != 8 {
+		return fmt.Errorf("could not write to eventfd")
+	}
+
+	return nil
+}
+
+/* Returns the filedescriptor which is internally used */
+func (e *EventFD) Fd() int {
+	return e.fd
+}
+
+/* Close the eventfd */
+func (e *EventFD) Close() error {
+	if e.valid == false {
+		return nil
+	}
+	e.valid = false
+	return syscall.Close(e.fd)
+}
diff --git a/vendor/github.com/gxed/hashland/LICENSE b/vendor/github.com/gxed/hashland/LICENSE
new file mode 100644
index 000000000..ee9d3facc
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Lawrence E. Bakst
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/github.com/gxed/hashland/keccak/LICENSE b/vendor/github.com/gxed/hashland/keccak/LICENSE
new file mode 100644
index 000000000..9cbcfb5f5
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccak/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2013 Barry Allard
+
+Except for keccak_test.go, .h and .c files are licensed seperately
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/gxed/hashland/keccakpg/keccak.go b/vendor/github.com/gxed/hashland/keccakpg/keccak.go
new file mode 100644
index 000000000..e97a49a49
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/keccakpg/keccak.go
@@ -0,0 +1,224 @@
+// Package keccak implements the Keccak (SHA-3) hash algorithm.
+// http://keccak.noekeon.org.
+package keccakpg
+
+import (
+	_ "fmt"
+	"hash"
+)
+
+const stdRounds = 24
+
+var roundConstants = []uint64{
+	0x0000000000000001, 0x0000000000008082,
+	0x800000000000808A, 0x8000000080008000,
+	0x000000000000808B, 0x0000000080000001,
+	0x8000000080008081, 0x8000000000008009,
+	0x000000000000008A, 0x0000000000000088,
+	0x0000000080008009, 0x000000008000000A,
+	0x000000008000808B, 0x800000000000008B,
+	0x8000000000008089, 0x8000000000008003,
+	0x8000000000008002, 0x8000000000000080,
+	0x000000000000800A, 0x800000008000000A,
+	0x8000000080008081, 0x8000000000008080,
+	0x0000000080000001, 0x8000000080008008,
+}
+
+var rotationConstants = [24]uint{
+	1, 3, 6, 10, 15, 21, 28, 36,
+	45, 55, 2, 14, 27, 41, 56, 8,
+	25, 43, 62, 18, 39, 61, 20, 44,
+}
+
+var piLane = [24]uint{
+	10, 7, 11, 17, 18, 3, 5, 16,
+	8, 21, 24, 4, 15, 23, 19, 13,
+	12, 2, 20, 14, 22, 9, 6, 1,
+}
+
+type keccak struct {
+	S         [25]uint64
+	size      int
+	blockSize int
+	rounds    int
+	buf       []byte
+}
+
+func newKeccak(bitlen, rounds int) hash.Hash {
+	var h keccak
+	h.size = bitlen / 8
+	h.blockSize = (200 - 2*h.size)
+	h.rounds = rounds
+	if rounds != stdRounds {
+		//fmt.Printf("keccak: warning non standard number of rounds %d vs %d\n", rounds, stdRounds)
+	}
+	return &h
+}
+
+func NewCustom(bits, rounds int) hash.Hash {
+	return newKeccak(bits, rounds)
+}
+
+func New160() hash.Hash {
+	return newKeccak(160, stdRounds)
+}
+
+func New224() hash.Hash {
+	return newKeccak(224, stdRounds)
+}
+
+func New256() hash.Hash {
+	return newKeccak(256, stdRounds)
+}
+
+func New384() hash.Hash {
+	return newKeccak(384, stdRounds)
+}
+
+func New512() hash.Hash {
+	return newKeccak(512, stdRounds)
+}
+
+func (k *keccak) Write(b []byte) (int, error) {
+	n := len(b)
+
+	if len(k.buf) > 0 {
+		x := k.blockSize - len(k.buf)
+		if x > len(b) {
+			x = len(b)
+		}
+		k.buf = append(k.buf, b[:x]...)
+		b = b[x:]
+
+		if len(k.buf) < k.blockSize {
+			return n, nil
+		}
+
+		k.f(k.buf)
+		k.buf = nil
+	}
+
+	for len(b) >= k.blockSize {
+		k.f(b[:k.blockSize])
+		b = b[k.blockSize:]
+	}
+
+	k.buf = b
+
+	return n, nil
+}
+
+func (k0 *keccak) Sum(b []byte) []byte {
+
+	k := *k0
+
+	last := k.pad(k.buf)
+	k.f(last)
+
+	buf := make([]byte, len(k.S)*8)
+	for i := range k.S {
+		putUint64le(buf[i*8:], k.S[i])
+	}
+	return append(b, buf[:k.size]...)
+}
+
+func (k *keccak) Reset() {
+	for i := range k.S {
+		k.S[i] = 0
+	}
+	k.buf = nil
+}
+
+func (k *keccak) Size() int {
+	return k.size
+}
+
+func (k *keccak) BlockSize() int {
+	return k.blockSize
+}
+
+func rotl64(x uint64, n uint) uint64 {
+	return (x << n) | (x >> (64 - n))
+}
+
+func (k *keccak) f(block []byte) {
+
+	if len(block) != k.blockSize {
+		panic("f() called with invalid block size")
+	}
+
+	for i := 0; i < k.blockSize/8; i++ {
+		k.S[i] ^= uint64le(block[i*8:])
+	}
+
+	for r := 0; r < k.rounds; r++ {
+		var bc [5]uint64
+
+		// theta
+		for i := range bc {
+			bc[i] = k.S[i] ^ k.S[5+i] ^ k.S[10+i] ^ k.S[15+i] ^ k.S[20+i]
+		}
+		for i := range bc {
+			t := bc[(i+4)%5] ^ rotl64(bc[(i+1)%5], 1)
+			for j := 0; j < len(k.S); j += 5 {
+				k.S[i+j] ^= t
+			}
+		}
+
+		// rho phi
+		temp := k.S[1]
+		for i := range piLane {
+			j := piLane[i]
+			temp2 := k.S[j]
+			k.S[j] = rotl64(temp, rotationConstants[i])
+			temp = temp2
+		}
+
+		// chi
+		for j := 0; j < len(k.S); j += 5 {
+			for i := range bc {
+				bc[i] = k.S[j+i]
+			}
+			for i := range bc {
+				k.S[j+i] ^= (^bc[(i+1)%5]) & bc[(i+2)%5]
+			}
+		}
+
+		// iota
+		k.S[0] ^= roundConstants[r]
+	}
+}
+
+func (k *keccak) pad(block []byte) []byte {
+
+	padded := make([]byte, k.blockSize)
+
+	copy(padded, k.buf)
+	padded[len(k.buf)] = 0x01
+	padded[len(padded)-1] |= 0x80
+
+	return padded
+}
+
+func uint64le(v []byte) uint64 {
+	return uint64(v[0]) |
+		uint64(v[1])<<8 |
+		uint64(v[2])<<16 |
+		uint64(v[3])<<24 |
+		uint64(v[4])<<32 |
+		uint64(v[5])<<40 |
+		uint64(v[6])<<48 |
+		uint64(v[7])<<56
+
+}
+
+func putUint64le(v []byte, x uint64) {
+	v[0] = byte(x)
+	v[1] = byte(x >> 8)
+	v[2] = byte(x >> 16)
+	v[3] = byte(x >> 24)
+	v[4] = byte(x >> 32)
+	v[5] = byte(x >> 40)
+	v[6] = byte(x >> 48)
+	v[7] = byte(x >> 56)
+}
diff --git a/vendor/github.com/gxed/hashland/murmur3/LICENSE b/vendor/github.com/gxed/hashland/murmur3/LICENSE
new file mode 100644
index 000000000..2a46fd750
--- /dev/null
+++ b/vendor/github.com/gxed/hashland/murmur3/LICENSE
@@ -0,0 +1,24 @@
+Copyright 2013, Sébastien Paolacci.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the library nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/ipfs/go-log/LICENSE b/vendor/github.com/ipfs/go-log/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/ipfs/go-log/context.go b/vendor/github.com/ipfs/go-log/context.go
new file mode 100644
index 000000000..b8ef5bc83
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/context.go
@@ -0,0 +1,38 @@
+package log
+
+import (
+	"context"
+	"errors"
+)
+
+type key int
+
+const metadataKey key = 0
+
+// ContextWithLoggable returns a derived context which contains the provided
+// Loggable. Any Events logged with the derived context will include the
+// provided Loggable.
+func ContextWithLoggable(ctx context.Context, l Loggable) context.Context {
+	existing, err := MetadataFromContext(ctx)
+	if err != nil {
+		// context does not contain meta. just set the new metadata
+		child := context.WithValue(ctx, metadataKey, Metadata(l.Loggable()))
+		return child
+	}
+
+	merged := DeepMerge(existing, l.Loggable())
+	child := context.WithValue(ctx, metadataKey, merged)
+	return child
+}
+
+// MetadataFromContext extracts Matadata from a given context's value.
+func MetadataFromContext(ctx context.Context) (Metadata, error) {
+	value := ctx.Value(metadataKey)
+	if value != nil {
+		metadata, ok := value.(Metadata)
+		if ok {
+			return metadata, nil
+		}
+	}
+	return nil, errors.New("context contains no metadata")
+}
diff --git a/vendor/github.com/ipfs/go-log/entry.go b/vendor/github.com/ipfs/go-log/entry.go
new file mode 100644
index 000000000..63c02135c
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/entry.go
@@ -0,0 +1,7 @@
+package log
+
+type entry struct {
+	loggables []Loggable
+	system    string
+	event     string
+}
diff --git a/vendor/github.com/ipfs/go-log/log.go b/vendor/github.com/ipfs/go-log/log.go
new file mode 100644
index 000000000..7732d7db8
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/log.go
@@ -0,0 +1,397 @@
+// Package log is the logging library used by IPFS
+// (https://github.com/ipfs/go-ipfs). It uses a modified version of
+// https://godoc.org/github.com/whyrusleeping/go-logging .
+package log
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"path"
+	"runtime"
+	"time"
+
+	writer "github.com/ipfs/go-log/writer"
+
+	opentrace "github.com/opentracing/opentracing-go"
+	otExt "github.com/opentracing/opentracing-go/ext"
+)
+
+var log = Logger("eventlog")
+
+// StandardLogger provides API compatibility with standard printf loggers
+// eg. go-logging
+type StandardLogger interface {
+	Debug(args ...interface{})
+	Debugf(format string, args ...interface{})
+	Error(args ...interface{})
+	Errorf(format string, args ...interface{})
+	Fatal(args ...interface{})
+	Fatalf(format string, args ...interface{})
+	Info(args ...interface{})
+	Infof(format string, args ...interface{})
+	Panic(args ...interface{})
+	Panicf(format string, args ...interface{})
+	Warning(args ...interface{})
+	Warningf(format string, args ...interface{})
+}
+
+// EventLogger extends the StandardLogger interface to allow for log items
+// containing structured metadata
+type EventLogger interface {
+	StandardLogger
+
+	// Event merges structured data from the provided inputs into a single
+	// machine-readable log event.
+	//
+	// If the context contains metadata, a copy of this is used as the base
+	// metadata accumulator.
+	//
+	// If one or more loggable objects are provided, these are deep-merged into base blob.
+	//
+	// Next, the event name is added to the blob under the key "event". If
+	// the key "event" already exists, it will be over-written.
+	//
+	// Finally the timestamp and package name are added to the accumulator and
+	// the metadata is logged.
+	// DEPRECATED
+	Event(ctx context.Context, event string, m ...Loggable)
+
+	// DEPRECATED
+	EventBegin(ctx context.Context, event string, m ...Loggable) *EventInProgress
+
+	// Start starts an opentracing span with `name`, using
+	// any Span found within `ctx` as a ChildOfRef. If no such parent could be
+	// found, Start creates a root (parentless) Span.
+	//
+	// The return value is a context.Context object built around the
+	// returned Span.
+	//
+	// Example usage:
+	//
+	//    SomeFunction(ctx context.Context, ...) {
+	//        ctx := log.Start(ctx, "SomeFunction")
+	//        defer log.Finish(ctx)
+	//        ...
+	//    }
+	Start(ctx context.Context, name string) context.Context
+
+	// StartFromParentState starts an opentracing span with `name`, using
+	// any Span found within `ctx` as a ChildOfRef. If no such parent could be
+	// found, StartSpanFromParentState creates a root (parentless) Span.
+	//
+	// StartFromParentState will attempt to deserialize a SpanContext from `parent`,
+	// using any Span found within to continue the trace
+	//
+	// The return value is a context.Context object built around the
+	// returned Span.
+	//
+	// An error is returned when `parent` cannot be deserialized to a SpanContext
+	//
+	// Example usage:
+	//
+	//    SomeFunction(ctx context.Context, bParent []byte) {
+	//        ctx := log.StartFromParentState(ctx, "SomeFunction", bParent)
+	//        defer log.Finish(ctx)
+	//        ...
+	//    }
+	StartFromParentState(ctx context.Context, name string, parent []byte) (context.Context, error)
+
+	// Finish completes the span associated with `ctx`.
+	//
+	// Finish() must be the last call made to any span instance, and to do
+	// otherwise leads to undefined behavior.
+	// Finish will do its best to notify (log) when used in correctly
+	//		.e.g called twice, or called on a spanless `ctx`
+	Finish(ctx context.Context)
+
+	// FinishWithErr completes the span associated with `ctx` and also calls
+	// SetErr if `err` is non-nil
+	//
+	// FinishWithErr() must be the last call made to any span instance, and to do
+	// otherwise leads to undefined behavior.
+	// FinishWithErr will do its best to notify (log) when used in correctly
+	//		.e.g called twice, or called on a spanless `ctx`
+	FinishWithErr(ctx context.Context, err error)
+
+	// SetErr tags the span associated with `ctx` to reflect an error occured, and
+	// logs the value `err` under key `error`.
+	SetErr(ctx context.Context, err error)
+
+	// LogKV records key:value logging data about an event stored in `ctx`
+	// Eexample:
+	//    log.LogKV(
+	//        "error", "resolve failure",
+	//        "type", "cache timeout",
+	//        "waited.millis", 1500)
+	LogKV(ctx context.Context, alternatingKeyValues ...interface{})
+
+	// SetTag tags key `k` and value `v` on the span associated with `ctx`
+	SetTag(ctx context.Context, key string, value interface{})
+
+	// SetTags tags keys from the `tags` maps on the span associated with `ctx`
+	// Example:
+	//    log.SetTags(ctx, map[string]{
+	//		"type": bizStruct,
+	//      "request": req,
+	//		})
+	SetTags(ctx context.Context, tags map[string]interface{})
+
+	// SerializeContext takes the SpanContext instance stored in `ctx` and Seralizes
+	// it to bytes. An error is returned if the `ctx` cannot be serialized to
+	// a bytes array
+	SerializeContext(ctx context.Context) ([]byte, error)
+}
+
+// Logger retrieves an event logger by name
+func Logger(system string) EventLogger {
+
+	// TODO if we would like to adjust log levels at run-time. Store this event
+	// logger in a map (just like the util.Logger impl)
+	if len(system) == 0 {
+		setuplog := getLogger("setup-logger")
+		setuplog.Warning("Missing name parameter")
+		system = "undefined"
+	}
+
+	logger := getLogger(system)
+
+	return &eventLogger{system: system, StandardLogger: logger}
+}
+
+// eventLogger implements the EventLogger and wraps a go-logging Logger
+type eventLogger struct {
+	StandardLogger
+
+	system string
+	// TODO add log-level
+}
+
+func (el *eventLogger) Start(ctx context.Context, operationName string) context.Context {
+	span, ctx := opentrace.StartSpanFromContext(ctx, operationName)
+	span.SetTag("system", el.system)
+	return ctx
+}
+
+func (el *eventLogger) StartFromParentState(ctx context.Context, operationName string, parent []byte) (context.Context, error) {
+	sc, err := deserializeContext(parent)
+	if err != nil {
+		return nil, err
+	}
+
+	//TODO RPCServerOption is probably not the best tag, as this is likely from a peer
+	span, ctx := opentrace.StartSpanFromContext(ctx, operationName, otExt.RPCServerOption(sc))
+	span.SetTag("system", el.system)
+	return ctx, nil
+}
+
+func (el *eventLogger) SerializeContext(ctx context.Context) ([]byte, error) {
+	gTracer := opentrace.GlobalTracer()
+	b := make([]byte, 0)
+	carrier := bytes.NewBuffer(b)
+	span := opentrace.SpanFromContext(ctx)
+	if err := gTracer.Inject(span.Context(), opentrace.Binary, carrier); err != nil {
+		return nil, err
+	}
+	return carrier.Bytes(), nil
+}
+
+func (el *eventLogger) LogKV(ctx context.Context, alternatingKeyValues ...interface{}) {
+	span := opentrace.SpanFromContext(ctx)
+	if span == nil {
+		_, file, line, _ := runtime.Caller(1)
+		log.Errorf("LogKV with no Span in context called on %s:%d", path.Base(file), line)
+		return
+	}
+	span.LogKV(alternatingKeyValues...)
+}
+
+func (el *eventLogger) SetTag(ctx context.Context, k string, v interface{}) {
+	span := opentrace.SpanFromContext(ctx)
+	if span == nil {
+		_, file, line, _ := runtime.Caller(1)
+		log.Errorf("SetTag with no Span in context called on %s:%d", path.Base(file), line)
+		return
+	}
+	span.SetTag(k, v)
+}
+
+func (el *eventLogger) SetTags(ctx context.Context, tags map[string]interface{}) {
+	span := opentrace.SpanFromContext(ctx)
+	if span == nil {
+		_, file, line, _ := runtime.Caller(1)
+		log.Errorf("SetTags with no Span in context called on %s:%d", path.Base(file), line)
+		return
+	}
+	for k, v := range tags {
+		span.SetTag(k, v)
+	}
+}
+
+func (el *eventLogger) SetErr(ctx context.Context, err error) {
+	span := opentrace.SpanFromContext(ctx)
+	if span == nil {
+		_, file, line, _ := runtime.Caller(1)
+		log.Errorf("SetErr with no Span in context called on %s:%d", path.Base(file), line)
+		return
+	}
+	if err == nil {
+		return
+	}
+
+	otExt.Error.Set(span, true)
+	span.LogKV("error", err.Error())
+}
+
+func (el *eventLogger) Finish(ctx context.Context) {
+	span := opentrace.SpanFromContext(ctx)
+	if span == nil {
+		_, file, line, _ := runtime.Caller(1)
+		log.Errorf("Finish with no Span in context called on %s:%d", path.Base(file), line)
+		return
+	}
+	span.Finish()
+}
+
+func (el *eventLogger) FinishWithErr(ctx context.Context, err error) {
+	el.SetErr(ctx, err)
+	el.Finish(ctx)
+}
+
+func deserializeContext(bCtx []byte) (opentrace.SpanContext, error) {
+	gTracer := opentrace.GlobalTracer()
+	carrier := bytes.NewReader(bCtx)
+	spanContext, err := gTracer.Extract(opentrace.Binary, carrier)
+	if err != nil {
+		log.Warning("Failed to deserialize context %s", err)
+		return nil, err
+	}
+	return spanContext, nil
+}
+
+// DEPRECATED use `Start`
+func (el *eventLogger) EventBegin(ctx context.Context, event string, metadata ...Loggable) *EventInProgress {
+	ctx = el.Start(ctx, event)
+
+	for _, m := range metadata {
+		for l, v := range m.Loggable() {
+			el.LogKV(ctx, l, v)
+		}
+	}
+
+	eip := &EventInProgress{}
+	eip.doneFunc = func(additional []Loggable) {
+		// anything added during the operation
+		// e.g. deprecated methods event.Append(...) or event.SetError(...)
+		for _, m := range eip.loggables {
+			for l, v := range m.Loggable() {
+				el.LogKV(ctx, l, v)
+			}
+		}
+		el.Finish(ctx)
+	}
+	return eip
+}
+
+type activeEventKeyType struct{}
+
+var activeEventKey = activeEventKeyType{}
+
+// DEPRECATED use `Start`
+func (el *eventLogger) Event(ctx context.Context, event string, metadata ...Loggable) {
+
+	// short circuit if theres nothing to write to
+	if !writer.WriterGroup.Active() {
+		return
+	}
+
+	// Collect loggables for later logging
+	var loggables []Loggable
+
+	// get any existing metadata from the context
+	existing, err := MetadataFromContext(ctx)
+	if err != nil {
+		existing = Metadata{}
+	}
+	loggables = append(loggables, existing)
+
+	for _, datum := range metadata {
+		loggables = append(loggables, datum)
+	}
+
+	e := entry{
+		loggables: loggables,
+		system:    el.system,
+		event:     event,
+	}
+
+	accum := Metadata{}
+	for _, loggable := range e.loggables {
+		accum = DeepMerge(accum, loggable.Loggable())
+	}
+
+	// apply final attributes to reserved keys
+	// TODO accum["level"] = level
+	accum["event"] = e.event
+	accum["system"] = e.system
+	accum["time"] = FormatRFC3339(time.Now())
+
+	out, err := json.Marshal(accum)
+	if err != nil {
+		el.Errorf("ERROR FORMATTING EVENT ENTRY: %s", err)
+		return
+	}
+
+	writer.WriterGroup.Write(append(out, '\n'))
+}
+
+// DEPRECATED
+// EventInProgress represent and event which is happening
+type EventInProgress struct {
+	loggables []Loggable
+	doneFunc  func([]Loggable)
+}
+
+// DEPRECATED use `LogKV` or `SetTag`
+// Append adds loggables to be included in the call to Done
+func (eip *EventInProgress) Append(l Loggable) {
+	eip.loggables = append(eip.loggables, l)
+}
+
+// DEPRECATED use `SetError(ctx, error)`
+// SetError includes the provided error
+func (eip *EventInProgress) SetError(err error) {
+	eip.loggables = append(eip.loggables, LoggableMap{
+		"error": err.Error(),
+	})
+}
+
+// DEPRECATED use `Finish`
+// Done creates a new Event entry that includes the duration and appended
+// loggables.
+func (eip *EventInProgress) Done() {
+	eip.doneFunc(eip.loggables) // create final event with extra data
+}
+
+// DEPRECATED use `FinishWithErr`
+// DoneWithErr creates a new Event entry that includes the duration and appended
+// loggables. DoneWithErr accepts an error, if err is non-nil, it is set on
+// the EventInProgress. Otherwise the logic is the same as the `Done()` method
+func (eip *EventInProgress) DoneWithErr(err error) {
+	if err != nil {
+		eip.SetError(err)
+	}
+	eip.doneFunc(eip.loggables)
+}
+
+// DEPRECATED use `Finish`
+// Close is an alias for done
+func (eip *EventInProgress) Close() error {
+	eip.Done()
+	return nil
+}
+
+// FormatRFC3339 returns the given time in UTC with RFC3999Nano format.
+func FormatRFC3339(t time.Time) string {
+	return t.UTC().Format(time.RFC3339Nano)
+}
diff --git a/vendor/github.com/ipfs/go-log/loggable.go b/vendor/github.com/ipfs/go-log/loggable.go
new file mode 100644
index 000000000..f4edb2684
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/loggable.go
@@ -0,0 +1,42 @@
+package log
+
+// Loggable describes objects that can be marshalled into Metadata for logging
+type Loggable interface {
+	Loggable() map[string]interface{}
+}
+
+// LoggableMap is just a generic map keyed by string. It
+// implements the Loggable interface.
+type LoggableMap map[string]interface{}
+
+// Loggable implements the Loggable interface for LoggableMap
+func (l LoggableMap) Loggable() map[string]interface{} {
+	return l
+}
+
+// LoggableF converts a func into a Loggable
+type LoggableF func() map[string]interface{}
+
+// Loggable implements the Loggable interface by running
+// the LoggableF function.
+func (l LoggableF) Loggable() map[string]interface{} {
+	return l()
+}
+
+// Deferred returns a LoggableF where the execution of the
+// provided function is deferred.
+func Deferred(key string, f func() string) Loggable {
+	function := func() map[string]interface{} {
+		return map[string]interface{}{
+			key: f(),
+		}
+	}
+	return LoggableF(function)
+}
+
+// Pair returns a Loggable where key is paired to Loggable.
+func Pair(key string, l Loggable) Loggable {
+	return LoggableMap{
+		key: l,
+	}
+}
diff --git a/vendor/github.com/ipfs/go-log/metadata.go b/vendor/github.com/ipfs/go-log/metadata.go
new file mode 100644
index 000000000..07947b54a
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/metadata.go
@@ -0,0 +1,77 @@
+package log
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+)
+
+// Metadata is a convenience type for generic maps
+type Metadata map[string]interface{}
+
+// DeepMerge merges the second Metadata parameter into the first.
+// Nested Metadata are merged recursively. Primitives are over-written.
+func DeepMerge(b, a Metadata) Metadata {
+	out := Metadata{}
+	for k, v := range b {
+		out[k] = v
+	}
+	for k, v := range a {
+
+		maybe, err := Metadatify(v)
+		if err != nil {
+			// if the new value is not meta. just overwrite the dest vaue
+			if out[k] != nil {
+				log.Debugf("Overwriting key: %s, old: %s, new: %s", k, out[k], v)
+			}
+			out[k] = v
+			continue
+		}
+
+		// it is meta. What about dest?
+		outv, exists := out[k]
+		if !exists {
+			// the new value is meta, but there's no dest value. just write it
+			out[k] = v
+			continue
+		}
+
+		outMetadataValue, err := Metadatify(outv)
+		if err != nil {
+			// the new value is meta and there's a dest value, but the dest
+			// value isn't meta. just overwrite
+			out[k] = v
+			continue
+		}
+
+		// both are meta. merge them.
+		out[k] = DeepMerge(outMetadataValue, maybe)
+	}
+	return out
+}
+
+// Loggable implements the Loggable interface.
+func (m Metadata) Loggable() map[string]interface{} {
+	// NB: method defined on value to avoid de-referencing nil Metadata
+	return m
+}
+
+// JsonString returns the marshaled JSON string for the metadata.
+func (m Metadata) JsonString() (string, error) {
+	// NB: method defined on value
+	b, err := json.Marshal(m)
+	return string(b), err
+}
+
+// Metadatify converts maps into Metadata.
+func Metadatify(i interface{}) (Metadata, error) {
+	value := reflect.ValueOf(i)
+	if value.Kind() == reflect.Map {
+		m := map[string]interface{}{}
+		for _, k := range value.MapKeys() {
+			m[k.String()] = value.MapIndex(k).Interface()
+		}
+		return Metadata(m), nil
+	}
+	return nil, errors.New("is not a map")
+}
diff --git a/vendor/github.com/ipfs/go-log/oldlog.go b/vendor/github.com/ipfs/go-log/oldlog.go
new file mode 100644
index 000000000..bb0396e69
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/oldlog.go
@@ -0,0 +1,126 @@
+package log
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	tracer "github.com/ipfs/go-log/tracer"
+
+	colorable "github.com/mattn/go-colorable"
+	opentrace "github.com/opentracing/opentracing-go"
+	logging "github.com/whyrusleeping/go-logging"
+)
+
+func init() {
+	SetupLogging()
+}
+
+var ansiGray = "\033[0;37m"
+var ansiBlue = "\033[0;34m"
+
+// LogFormats defines formats for logging (i.e. "color")
+var LogFormats = map[string]string{
+	"nocolor": "%{time:2006-01-02 15:04:05.000000} %{level} %{module} %{shortfile}: %{message}",
+	"color": ansiGray + "%{time:15:04:05.000} %{color}%{level:5.5s} " + ansiBlue +
+		"%{module:10.10s}: %{color:reset}%{message} " + ansiGray + "%{shortfile}%{color:reset}",
+}
+
+var defaultLogFormat = "color"
+
+// Logging environment variables
+const (
+	envLogging    = "IPFS_LOGGING"
+	envLoggingFmt = "IPFS_LOGGING_FMT"
+)
+
+// ErrNoSuchLogger is returned when the util pkg is asked for a non existant logger
+var ErrNoSuchLogger = errors.New("Error: No such logger")
+
+// loggers is the set of loggers in the system
+var loggers = map[string]*logging.Logger{}
+
+// SetupLogging will initialize the logger backend and set the flags.
+func SetupLogging() {
+
+	lfmt := LogFormats[os.Getenv(envLoggingFmt)]
+	if lfmt == "" {
+		lfmt = LogFormats[defaultLogFormat]
+	}
+
+	backend := logging.NewLogBackend(colorable.NewColorableStderr(), "", 0)
+	logging.SetBackend(backend)
+	logging.SetFormatter(logging.MustStringFormatter(lfmt))
+
+	lvl := logging.ERROR
+
+	if logenv := os.Getenv(envLogging); logenv != "" {
+		var err error
+		lvl, err = logging.LogLevel(logenv)
+		if err != nil {
+			fmt.Println("error setting log levels", err)
+		}
+	}
+
+	// TracerPlugins are instantiated after this, so use loggable tracer
+	// by default, if a TracerPlugin is added it will override this
+	lgblRecorder := tracer.NewLoggableRecorder()
+	lgblTracer := tracer.New(lgblRecorder)
+	opentrace.SetGlobalTracer(lgblTracer)
+
+	SetAllLoggers(lvl)
+}
+
+// SetDebugLogging calls SetAllLoggers with logging.DEBUG
+func SetDebugLogging() {
+	SetAllLoggers(logging.DEBUG)
+}
+
+// SetAllLoggers changes the logging.Level of all loggers to lvl
+func SetAllLoggers(lvl logging.Level) {
+	logging.SetLevel(lvl, "")
+	for n := range loggers {
+		logging.SetLevel(lvl, n)
+	}
+}
+
+// SetLogLevel changes the log level of a specific subsystem
+// name=="*" changes all subsystems
+func SetLogLevel(name, level string) error {
+	lvl, err := logging.LogLevel(level)
+	if err != nil {
+		return err
+	}
+
+	// wildcard, change all
+	if name == "*" {
+		SetAllLoggers(lvl)
+		return nil
+	}
+
+	// Check if we have a logger by that name
+	if _, ok := loggers[name]; !ok {
+		return ErrNoSuchLogger
+	}
+
+	logging.SetLevel(lvl, name)
+
+	return nil
+}
+
+// GetSubsystems returns a slice containing the
+// names of the current loggers
+func GetSubsystems() []string {
+	subs := make([]string, 0, len(loggers))
+
+	for k := range loggers {
+		subs = append(subs, k)
+	}
+	return subs
+}
+
+func getLogger(name string) *logging.Logger {
+	log := logging.MustGetLogger(name)
+	loggers[name] = log
+	return log
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/LICENSE b/vendor/github.com/ipfs/go-log/tracer/LICENSE
new file mode 100644
index 000000000..148509a40
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 The OpenTracing Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/ipfs/go-log/tracer/context.go b/vendor/github.com/ipfs/go-log/tracer/context.go
new file mode 100644
index 000000000..f1ebf61f6
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/context.go
@@ -0,0 +1,42 @@
+package loggabletracer
+
+// SpanContext holds the basic Span metadata.
+type SpanContext struct {
+	// A probabilistically unique identifier for a [multi-span] trace.
+	TraceID uint64
+
+	// A probabilistically unique identifier for a span.
+	SpanID uint64
+
+	// Whether the trace is sampled.
+	Sampled bool
+
+	// The span's associated baggage.
+	Baggage map[string]string // initialized on first use
+}
+
+// ForeachBaggageItem belongs to the opentracing.SpanContext interface
+func (c SpanContext) ForeachBaggageItem(handler func(k, v string) bool) {
+	for k, v := range c.Baggage {
+		if !handler(k, v) {
+			break
+		}
+	}
+}
+
+// WithBaggageItem returns an entirely new loggabletracer SpanContext with the
+// given key:value baggage pair set.
+func (c SpanContext) WithBaggageItem(key, val string) SpanContext {
+	var newBaggage map[string]string
+	if c.Baggage == nil {
+		newBaggage = map[string]string{key: val}
+	} else {
+		newBaggage = make(map[string]string, len(c.Baggage)+1)
+		for k, v := range c.Baggage {
+			newBaggage[k] = v
+		}
+		newBaggage[key] = val
+	}
+	// Use positional parameters so the compiler will help catch new fields.
+	return SpanContext{c.TraceID, c.SpanID, c.Sampled, newBaggage}
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/debug.go b/vendor/github.com/ipfs/go-log/tracer/debug.go
new file mode 100644
index 000000000..8c302b370
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/debug.go
@@ -0,0 +1,78 @@
+package loggabletracer
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"sync"
+)
+
+const debugGoroutineIDTag = "_initial_goroutine"
+
+type errAssertionFailed struct {
+	span *spanImpl
+	msg  string
+}
+
+// Error implements the error interface.
+func (err *errAssertionFailed) Error() string {
+	return fmt.Sprintf("%s:\n%+v", err.msg, err.span)
+}
+
+func (s *spanImpl) Lock() {
+	s.Mutex.Lock()
+	s.maybeAssertSanityLocked()
+}
+
+func (s *spanImpl) maybeAssertSanityLocked() {
+	if s.tracer == nil {
+		s.Mutex.Unlock()
+		panic(&errAssertionFailed{span: s, msg: "span used after call to Finish()"})
+	}
+	if s.tracer.options.DebugAssertSingleGoroutine {
+		startID := curGoroutineID()
+		curID, ok := s.raw.Tags[debugGoroutineIDTag].(uint64)
+		if !ok {
+			// This is likely invoked in the context of the SetTag which sets
+			// debugGoroutineTag.
+			return
+		}
+		if startID != curID {
+			s.Mutex.Unlock()
+			panic(&errAssertionFailed{
+				span: s,
+				msg:  fmt.Sprintf("span started on goroutine %d, but now running on %d", startID, curID),
+			})
+		}
+	}
+}
+
+var goroutineSpace = []byte("goroutine ")
+var littleBuf = sync.Pool{
+	New: func() interface{} {
+		buf := make([]byte, 64)
+		return &buf
+	},
+}
+
+// Credit to @bradfitz:
+// https://github.com/golang/net/blob/master/http2/gotrack.go#L51
+func curGoroutineID() uint64 {
+	bp := littleBuf.Get().(*[]byte)
+	defer littleBuf.Put(bp)
+	b := *bp
+	b = b[:runtime.Stack(b, false)]
+	// Parse the 4707 out of "goroutine 4707 ["
+	b = bytes.TrimPrefix(b, goroutineSpace)
+	i := bytes.IndexByte(b, ' ')
+	if i < 0 {
+		panic(fmt.Sprintf("No space found in %q", b))
+	}
+	b = b[:i]
+	n, err := strconv.ParseUint(string(b), 10, 64)
+	if err != nil {
+		panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
+	}
+	return n
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/event.go b/vendor/github.com/ipfs/go-log/tracer/event.go
new file mode 100644
index 000000000..9dbcb76a6
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/event.go
@@ -0,0 +1,62 @@
+package loggabletracer
+
+import "github.com/opentracing/opentracing-go"
+
+// A SpanEvent is emitted when a mutating command is called on a Span.
+type SpanEvent interface{}
+
+// EventCreate is emitted when a Span is created.
+type EventCreate struct{ OperationName string }
+
+// EventTag is received when SetTag is called.
+type EventTag struct {
+	Key   string
+	Value interface{}
+}
+
+// EventBaggage is received when SetBaggageItem is called.
+type EventBaggage struct {
+	Key, Value string
+}
+
+// EventLogFields is received when LogFields or LogKV is called.
+type EventLogFields opentracing.LogRecord
+
+// EventLog is received when Log (or one of its derivatives) is called.
+//
+// DEPRECATED
+type EventLog opentracing.LogData
+
+// EventFinish is received when Finish is called.
+type EventFinish RawSpan
+
+func (s *spanImpl) onCreate(opName string) {
+	if s.event != nil {
+		s.event(EventCreate{OperationName: opName})
+	}
+}
+func (s *spanImpl) onTag(key string, value interface{}) {
+	if s.event != nil {
+		s.event(EventTag{Key: key, Value: value})
+	}
+}
+func (s *spanImpl) onLog(ld opentracing.LogData) {
+	if s.event != nil {
+		s.event(EventLog(ld))
+	}
+}
+func (s *spanImpl) onLogFields(lr opentracing.LogRecord) {
+	if s.event != nil {
+		s.event(EventLogFields(lr))
+	}
+}
+func (s *spanImpl) onBaggage(key, value string) {
+	if s.event != nil {
+		s.event(EventBaggage{Key: key, Value: value})
+	}
+}
+func (s *spanImpl) onFinish(sp RawSpan) {
+	if s.event != nil {
+		s.event(EventFinish(sp))
+	}
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/propagation.go b/vendor/github.com/ipfs/go-log/tracer/propagation.go
new file mode 100644
index 000000000..bb2106597
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/propagation.go
@@ -0,0 +1,61 @@
+package loggabletracer
+
+import opentracing "github.com/opentracing/opentracing-go"
+
+type accessorPropagator struct {
+	tracer *LoggableTracer
+}
+
+// DelegatingCarrier is a flexible carrier interface which can be implemented
+// by types which have a means of storing the trace metadata and already know
+// how to serialize themselves (for example, protocol buffers).
+type DelegatingCarrier interface {
+	SetState(traceID, spanID uint64, sampled bool)
+	State() (traceID, spanID uint64, sampled bool)
+	SetBaggageItem(key, value string)
+	GetBaggage(func(key, value string))
+}
+
+func (p *accessorPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	carrier interface{},
+) error {
+	dc, ok := carrier.(DelegatingCarrier)
+	if !ok || dc == nil {
+		return opentracing.ErrInvalidCarrier
+	}
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	dc.SetState(sc.TraceID, sc.SpanID, sc.Sampled)
+	for k, v := range sc.Baggage {
+		dc.SetBaggageItem(k, v)
+	}
+	return nil
+}
+
+func (p *accessorPropagator) Extract(
+	carrier interface{},
+) (opentracing.SpanContext, error) {
+	dc, ok := carrier.(DelegatingCarrier)
+	if !ok || dc == nil {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+
+	traceID, spanID, sampled := dc.State()
+	sc := SpanContext{
+		TraceID: traceID,
+		SpanID:  spanID,
+		Sampled: sampled,
+		Baggage: nil,
+	}
+	dc.GetBaggage(func(k, v string) {
+		if sc.Baggage == nil {
+			sc.Baggage = map[string]string{}
+		}
+		sc.Baggage[k] = v
+	})
+
+	return sc, nil
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/propagation_ot.go b/vendor/github.com/ipfs/go-log/tracer/propagation_ot.go
new file mode 100644
index 000000000..4a4782ead
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/propagation_ot.go
@@ -0,0 +1,180 @@
+package loggabletracer
+
+import (
+	"encoding/binary"
+	"io"
+	"strconv"
+	"strings"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/ipfs/go-log/tracer/wire"
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+type textMapPropagator struct {
+	tracer *LoggableTracer
+}
+type binaryPropagator struct {
+	tracer *LoggableTracer
+}
+
+const (
+	prefixTracerState = "ot-tracer-"
+	prefixBaggage     = "ot-baggage-"
+
+	tracerStateFieldCount = 3
+	fieldNameTraceID      = prefixTracerState + "traceid"
+	fieldNameSpanID       = prefixTracerState + "spanid"
+	fieldNameSampled      = prefixTracerState + "sampled"
+)
+
+func (p *textMapPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	opaqueCarrier interface{},
+) error {
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	carrier, ok := opaqueCarrier.(opentracing.TextMapWriter)
+	if !ok {
+		return opentracing.ErrInvalidCarrier
+	}
+	carrier.Set(fieldNameTraceID, strconv.FormatUint(sc.TraceID, 16))
+	carrier.Set(fieldNameSpanID, strconv.FormatUint(sc.SpanID, 16))
+	carrier.Set(fieldNameSampled, strconv.FormatBool(sc.Sampled))
+
+	for k, v := range sc.Baggage {
+		carrier.Set(prefixBaggage+k, v)
+	}
+	return nil
+}
+
+func (p *textMapPropagator) Extract(
+	opaqueCarrier interface{},
+) (opentracing.SpanContext, error) {
+	carrier, ok := opaqueCarrier.(opentracing.TextMapReader)
+	if !ok {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+	requiredFieldCount := 0
+	var traceID, spanID uint64
+	var sampled bool
+	var err error
+	decodedBaggage := make(map[string]string)
+	err = carrier.ForeachKey(func(k, v string) error {
+		switch strings.ToLower(k) {
+		case fieldNameTraceID:
+			traceID, err = strconv.ParseUint(v, 16, 64)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		case fieldNameSpanID:
+			spanID, err = strconv.ParseUint(v, 16, 64)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		case fieldNameSampled:
+			sampled, err = strconv.ParseBool(v)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		default:
+			lowercaseK := strings.ToLower(k)
+			if strings.HasPrefix(lowercaseK, prefixBaggage) {
+				decodedBaggage[strings.TrimPrefix(lowercaseK, prefixBaggage)] = v
+			}
+			// Balance off the requiredFieldCount++ just below...
+			requiredFieldCount--
+		}
+		requiredFieldCount++
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if requiredFieldCount < tracerStateFieldCount {
+		if requiredFieldCount == 0 {
+			return nil, opentracing.ErrSpanContextNotFound
+		}
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+
+	return SpanContext{
+		TraceID: traceID,
+		SpanID:  spanID,
+		Sampled: sampled,
+		Baggage: decodedBaggage,
+	}, nil
+}
+
+func (p *binaryPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	opaqueCarrier interface{},
+) error {
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	carrier, ok := opaqueCarrier.(io.Writer)
+	if !ok {
+		return opentracing.ErrInvalidCarrier
+	}
+
+	state := wire.TracerState{}
+	state.TraceId = sc.TraceID
+	state.SpanId = sc.SpanID
+	state.Sampled = sc.Sampled
+	state.BaggageItems = sc.Baggage
+
+	b, err := proto.Marshal(&state)
+	if err != nil {
+		return err
+	}
+
+	// Write the length of the marshalled binary to the writer.
+	length := uint32(len(b))
+	if err := binary.Write(carrier, binary.BigEndian, &length); err != nil {
+		return err
+	}
+
+	_, err = carrier.Write(b)
+	return err
+}
+
+func (p *binaryPropagator) Extract(
+	opaqueCarrier interface{},
+) (opentracing.SpanContext, error) {
+	carrier, ok := opaqueCarrier.(io.Reader)
+	if !ok {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+
+	// Read the length of marshalled binary. io.ReadAll isn't that performant
+	// since it keeps resizing the underlying buffer as it encounters more bytes
+	// to read. By reading the length, we can allocate a fixed sized buf and read
+	// the exact amount of bytes into it.
+	var length uint32
+	if err := binary.Read(carrier, binary.BigEndian, &length); err != nil {
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+	buf := make([]byte, length)
+	if n, err := carrier.Read(buf); err != nil {
+		if n > 0 {
+			return nil, opentracing.ErrSpanContextCorrupted
+		}
+		return nil, opentracing.ErrSpanContextNotFound
+	}
+
+	ctx := wire.TracerState{}
+	if err := proto.Unmarshal(buf, &ctx); err != nil {
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+
+	return SpanContext{
+		TraceID: ctx.TraceId,
+		SpanID:  ctx.SpanId,
+		Sampled: ctx.Sampled,
+		Baggage: ctx.BaggageItems,
+	}, nil
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/raw.go b/vendor/github.com/ipfs/go-log/tracer/raw.go
new file mode 100644
index 000000000..759454274
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/raw.go
@@ -0,0 +1,34 @@
+package loggabletracer
+
+import (
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+// RawSpan encapsulates all state associated with a (finished) Span.
+type RawSpan struct {
+	// Those recording the RawSpan should also record the contents of its
+	// SpanContext.
+	Context SpanContext
+
+	// The SpanID of this SpanContext's first intra-trace reference (i.e.,
+	// "parent"), or 0 if there is no parent.
+	ParentSpanID uint64
+
+	// The name of the "operation" this span is an instance of. (Called a "span
+	// name" in some implementations)
+	Operation string
+
+	// We store <start, duration> rather than <start, end> so that only
+	// one of the timestamps has global clock uncertainty issues.
+	Start    time.Time
+	Duration time.Duration
+
+	// Essentially an extension mechanism. Can be used for many purposes,
+	// not to be enumerated here.
+	Tags opentracing.Tags
+
+	// The span's "microlog".
+	Logs []opentracing.LogRecord
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/recorder.go b/vendor/github.com/ipfs/go-log/tracer/recorder.go
new file mode 100644
index 000000000..60ed1f8cb
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/recorder.go
@@ -0,0 +1,86 @@
+package loggabletracer
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	writer "github.com/ipfs/go-log/writer"
+	opentrace "github.com/opentracing/opentracing-go"
+)
+
+// A SpanRecorder handles all of the `RawSpan` data generated via an
+// associated `Tracer` (see `NewStandardTracer`) instance. It also names
+// the containing process and provides access to a straightforward tag map.
+type SpanRecorder interface {
+	// Implementations must determine whether and where to store `span`.
+	RecordSpan(span RawSpan)
+}
+
+type LoggableSpanRecorder struct{}
+
+// NewLoggableRecorder creates new LoggableSpanRecorder
+func NewLoggableRecorder() *LoggableSpanRecorder {
+	return new(LoggableSpanRecorder)
+}
+
+// Loggable Representation of a span, treated as an event log
+type LoggableSpan struct {
+	TraceID      uint64         `json:"TraceID"`
+	SpanID       uint64         `json:"SpanID"`
+	ParentSpanID uint64         `json:"ParentSpanID"`
+	Operation    string         `json:"Operation"`
+	Start        time.Time      `json:"Start"`
+	Duration     time.Duration  `json:"Duration"`
+	Tags         opentrace.Tags `json:"Tags"`
+	Logs         []SpanLog      `json:"Logs"`
+}
+
+type SpanLog struct {
+	Timestamp time.Time   `json:"Timestamp"`
+	Field     []SpanField `json:"Fields"`
+}
+
+type SpanField struct {
+	Key   string `json:"Key"`
+	Value string `json:"Value"`
+}
+
+// RecordSpan implements the respective method of SpanRecorder.
+func (r *LoggableSpanRecorder) RecordSpan(span RawSpan) {
+	// short circuit if theres nothing to write to
+	if !writer.WriterGroup.Active() {
+		return
+	}
+
+	sl := make([]SpanLog, len(span.Logs))
+	for i := range span.Logs {
+		sl[i].Timestamp = span.Logs[i].Timestamp
+		sf := make([]SpanField, len(span.Logs[i].Fields))
+		sl[i].Field = sf
+		for j := range span.Logs[i].Fields {
+			sf[j].Key = span.Logs[i].Fields[j].Key()
+			sf[j].Value = fmt.Sprint(span.Logs[i].Fields[j].Value())
+		}
+	}
+
+	spanlog := &LoggableSpan{
+		TraceID:      span.Context.TraceID,
+		SpanID:       span.Context.SpanID,
+		ParentSpanID: span.ParentSpanID,
+		Operation:    span.Operation,
+		Start:        span.Start,
+		Duration:     span.Duration,
+		Tags:         span.Tags,
+		Logs:         sl,
+	}
+
+	out, err := json.Marshal(spanlog)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ERROR FORMATTING SPAN ENTRY: %s\n", err)
+		return
+	}
+
+	writer.WriterGroup.Write(append(out, '\n'))
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/span.go b/vendor/github.com/ipfs/go-log/tracer/span.go
new file mode 100644
index 000000000..a23a57c32
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/span.go
@@ -0,0 +1,274 @@
+package loggabletracer
+
+import (
+	"sync"
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go/ext"
+	"github.com/opentracing/opentracing-go/log"
+)
+
+// Span provides access to the essential details of the span, for use
+// by loggabletracer consumers.  These methods may only be called prior
+// to (*opentracing.Span).Finish().
+type Span interface {
+	opentracing.Span
+
+	// Operation names the work done by this span instance
+	Operation() string
+
+	// Start indicates when the span began
+	Start() time.Time
+}
+
+// Implements the `Span` interface. Created via LoggableTracer (see
+// `loggabletracer.New()`).
+type spanImpl struct {
+	tracer     *LoggableTracer
+	event      func(SpanEvent)
+	sync.Mutex // protects the fields below
+	raw        RawSpan
+	// The number of logs dropped because of MaxLogsPerSpan.
+	numDroppedLogs int
+}
+
+var spanPool = &sync.Pool{New: func() interface{} {
+	return &spanImpl{}
+}}
+
+func (s *spanImpl) reset() {
+	s.tracer, s.event = nil, nil
+	// Note: Would like to do the following, but then the consumer of RawSpan
+	// (the recorder) needs to make sure that they're not holding on to the
+	// baggage or logs when they return (i.e. they need to copy if they care):
+	//
+	//     logs, baggage := s.raw.Logs[:0], s.raw.Baggage
+	//     for k := range baggage {
+	//         delete(baggage, k)
+	//     }
+	//     s.raw.Logs, s.raw.Baggage = logs, baggage
+	//
+	// That's likely too much to ask for. But there is some magic we should
+	// be able to do with `runtime.SetFinalizer` to reclaim that memory into
+	// a buffer pool when GC considers them unreachable, which should ease
+	// some of the load. Hard to say how quickly that would be in practice
+	// though.
+	s.raw = RawSpan{
+		Context: SpanContext{},
+	}
+}
+
+func (s *spanImpl) SetOperationName(operationName string) opentracing.Span {
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Operation = operationName
+	return s
+}
+
+func (s *spanImpl) trim() bool {
+	return !s.raw.Context.Sampled && s.tracer.options.TrimUnsampledSpans
+}
+
+func (s *spanImpl) SetTag(key string, value interface{}) opentracing.Span {
+	defer s.onTag(key, value)
+	s.Lock()
+	defer s.Unlock()
+	if key == string(ext.SamplingPriority) {
+		if v, ok := value.(uint16); ok {
+			s.raw.Context.Sampled = v != 0
+			return s
+		}
+	}
+	if s.trim() {
+		return s
+	}
+
+	if s.raw.Tags == nil {
+		s.raw.Tags = opentracing.Tags{}
+	}
+	s.raw.Tags[key] = value
+	return s
+}
+
+func (s *spanImpl) LogKV(keyValues ...interface{}) {
+	fields, err := log.InterleavedKVToFields(keyValues...)
+	if err != nil {
+		s.LogFields(log.Error(err), log.String("function", "LogKV"))
+		return
+	}
+	s.LogFields(fields...)
+}
+
+func (s *spanImpl) appendLog(lr opentracing.LogRecord) {
+	maxLogs := s.tracer.options.MaxLogsPerSpan
+	if maxLogs == 0 || len(s.raw.Logs) < maxLogs {
+		s.raw.Logs = append(s.raw.Logs, lr)
+		return
+	}
+
+	// We have too many logs. We don't touch the first numOld logs; we treat the
+	// rest as a circular buffer and overwrite the oldest log among those.
+	numOld := (maxLogs - 1) / 2
+	numNew := maxLogs - numOld
+	s.raw.Logs[numOld+s.numDroppedLogs%numNew] = lr
+	s.numDroppedLogs++
+}
+
+func (s *spanImpl) LogFields(fields ...log.Field) {
+	lr := opentracing.LogRecord{
+		Fields: fields,
+	}
+	defer s.onLogFields(lr)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+	if lr.Timestamp.IsZero() {
+		lr.Timestamp = time.Now()
+	}
+	s.appendLog(lr)
+}
+
+func (s *spanImpl) LogEvent(event string) {
+	s.Log(opentracing.LogData{
+		Event: event,
+	})
+}
+
+func (s *spanImpl) LogEventWithPayload(event string, payload interface{}) {
+	s.Log(opentracing.LogData{
+		Event:   event,
+		Payload: payload,
+	})
+}
+
+func (s *spanImpl) Log(ld opentracing.LogData) {
+	defer s.onLog(ld)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+
+	if ld.Timestamp.IsZero() {
+		ld.Timestamp = time.Now()
+	}
+
+	s.appendLog(ld.ToLogRecord())
+}
+
+func (s *spanImpl) Finish() {
+	s.FinishWithOptions(opentracing.FinishOptions{})
+}
+
+// rotateLogBuffer rotates the records in the buffer: records 0 to pos-1 move at
+// the end (i.e. pos circular left shifts).
+func rotateLogBuffer(buf []opentracing.LogRecord, pos int) {
+	// This algorithm is described in:
+	//    http://www.cplusplus.com/reference/algorithm/rotate
+	for first, middle, next := 0, pos, pos; first != middle; {
+		buf[first], buf[next] = buf[next], buf[first]
+		first++
+		next++
+		if next == len(buf) {
+			next = middle
+		} else if first == middle {
+			middle = next
+		}
+	}
+}
+
+func (s *spanImpl) FinishWithOptions(opts opentracing.FinishOptions) {
+	finishTime := opts.FinishTime
+	if finishTime.IsZero() {
+		finishTime = time.Now()
+	}
+	duration := finishTime.Sub(s.raw.Start)
+
+	s.Lock()
+	defer s.Unlock()
+
+	for _, lr := range opts.LogRecords {
+		s.appendLog(lr)
+	}
+	for _, ld := range opts.BulkLogData {
+		s.appendLog(ld.ToLogRecord())
+	}
+
+	if s.numDroppedLogs > 0 {
+		// We dropped some log events, which means that we used part of Logs as a
+		// circular buffer (see appendLog). De-circularize it.
+		numOld := (len(s.raw.Logs) - 1) / 2
+		numNew := len(s.raw.Logs) - numOld
+		rotateLogBuffer(s.raw.Logs[numOld:], s.numDroppedLogs%numNew)
+
+		// Replace the log in the middle (the oldest "new" log) with information
+		// about the dropped logs. This means that we are effectively dropping one
+		// more "new" log.
+		numDropped := s.numDroppedLogs + 1
+		s.raw.Logs[numOld] = opentracing.LogRecord{
+			// Keep the timestamp of the last dropped event.
+			Timestamp: s.raw.Logs[numOld].Timestamp,
+			Fields: []log.Field{
+				log.String("event", "dropped Span logs"),
+				log.Int("dropped_log_count", numDropped),
+				log.String("component", "loggabletracer"),
+			},
+		}
+	}
+
+	s.raw.Duration = duration
+
+	s.onFinish(s.raw)
+	s.tracer.options.Recorder.RecordSpan(s.raw)
+
+	// Last chance to get options before the span is possibly reset.
+	poolEnabled := s.tracer.options.EnableSpanPool
+	if s.tracer.options.DebugAssertUseAfterFinish {
+		// This makes it much more likely to catch a panic on any subsequent
+		// operation since s.tracer is accessed on every call to `Lock`.
+		// We don't call `reset()` here to preserve the logs in the Span
+		// which are printed when the assertion triggers.
+		s.tracer = nil
+	}
+
+	if poolEnabled {
+		spanPool.Put(s)
+	}
+}
+
+func (s *spanImpl) Tracer() opentracing.Tracer {
+	return s.tracer
+}
+
+func (s *spanImpl) Context() opentracing.SpanContext {
+	return s.raw.Context
+}
+
+func (s *spanImpl) SetBaggageItem(key, val string) opentracing.Span {
+	s.onBaggage(key, val)
+	if s.trim() {
+		return s
+	}
+
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Context = s.raw.Context.WithBaggageItem(key, val)
+	return s
+}
+
+func (s *spanImpl) BaggageItem(key string) string {
+	s.Lock()
+	defer s.Unlock()
+	return s.raw.Context.Baggage[key]
+}
+
+func (s *spanImpl) Operation() string {
+	return s.raw.Operation
+}
+
+func (s *spanImpl) Start() time.Time {
+	return s.raw.Start
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/tracer.go b/vendor/github.com/ipfs/go-log/tracer/tracer.go
new file mode 100644
index 000000000..a6ea3a22e
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/tracer.go
@@ -0,0 +1,280 @@
+package loggabletracer
+
+import (
+	"time"
+
+	writer "github.com/ipfs/go-log/writer"
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+// Tracer extends the opentracing.Tracer interface with methods to
+// probe implementation state, for use by loggabletracer consumers.
+type Tracer interface {
+	opentracing.Tracer
+
+	// Options gets the Options used in New() or NewWithOptions().
+	Options() Options
+}
+
+// Options allows creating a customized Tracer via NewWithOptions. The object
+// must not be updated when there is an active tracer using it.
+type Options struct {
+	// ShouldSample is a function which is called when creating a new Span and
+	// determines whether that Span is sampled. The randomized TraceID is supplied
+	// to allow deterministic sampling decisions to be made across different nodes.
+	// For example,
+	//
+	//   func(traceID uint64) { return traceID % 64 == 0 }
+	//
+	// samples every 64th trace on average.
+	ShouldSample func(traceID uint64) bool
+	// TrimUnsampledSpans turns potentially expensive operations on unsampled
+	// Spans into no-ops. More precisely, tags and log events are silently
+	// discarded. If NewSpanEventListener is set, the callbacks will still fire.
+	TrimUnsampledSpans bool
+	// Recorder receives Spans which have been finished.
+	Recorder SpanRecorder
+	// NewSpanEventListener can be used to enhance the tracer by effectively
+	// attaching external code to trace events. See NetTraceIntegrator for a
+	// practical example, and event.go for the list of possible events.
+	NewSpanEventListener func() func(SpanEvent)
+	// DropAllLogs turns log events on all Spans into no-ops.
+	// If NewSpanEventListener is set, the callbacks will still fire.
+	DropAllLogs bool
+	// MaxLogsPerSpan limits the number of Logs in a span (if set to a nonzero
+	// value). If a span has more logs than this value, logs are dropped as
+	// necessary (and replaced with a log describing how many were dropped).
+	//
+	// About half of the MaxLogPerSpan logs kept are the oldest logs, and about
+	// half are the newest logs.
+	//
+	// If NewSpanEventListener is set, the callbacks will still fire for all log
+	// events. This value is ignored if DropAllLogs is true.
+	MaxLogsPerSpan int
+	// DebugAssertSingleGoroutine internally records the ID of the goroutine
+	// creating each Span and verifies that no operation is carried out on
+	// it on a different goroutine.
+	// Provided strictly for development purposes.
+	// Passing Spans between goroutine without proper synchronization often
+	// results in use-after-Finish() errors. For a simple example, consider the
+	// following pseudocode:
+	//
+	//  func (s *Server) Handle(req http.Request) error {
+	//    sp := s.StartSpan("server")
+	//    defer sp.Finish()
+	//    wait := s.queueProcessing(opentracing.ContextWithSpan(context.Background(), sp), req)
+	//    select {
+	//    case resp := <-wait:
+	//      return resp.Error
+	//    case <-time.After(10*time.Second):
+	//      sp.LogEvent("timed out waiting for processing")
+	//      return ErrTimedOut
+	//    }
+	//  }
+	//
+	// This looks reasonable at first, but a request which spends more than ten
+	// seconds in the queue is abandoned by the main goroutine and its trace
+	// finished, leading to use-after-finish when the request is finally
+	// processed. Note also that even joining on to a finished Span via
+	// StartSpanWithOptions constitutes an illegal operation.
+	//
+	// Code bases which do not require (or decide they do not want) Spans to
+	// be passed across goroutine boundaries can run with this flag enabled in
+	// tests to increase their chances of spotting wrong-doers.
+	DebugAssertSingleGoroutine bool
+	// DebugAssertUseAfterFinish is provided strictly for development purposes.
+	// When set, it attempts to exacerbate issues emanating from use of Spans
+	// after calling Finish by running additional assertions.
+	DebugAssertUseAfterFinish bool
+	// EnableSpanPool enables the use of a pool, so that the tracer reuses spans
+	// after Finish has been called on it. Adds a slight performance gain as it
+	// reduces allocations. However, if you have any use-after-finish race
+	// conditions the code may panic.
+	EnableSpanPool bool
+}
+
+// DefaultOptions returns an Options object with a 1 in 64 sampling rate and
+// all options disabled. A Recorder needs to be set manually before using the
+// returned object with a Tracer.
+func DefaultOptions() Options {
+	return Options{
+		ShouldSample:   func(traceID uint64) bool { return traceID%64 == 0 },
+		MaxLogsPerSpan: 100,
+	}
+}
+
+// NewWithOptions creates a customized Tracer.
+func NewWithOptions(opts Options) opentracing.Tracer {
+	rval := &LoggableTracer{options: opts}
+	rval.accessorPropagator = &accessorPropagator{rval}
+	return rval
+}
+
+// New creates and returns a standard Tracer which defers completed Spans to
+// `recorder`.
+// Spans created by this Tracer support the ext.SamplingPriority tag: Setting
+// ext.SamplingPriority causes the Span to be Sampled from that point on.
+func New(recorder SpanRecorder) opentracing.Tracer {
+	opts := DefaultOptions()
+	opts.Recorder = recorder
+	return NewWithOptions(opts)
+}
+
+// Implements the `Tracer` interface.
+type LoggableTracer struct {
+	options            Options
+	textPropagator     *textMapPropagator
+	binaryPropagator   *binaryPropagator
+	accessorPropagator *accessorPropagator
+}
+
+func (t *LoggableTracer) StartSpan(
+	operationName string,
+	opts ...opentracing.StartSpanOption,
+) opentracing.Span {
+
+	if !writer.WriterGroup.Active() {
+		return opentracing.NoopTracer.StartSpan(opentracing.NoopTracer{}, operationName)
+	}
+
+	sso := opentracing.StartSpanOptions{}
+	for _, o := range opts {
+		o.Apply(&sso)
+	}
+	return t.StartSpanWithOptions(operationName, sso)
+}
+
+func (t *LoggableTracer) getSpan() *spanImpl {
+	if t.options.EnableSpanPool {
+		sp := spanPool.Get().(*spanImpl)
+		sp.reset()
+		return sp
+	}
+	return &spanImpl{}
+}
+
+func (t *LoggableTracer) StartSpanWithOptions(
+	operationName string,
+	opts opentracing.StartSpanOptions,
+) opentracing.Span {
+	if !writer.WriterGroup.Active() {
+		return opentracing.NoopTracer.StartSpan(opentracing.NoopTracer{}, operationName)
+	}
+	// Start time.
+	startTime := opts.StartTime
+	if startTime.IsZero() {
+		startTime = time.Now()
+	}
+
+	// Tags.
+	tags := opts.Tags
+
+	// Build the new span. This is the only allocation: We'll return this as
+	// an opentracing.Span.
+	sp := t.getSpan()
+	// Look for a parent in the list of References.
+	//
+	// TODO: would be nice if loggabletracer did something with all
+	// References, not just the first one.
+ReferencesLoop:
+	for _, ref := range opts.References {
+		switch ref.Type {
+		case opentracing.ChildOfRef,
+			opentracing.FollowsFromRef:
+
+			refCtx, ok := ref.ReferencedContext.(SpanContext)
+			if !ok {
+				// Could be a noopSpanContext
+				// Ignore that parent.
+				continue
+			}
+			sp.raw.Context.TraceID = refCtx.TraceID
+			sp.raw.Context.SpanID = randomID()
+			sp.raw.Context.Sampled = refCtx.Sampled
+			sp.raw.ParentSpanID = refCtx.SpanID
+
+			if l := len(refCtx.Baggage); l > 0 {
+				sp.raw.Context.Baggage = make(map[string]string, l)
+				for k, v := range refCtx.Baggage {
+					sp.raw.Context.Baggage[k] = v
+				}
+			}
+			break ReferencesLoop
+		}
+	}
+	if sp.raw.Context.TraceID == 0 {
+		// No parent Span found; allocate new trace and span ids and determine
+		// the Sampled status.
+		sp.raw.Context.TraceID, sp.raw.Context.SpanID = randomID2()
+		sp.raw.Context.Sampled = t.options.ShouldSample(sp.raw.Context.TraceID)
+	}
+
+	return t.startSpanInternal(
+		sp,
+		operationName,
+		startTime,
+		tags,
+	)
+}
+
+func (t *LoggableTracer) startSpanInternal(
+	sp *spanImpl,
+	operationName string,
+	startTime time.Time,
+	tags opentracing.Tags,
+) opentracing.Span {
+	sp.tracer = t
+	if t.options.NewSpanEventListener != nil {
+		sp.event = t.options.NewSpanEventListener()
+	}
+	sp.raw.Operation = operationName
+	sp.raw.Start = startTime
+	sp.raw.Duration = -1
+	sp.raw.Tags = tags
+	if t.options.DebugAssertSingleGoroutine {
+		sp.SetTag(debugGoroutineIDTag, curGoroutineID())
+	}
+	defer sp.onCreate(operationName)
+	return sp
+}
+
+type delegatorType struct{}
+
+// Delegator is the format to use for DelegatingCarrier.
+var Delegator delegatorType
+
+func (t *LoggableTracer) Inject(sc opentracing.SpanContext, format interface{}, carrier interface{}) error {
+	if !writer.WriterGroup.Active() {
+		return opentracing.NoopTracer.Inject(opentracing.NoopTracer{}, sc, format, carrier)
+	}
+	switch format {
+	case opentracing.TextMap, opentracing.HTTPHeaders:
+		return t.textPropagator.Inject(sc, carrier)
+	case opentracing.Binary:
+		return t.binaryPropagator.Inject(sc, carrier)
+	}
+	if _, ok := format.(delegatorType); ok {
+		return t.accessorPropagator.Inject(sc, carrier)
+	}
+	return opentracing.ErrUnsupportedFormat
+}
+
+func (t *LoggableTracer) Extract(format interface{}, carrier interface{}) (opentracing.SpanContext, error) {
+	if !writer.WriterGroup.Active() {
+		return opentracing.NoopTracer.Extract(opentracing.NoopTracer{}, format, carrier)
+	}
+	switch format {
+	case opentracing.TextMap, opentracing.HTTPHeaders:
+		return t.textPropagator.Extract(carrier)
+	case opentracing.Binary:
+		return t.binaryPropagator.Extract(carrier)
+	}
+	if _, ok := format.(delegatorType); ok {
+		return t.accessorPropagator.Extract(carrier)
+	}
+	return nil, opentracing.ErrUnsupportedFormat
+}
+
+func (t *LoggableTracer) Options() Options {
+	return t.options
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/util.go b/vendor/github.com/ipfs/go-log/tracer/util.go
new file mode 100644
index 000000000..279e2acaa
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/util.go
@@ -0,0 +1,25 @@
+package loggabletracer
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+var (
+	seededIDGen = rand.New(rand.NewSource(time.Now().UnixNano()))
+	// The golang rand generators are *not* intrinsically thread-safe.
+	seededIDLock sync.Mutex
+)
+
+func randomID() uint64 {
+	seededIDLock.Lock()
+	defer seededIDLock.Unlock()
+	return uint64(seededIDGen.Int63())
+}
+
+func randomID2() (uint64, uint64) {
+	seededIDLock.Lock()
+	defer seededIDLock.Unlock()
+	return uint64(seededIDGen.Int63()), uint64(seededIDGen.Int63())
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/wire/carrier.go b/vendor/github.com/ipfs/go-log/tracer/wire/carrier.go
new file mode 100644
index 000000000..12ec98e90
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/wire/carrier.go
@@ -0,0 +1,40 @@
+package wire
+
+// ProtobufCarrier is a DelegatingCarrier that uses protocol buffers as the
+// the underlying datastructure. The reason for implementing DelagatingCarrier
+// is to allow for end users to serialize the underlying protocol buffers using
+// jsonpb or any other serialization forms they want.
+type ProtobufCarrier TracerState
+
+// SetState set's the tracer state.
+func (p *ProtobufCarrier) SetState(traceID, spanID uint64, sampled bool) {
+	p.TraceId = traceID
+	p.SpanId = spanID
+	p.Sampled = sampled
+}
+
+// State returns the tracer state.
+func (p *ProtobufCarrier) State() (traceID, spanID uint64, sampled bool) {
+	traceID = p.TraceId
+	spanID = p.SpanId
+	sampled = p.Sampled
+	return traceID, spanID, sampled
+}
+
+// SetBaggageItem sets a baggage item.
+func (p *ProtobufCarrier) SetBaggageItem(key, value string) {
+	if p.BaggageItems == nil {
+		p.BaggageItems = map[string]string{key: value}
+		return
+	}
+
+	p.BaggageItems[key] = value
+}
+
+// GetBaggage iterates over each baggage item and executes the callback with
+// the key:value pair.
+func (p *ProtobufCarrier) GetBaggage(f func(k, v string)) {
+	for k, v := range p.BaggageItems {
+		f(k, v)
+	}
+}
diff --git a/vendor/github.com/ipfs/go-log/tracer/wire/gen.go b/vendor/github.com/ipfs/go-log/tracer/wire/gen.go
new file mode 100644
index 000000000..7d951fa43
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/wire/gen.go
@@ -0,0 +1,6 @@
+package wire
+
+//go:generate protoc --gogofaster_out=$GOPATH/src/github.com/ipfs/go-log/tracer/wire wire.proto
+
+// Run `go get github.com/gogo/protobuf/protoc-gen-gogofaster` to install the
+// gogofaster generator binary.
diff --git a/vendor/github.com/ipfs/go-log/tracer/wire/wire.pb.go b/vendor/github.com/ipfs/go-log/tracer/wire/wire.pb.go
new file mode 100644
index 000000000..dea81208c
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/tracer/wire/wire.pb.go
@@ -0,0 +1,45 @@
+// Code generated by protoc-gen-gogo.
+// source: wire.proto
+// DO NOT EDIT!
+
+/*
+Package wire is a generated protocol buffer package.
+
+It is generated from these files:
+	wire.proto
+
+It has these top-level messages:
+	TracerState
+*/
+package wire
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type TracerState struct {
+	TraceId      uint64            `protobuf:"fixed64,1,opt,name=trace_id,proto3" json:"trace_id,omitempty"`
+	SpanId       uint64            `protobuf:"fixed64,2,opt,name=span_id,proto3" json:"span_id,omitempty"`
+	Sampled      bool              `protobuf:"varint,3,opt,name=sampled,proto3" json:"sampled,omitempty"`
+	BaggageItems map[string]string `protobuf:"bytes,4,rep,name=baggage_items" json:"baggage_items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (m *TracerState) Reset()         { *m = TracerState{} }
+func (m *TracerState) String() string { return proto.CompactTextString(m) }
+func (*TracerState) ProtoMessage()    {}
+
+func (m *TracerState) GetBaggageItems() map[string]string {
+	if m != nil {
+		return m.BaggageItems
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*TracerState)(nil), "basictracer_go.wire.TracerState")
+}
diff --git a/vendor/github.com/ipfs/go-log/writer/option.go b/vendor/github.com/ipfs/go-log/writer/option.go
new file mode 100644
index 000000000..e467fc175
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/writer/option.go
@@ -0,0 +1,55 @@
+package log
+
+import (
+	"io"
+
+	logging "github.com/whyrusleeping/go-logging"
+)
+
+// WriterGroup is the global writer group for logs to output to
+var WriterGroup = NewMirrorWriter()
+
+// Option is a generic function
+type Option func()
+
+// Configure applies the provided options sequentially from left to right
+func Configure(options ...Option) {
+	for _, f := range options {
+		f()
+	}
+}
+
+// LdJSONFormatter Option formats the event log as line-delimited JSON
+var LdJSONFormatter = func() {
+	logging.SetFormatter(&PoliteJSONFormatter{})
+}
+
+// TextFormatter Option formats the event log as human-readable plain-text
+var TextFormatter = func() {
+	logging.SetFormatter(logging.DefaultFormatter)
+}
+
+// Output returns an option which sets the the given writer as the new
+// logging backend
+func Output(w io.Writer) Option {
+	return func() {
+		backend := logging.NewLogBackend(w, "", 0)
+		logging.SetBackend(backend)
+		// TODO return previous Output option
+	}
+}
+
+// LevelDebug Option sets the log level to debug
+var LevelDebug = func() {
+	logging.SetLevel(logging.DEBUG, "")
+}
+
+// LevelError Option sets the log level to error
+var LevelError = func() {
+	logging.SetLevel(logging.ERROR, "")
+}
+
+// LevelInfo Option sets the log level to info
+var LevelInfo = func() {
+	logging.SetLevel(logging.INFO, "")
+}
diff --git a/vendor/github.com/ipfs/go-log/writer/polite_json_formatter.go b/vendor/github.com/ipfs/go-log/writer/polite_json_formatter.go
new file mode 100644
index 000000000..c5e620fd1
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/writer/polite_json_formatter.go
@@ -0,0 +1,29 @@
+package log
+
+import (
+	"encoding/json"
+	"io"
+
+	logging "github.com/whyrusleeping/go-logging"
+)
+
+// PoliteJSONFormatter marshals entries into JSON encoded slices (without
+// overwriting user-provided keys). How polite of it!
+type PoliteJSONFormatter struct{}
+
+// Format encodes a logging.Record in JSON and writes it to Writer.
+func (f *PoliteJSONFormatter) Format(calldepth int, r *logging.Record, w io.Writer) error {
+	entry := make(map[string]interface{})
+	entry["id"] = r.Id
+	entry["level"] = r.Level
+	entry["time"] = r.Time
+	entry["module"] = r.Module
+	entry["message"] = r.Message()
+	err := json.NewEncoder(w).Encode(entry)
+	if err != nil {
+		return err
+	}
+
+	w.Write([]byte{'\n'})
+	return nil
+}
diff --git a/vendor/github.com/ipfs/go-log/writer/writer.go b/vendor/github.com/ipfs/go-log/writer/writer.go
new file mode 100644
index 000000000..ec5d7299c
--- /dev/null
+++ b/vendor/github.com/ipfs/go-log/writer/writer.go
@@ -0,0 +1,258 @@
+package log
+
+import (
+	"fmt"
+	"io"
+	"sync"
+	"sync/atomic"
+)
+
+// MaxWriterBuffer specifies how big the writer buffer can get before
+// killing the writer.
+var MaxWriterBuffer = 512 * 1024
+
+// MirrorWriter implements a WriteCloser which syncs incoming bytes to multiple
+// [buffered] WriteClosers. They can be added with AddWriter().
+type MirrorWriter struct {
+	active uint32
+
+	// channel for incoming writers
+	writerAdd chan *writerAdd
+
+	// slices of writer/sync-channel pairs
+	writers []*bufWriter
+
+	// synchronization channel for incoming writes
+	msgSync chan []byte
+}
+
+type writerSync struct {
+	w  io.WriteCloser
+	br chan []byte
+}
+
+// NewMirrorWriter initializes and returns a MirrorWriter.
+func NewMirrorWriter() *MirrorWriter {
+	mw := &MirrorWriter{
+		msgSync:   make(chan []byte, 64), // sufficiently large buffer to avoid callers waiting
+		writerAdd: make(chan *writerAdd),
+	}
+
+	go mw.logRoutine()
+
+	return mw
+}
+
+// Write broadcasts the written bytes to all Writers.
+func (mw *MirrorWriter) Write(b []byte) (int, error) {
+	mycopy := make([]byte, len(b))
+	copy(mycopy, b)
+	mw.msgSync <- mycopy
+	return len(b), nil
+}
+
+// Close closes the MirrorWriter
+func (mw *MirrorWriter) Close() error {
+	// it is up to the caller to ensure that write is not called during or
+	// after close is called.
+	close(mw.msgSync)
+	return nil
+}
+
+func (mw *MirrorWriter) doClose() {
+	for _, w := range mw.writers {
+		w.writer.Close()
+	}
+}
+
+func (mw *MirrorWriter) logRoutine() {
+	// rebind to avoid races on nilling out struct fields
+	msgSync := mw.msgSync
+	writerAdd := mw.writerAdd
+
+	defer mw.doClose()
+
+	for {
+		select {
+		case b, ok := <-msgSync:
+			if !ok {
+				return
+			}
+
+			// write to all writers
+			dropped := mw.broadcastMessage(b)
+
+			// consolidate the slice
+			if dropped {
+				mw.clearDeadWriters()
+			}
+		case wa := <-writerAdd:
+			mw.writers = append(mw.writers, newBufWriter(wa.w))
+
+			atomic.StoreUint32(&mw.active, 1)
+			close(wa.done)
+		}
+	}
+}
+
+// broadcastMessage sends the given message to every writer
+// if any writer is killed during the send, 'true' is returned
+func (mw *MirrorWriter) broadcastMessage(b []byte) bool {
+	var dropped bool
+	for i, w := range mw.writers {
+		_, err := w.Write(b)
+		if err != nil {
+			mw.writers[i] = nil
+			dropped = true
+		}
+	}
+	return dropped
+}
+
+func (mw *MirrorWriter) clearDeadWriters() {
+	writers := mw.writers
+	mw.writers = nil
+	for _, w := range writers {
+		if w != nil {
+			mw.writers = append(mw.writers, w)
+		}
+	}
+	if len(mw.writers) == 0 {
+		atomic.StoreUint32(&mw.active, 0)
+	}
+}
+
+type writerAdd struct {
+	w    io.WriteCloser
+	done chan struct{}
+}
+
+// AddWriter attaches a new WriteCloser to this MirrorWriter.
+// The new writer will start getting any bytes written to the mirror.
+func (mw *MirrorWriter) AddWriter(w io.WriteCloser) {
+	wa := &writerAdd{
+		w:    w,
+		done: make(chan struct{}),
+	}
+	mw.writerAdd <- wa
+	<-wa.done
+}
+
+// Active returns if there is at least one Writer
+// attached to this MirrorWriter
+func (mw *MirrorWriter) Active() (active bool) {
+	return atomic.LoadUint32(&mw.active) == 1
+}
+
+func newBufWriter(w io.WriteCloser) *bufWriter {
+	bw := &bufWriter{
+		writer:   w,
+		incoming: make(chan []byte, 1),
+	}
+
+	go bw.loop()
+	return bw
+}
+
+// writes incoming messages to a buffer and when it fills
+// up, writes them to the writer
+type bufWriter struct {
+	writer io.WriteCloser
+
+	incoming chan []byte
+
+	deathLock sync.Mutex
+	dead      bool
+}
+
+var errDeadWriter = fmt.Errorf("writer is dead")
+
+func (bw *bufWriter) Write(b []byte) (int, error) {
+	bw.deathLock.Lock()
+	dead := bw.dead
+	bw.deathLock.Unlock()
+	if dead {
+		if bw.incoming != nil {
+			close(bw.incoming)
+			bw.incoming = nil
+		}
+		return 0, errDeadWriter
+	}
+
+	bw.incoming <- b
+	return len(b), nil
+}
+
+func (bw *bufWriter) die() {
+	bw.deathLock.Lock()
+	bw.dead = true
+	bw.writer.Close()
+	bw.deathLock.Unlock()
+}
+
+func (bw *bufWriter) loop() {
+	bufsize := 0
+	bufBase := make([][]byte, 0, 16) // some initial memory
+	buffered := bufBase
+	nextCh := make(chan []byte)
+
+	var nextMsg []byte
+
+	go func() {
+		for b := range nextCh {
+			_, err := bw.writer.Write(b)
+			if err != nil {
+				// TODO: need a way to notify there was an error here
+				// wouldn't want to log here as it could casue an infinite loop
+				bw.die()
+				return
+			}
+		}
+	}()
+
+	// collect and buffer messages
+	incoming := bw.incoming
+	for {
+		if nextMsg == nil || nextCh == nil {
+			// nextCh == nil implies we are 'dead' and draining the incoming channel
+			// until the caller notices and closes it for us
+			select {
+			case b, ok := <-incoming:
+				if !ok {
+					return
+				}
+				nextMsg = b
+			}
+		}
+
+		select {
+		case b, ok := <-incoming:
+			if !ok {
+				return
+			}
+			bufsize += len(b)
+			buffered = append(buffered, b)
+			if bufsize > MaxWriterBuffer {
+				// if we have too many messages buffered, kill the writer
+				bw.die()
+				if nextCh != nil {
+					close(nextCh)
+				}
+				nextCh = nil
+				// explicity keep going here to drain incoming
+			}
+		case nextCh <- nextMsg:
+			nextMsg = nil
+			if len(buffered) > 0 {
+				nextMsg = buffered[0]
+				buffered = buffered[1:]
+				bufsize -= len(nextMsg)
+			}
+
+			if len(buffered) == 0 {
+				// reset slice position
+				buffered = bufBase[:0]
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/jackpal/gateway/LICENSE b/vendor/github.com/jackpal/gateway/LICENSE
new file mode 100644
index 000000000..c9efac32e
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/LICENSE
@@ -0,0 +1,27 @@
+// Copyright (c) 2010 Jack Palevich. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/jackpal/gateway/gateway_common.go b/vendor/github.com/jackpal/gateway/gateway_common.go
new file mode 100644
index 000000000..74cc7b267
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_common.go
@@ -0,0 +1,129 @@
+package gateway
+
+import (
+	"errors"
+	"net"
+	"strings"
+)
+
+var errNoGateway = errors.New("no gateway found")
+
+func parseWindowsRoutePrint(output []byte) (net.IP, error) {
+	// Windows route output format is always like this:
+	// ===========================================================================
+	// Active Routes:
+	// Network Destination        Netmask          Gateway       Interface  Metric
+	//           0.0.0.0          0.0.0.0      192.168.1.1    192.168.1.100     20
+	// ===========================================================================
+	// I'm trying to pick the active route,
+	// then jump 2 lines and pick the third IP
+	// Not using regex because output is quite standard from Windows XP to 8 (NEEDS TESTING)
+	lines := strings.Split(string(output), "\n")
+	for idx, line := range lines {
+		if strings.HasPrefix(line, "Active Routes:") {
+			if len(lines) <= idx+2 {
+				return nil, errNoGateway
+			}
+
+			fields := strings.Fields(lines[idx+2])
+			if len(fields) < 3 {
+				return nil, errNoGateway
+			}
+
+			ip := net.ParseIP(fields[2])
+			if ip != nil {
+				return ip, nil
+			}
+		}
+	}
+	return nil, errNoGateway
+}
+
+func parseLinuxIPRoute(output []byte) (net.IP, error) {
+	// Linux '/usr/bin/ip route show' format looks like this:
+	// default via 192.168.178.1 dev wlp3s0  metric 303
+	// 192.168.178.0/24 dev wlp3s0  proto kernel  scope link  src 192.168.178.76  metric 303
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) >= 3 && fields[0] == "default" {
+			ip := net.ParseIP(fields[2])
+			if ip != nil {
+				return ip, nil
+			}
+		}
+	}
+
+	return nil, errNoGateway
+}
+
+func parseLinuxRoute(output []byte) (net.IP, error) {
+	// Linux route out format is always like this:
+	// Kernel IP routing table
+	// Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
+	// 0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth0
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[0] == "0.0.0.0" {
+			ip := net.ParseIP(fields[1])
+			if ip != nil {
+				return ip, nil
+			}
+		}
+	}
+
+	return nil, errNoGateway
+}
+
+func parseDarwinRouteGet(output []byte) (net.IP, error) {
+	// Darwin route out format is always like this:
+	//    route to: default
+	// destination: default
+	//        mask: default
+	//     gateway: 192.168.1.1
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[0] == "gateway:" {
+			ip := net.ParseIP(fields[1])
+			if ip != nil {
+				return ip, nil
+			}
+		}
+	}
+
+	return nil, errNoGateway
+}
+
+func parseBSDSolarisNetstat(output []byte) (net.IP, error) {
+	// netstat -rn produces the following on FreeBSD:
+	// Routing tables
+	//
+	// Internet:
+	// Destination        Gateway            Flags      Netif Expire
+	// default            10.88.88.2         UGS         em0
+	// 10.88.88.0/24      link#1             U           em0
+	// 10.88.88.148       link#1             UHS         lo0
+	// 127.0.0.1          link#2             UH          lo0
+	//
+	// Internet6:
+	// Destination                       Gateway                       Flags      Netif Expire
+	// ::/96                             ::1                           UGRS        lo0
+	// ::1                               link#2                        UH          lo0
+	// ::ffff:0.0.0.0/96                 ::1                           UGRS        lo0
+	// fe80::/10                         ::1                           UGRS        lo0
+	// ...
+	outputLines := strings.Split(string(output), "\n")
+	for _, line := range outputLines {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[0] == "default" {
+			ip := net.ParseIP(fields[1])
+			if ip != nil {
+				return ip, nil
+			}
+		}
+	}
+
+	return nil, errNoGateway
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_darwin.go b/vendor/github.com/jackpal/gateway/gateway_darwin.go
new file mode 100644
index 000000000..32e755cbf
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_darwin.go
@@ -0,0 +1,16 @@
+package gateway
+
+import (
+	"net"
+	"os/exec"
+)
+
+func DiscoverGateway() (net.IP, error) {
+	routeCmd := exec.Command("/sbin/route", "-n", "get", "0.0.0.0")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseDarwinRouteGet(output)
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_freebsd.go b/vendor/github.com/jackpal/gateway/gateway_freebsd.go
new file mode 100644
index 000000000..3d6691087
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_freebsd.go
@@ -0,0 +1,16 @@
+package gateway
+
+import (
+	"net"
+	"os/exec"
+)
+
+func DiscoverGateway() (ip net.IP, err error) {
+	routeCmd := exec.Command("netstat", "-rn")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseBSDSolarisNetstat(output)
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_linux.go b/vendor/github.com/jackpal/gateway/gateway_linux.go
new file mode 100644
index 000000000..c705632c2
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_linux.go
@@ -0,0 +1,34 @@
+package gateway
+
+import (
+	"net"
+	"os/exec"
+)
+
+func DiscoverGateway() (ip net.IP, err error) {
+	ip, err = discoverGatewayUsingRoute()
+	if err != nil {
+		ip, err = discoverGatewayUsingIp()
+	}
+	return
+}
+
+func discoverGatewayUsingIp() (net.IP, error) {
+	routeCmd := exec.Command("/usr/bin/ip", "route", "show")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseLinuxIPRoute(output)
+}
+
+func discoverGatewayUsingRoute() (net.IP, error) {
+	routeCmd := exec.Command("/usr/bin/route", "-n")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseLinuxRoute(output)
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_solaris.go b/vendor/github.com/jackpal/gateway/gateway_solaris.go
new file mode 100644
index 000000000..3d6691087
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_solaris.go
@@ -0,0 +1,16 @@
+package gateway
+
+import (
+	"net"
+	"os/exec"
+)
+
+func DiscoverGateway() (ip net.IP, err error) {
+	routeCmd := exec.Command("netstat", "-rn")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseBSDSolarisNetstat(output)
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_unimplemented.go b/vendor/github.com/jackpal/gateway/gateway_unimplemented.go
new file mode 100644
index 000000000..750ac4b7a
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_unimplemented.go
@@ -0,0 +1,14 @@
+// +build !darwin,!linux,!windows,!solaris,!freebsd
+
+package gateway
+
+import (
+	"fmt"
+	"net"
+	"runtime"
+)
+
+func DiscoverGateway() (ip net.IP, err error) {
+	err = fmt.Errorf("DiscoverGateway not implemented for OS %s", runtime.GOOS)
+	return
+}
diff --git a/vendor/github.com/jackpal/gateway/gateway_windows.go b/vendor/github.com/jackpal/gateway/gateway_windows.go
new file mode 100644
index 000000000..4e944eefb
--- /dev/null
+++ b/vendor/github.com/jackpal/gateway/gateway_windows.go
@@ -0,0 +1,16 @@
+package gateway
+
+import (
+	"net"
+	"os/exec"
+)
+
+func DiscoverGateway() (ip net.IP, err error) {
+	routeCmd := exec.Command("route", "print", "0.0.0.0")
+	output, err := routeCmd.CombinedOutput()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseWindowsRoutePrint(output)
+}
diff --git a/vendor/github.com/jbenet/go-temp-err-catcher/LICENSE b/vendor/github.com/jbenet/go-temp-err-catcher/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/jbenet/go-temp-err-catcher/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/jbenet/go-temp-err-catcher/doc.go b/vendor/github.com/jbenet/go-temp-err-catcher/doc.go
new file mode 100644
index 000000000..766c8b6f7
--- /dev/null
+++ b/vendor/github.com/jbenet/go-temp-err-catcher/doc.go
@@ -0,0 +1,62 @@
+// Package temperrcatcher provides a TempErrCatcher object,
+// which implements simple error-retrying functionality.
+// It is meant to be used with things like net.Lister.Accept:
+//
+//   import (
+//     tec "github.com/jbenet/go-temp-err-catcher"
+//   )
+//
+//   func listen(listener net.Listener) {
+//     var c tec.TempErrCatcher
+//
+//     for {
+//       conn, err := listener.Accept()
+//       if err != nil && c.IsTemporary(c) {
+//         continue
+//       }
+//       return conn, err
+//     }
+//   }
+//
+// You can make your errors implement `Temporary`:
+//
+//   type errTemp struct {
+//     e error
+//   }
+//
+//   func (e errTemp) Temporary() bool {
+//     return true
+//   }
+//
+//   func (e errTemp) Error() string {
+//     return e.e.Error()
+//   }
+//
+//   err := errors.New("beep boop")
+//   var c tec.TempErrCatcher
+//   c.IsTemporary(err)              // false
+//   c.IsTemporary(errTemp{err}) // true
+//
+// Or just use `ErrTemp`:
+//
+//   err := errors.New("beep boop")
+//   var c tec.TempErrCatcher
+//   c.IsTemporary(err)              // false
+//   c.IsTemporary(tec.ErrTemp{err}) // true
+//
+//
+// You can also define an `IsTemp` function to classify errors:
+//
+//   var ErrSkip = errors.New("this should be skipped")
+//   var ErrNotSkip = errors.New("this should not be skipped")
+//
+//   var c tec.TempErrCatcher
+//   c.IsTemp = func(e error) bool {
+//     return e == ErrSkip
+//   }
+//
+//   c.IsTemporary(ErrSkip) // true
+//   c.IsTemporary(ErrNotSkip) // false
+//   c.IsTemporary(ErrTemp) // false! no longer accepts Temporary()
+//
+package temperrcatcher
diff --git a/vendor/github.com/jbenet/go-temp-err-catcher/temp_err_catcher.go b/vendor/github.com/jbenet/go-temp-err-catcher/temp_err_catcher.go
new file mode 100644
index 000000000..fe8e780c6
--- /dev/null
+++ b/vendor/github.com/jbenet/go-temp-err-catcher/temp_err_catcher.go
@@ -0,0 +1,124 @@
+// Package temperrcatcher provides a TempErrCatcher object,
+// which implements simple error-retrying functionality.
+package temperrcatcher
+
+import (
+	"time"
+)
+
+// InitialDelay governs how long to wait the first time.
+// This is defaulted to time.Millisecond, which makes sense
+// for network listener failures. You may want a much smaller
+// delay. You can configure this package wide, or in each
+// TempErrCatcher
+var InitialDelay = time.Millisecond
+
+// Temporary is an interface errors can implement to
+// ensure they are correctly classified by the default
+// TempErrCatcher classifier
+type Temporary interface {
+	Temporary() bool
+}
+
+// ErrIsTemporary returns whether an error is Temporary(),
+// iff it implements the Temporary interface.
+func ErrIsTemporary(e error) bool {
+	te, ok := e.(Temporary)
+	return ok && te.Temporary()
+}
+
+// TempErrCatcher catches temporary errors for you. It then sleeps
+// for a bit before returning (you should then try again). This may
+// seem odd, but it's exactly what net/http does:
+// http://golang.org/src/net/http/server.go?s=51504:51550#L1728
+//
+// You can set a few options in TempErrCatcher. They all have defaults
+// so a zero TempErrCatcher is ready to be used:
+//
+//  var c tec.TempErrCatcher
+//  c.IsTemporary(tempErr)
+//
+type TempErrCatcher struct {
+	IsTemp func(error) bool    // the classifier to use. default: ErrIsTemporary
+	Wait   func(time.Duration) // the wait func to call. default: time.Sleep
+	Max    time.Duration       // the maximum time to wait. default: time.Second
+	Start  time.Duration       // the delay to start with. default: InitialDelay
+	delay  time.Duration
+	last   time.Time
+}
+
+func (tec *TempErrCatcher) init() {
+	if tec.Max == 0 {
+		tec.Max = time.Second
+	}
+	if tec.IsTemp == nil {
+		tec.IsTemp = ErrIsTemporary
+	}
+	if tec.Wait == nil {
+		tec.Wait = time.Sleep
+	}
+	if tec.Start == 0 {
+		tec.Start = InitialDelay
+	}
+}
+
+// IsTemporary checks whether an error is temporary. It will call
+// tec.Wait before returning, with a delay. The delay is also
+// doubled, so we do not constantly spin. This is the strategy
+// net.Listener uses.
+//
+// Note: you will want to call Reset() if you get a success,
+// so that the stored delay is brough back to 0.
+func (tec *TempErrCatcher) IsTemporary(e error) bool {
+	tec.init()
+	if tec.IsTemp(e) {
+		now := time.Now()
+		if now.Sub(tec.last) > (tec.delay * 5) {
+			// this is a "new streak" of temp failures. reset.
+			tec.Reset()
+		}
+
+		if tec.delay == 0 { // init case.
+			tec.delay = tec.Start
+		} else {
+			tec.delay *= 2
+		}
+
+		if tec.delay > tec.Max {
+			tec.delay = tec.Max
+		}
+		tec.Wait(tec.delay)
+		tec.last = now
+		return true
+	}
+	tec.Reset() // different failure. call reset
+	return false
+}
+
+// Reset sets the internal delay counter to 0
+func (tec *TempErrCatcher) Reset() {
+	tec.delay = 0
+}
+
+// ErrTemporary wraps any error and implements Temporary function.
+//
+//   err := errors.New("beep boop")
+//   var c tec.TempErrCatcher
+//   c.IsTemporary(err)              // false
+//   c.IsTemporary(tec.ErrTemp{err}) // true
+//
+type ErrTemporary struct {
+	Err error
+}
+
+func (e ErrTemporary) Temporary() bool {
+	return true
+}
+
+func (e ErrTemporary) Error() string {
+	return e.Err.Error()
+}
+
+func (e ErrTemporary) String() string {
+	return e.Error()
+}
diff --git a/vendor/github.com/jbenet/goprocess/LICENSE b/vendor/github.com/jbenet/goprocess/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/jbenet/goprocess/context/context.go b/vendor/github.com/jbenet/goprocess/context/context.go
new file mode 100644
index 000000000..07308dadf
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/context/context.go
@@ -0,0 +1,111 @@
+package goprocessctx
+
+import (
+	"context"
+
+	goprocess "github.com/jbenet/goprocess"
+)
+
+// WithContext constructs and returns a Process that respects
+// given context. It is the equivalent of:
+//
+//   func ProcessWithContext(ctx context.Context) goprocess.Process {
+//     p := goprocess.WithParent(goprocess.Background())
+//     CloseAfterContext(p, ctx)
+//     return p
+//   }
+//
+func WithContext(ctx context.Context) goprocess.Process {
+	p := goprocess.WithParent(goprocess.Background())
+	CloseAfterContext(p, ctx)
+	return p
+}
+
+// WithContextAndTeardown is a helper function to set teardown at initiation
+// of WithContext
+func WithContextAndTeardown(ctx context.Context, tf goprocess.TeardownFunc) goprocess.Process {
+	p := goprocess.WithTeardown(tf)
+	CloseAfterContext(p, ctx)
+	return p
+}
+
+// WaitForContext makes p WaitFor ctx. When Closing, p waits for
+// ctx.Done(), before being Closed(). It is simply:
+//
+//   p.WaitFor(goprocess.WithContext(ctx))
+//
+func WaitForContext(ctx context.Context, p goprocess.Process) {
+	p.WaitFor(WithContext(ctx))
+}
+
+// CloseAfterContext schedules the process to close after the given
+// context is done. It is the equivalent of:
+//
+//   func CloseAfterContext(p goprocess.Process, ctx context.Context) {
+//     go func() {
+//       <-ctx.Done()
+//       p.Close()
+//     }()
+//   }
+//
+func CloseAfterContext(p goprocess.Process, ctx context.Context) {
+	if p == nil {
+		panic("nil Process")
+	}
+	if ctx == nil {
+		panic("nil Context")
+	}
+
+	// context.Background(). if ctx.Done() is nil, it will never be done.
+	// we check for this to avoid wasting a goroutine forever.
+	if ctx.Done() == nil {
+		return
+	}
+
+	go func() {
+		<-ctx.Done()
+		p.Close()
+	}()
+}
+
+// WithProcessClosing returns a context.Context derived from ctx that
+// is cancelled as p is Closing (after: <-p.Closing()). It is simply:
+//
+//   func WithProcessClosing(ctx context.Context, p goprocess.Process) context.Context {
+//     ctx, cancel := context.WithCancel(ctx)
+//     go func() {
+//       <-p.Closing()
+//       cancel()
+//     }()
+//     return ctx
+//   }
+//
+func WithProcessClosing(ctx context.Context, p goprocess.Process) context.Context {
+	ctx, cancel := context.WithCancel(ctx)
+	go func() {
+		<-p.Closing()
+		cancel()
+	}()
+	return ctx
+}
+
+// WithProcessClosed returns a context.Context that is cancelled
+// after Process p is Closed. It is the equivalent of:
+//
+//   func WithProcessClosed(ctx context.Context, p goprocess.Process) context.Context {
+//     ctx, cancel := context.WithCancel(ctx)
+//     go func() {
+//       <-p.Closed()
+//       cancel()
+//     }()
+//     return ctx
+//   }
+//
+func WithProcessClosed(ctx context.Context, p goprocess.Process) context.Context {
+	ctx, cancel := context.WithCancel(ctx)
+	go func() {
+		<-p.Closed()
+		cancel()
+	}()
+	return ctx
+}
diff --git a/vendor/github.com/jbenet/goprocess/context/derive.go b/vendor/github.com/jbenet/goprocess/context/derive.go
new file mode 100644
index 000000000..c7b913069
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/context/derive.go
@@ -0,0 +1,59 @@
+package goprocessctx
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	goprocess "github.com/jbenet/goprocess"
+)
+
+const (
+	closing = iota
+	closed
+)
+
+type procContext struct {
+	done  <-chan struct{}
+	which int
+}
+
+// OnClosingContext derives a context from a given goprocess that will
+// be 'Done' when the process is closing
+func OnClosingContext(p goprocess.Process) context.Context {
+	return &procContext{
+		done:  p.Closing(),
+		which: closing,
+	}
+}
+
+// OnClosedContext derives a context from a given goprocess that will
+// be 'Done' when the process is closed
+func OnClosedContext(p goprocess.Process) context.Context {
+	return &procContext{
+		done:  p.Closed(),
+		which: closed,
+	}
+}
+
+func (c *procContext) Done() <-chan struct{} {
+	return c.done
+}
+
+func (c *procContext) Deadline() (time.Time, bool) {
+	return time.Time{}, false
+}
+
+func (c *procContext) Err() error {
+	if c.which == closing {
+		return errors.New("process closing")
+	} else if c.which == closed {
+		return errors.New("process closed")
+	} else {
+		panic("unrecognized process context type")
+	}
+}
+
+func (c *procContext) Value(key interface{}) interface{} {
+	return nil
+}
diff --git a/vendor/github.com/jbenet/goprocess/goprocess.go b/vendor/github.com/jbenet/goprocess/goprocess.go
new file mode 100644
index 000000000..a81ec8b92
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/goprocess.go
@@ -0,0 +1,283 @@
+// Package goprocess introduces a Process abstraction that allows simple
+// organization, and orchestration of work. It is much like a WaitGroup,
+// and much like a context.Context, but also ensures safe **exactly-once**,
+// and well-ordered teardown semantics.
+package goprocess
+
+import (
+	"os"
+	"os/signal"
+)
+
+// Process is the basic unit of work in goprocess. It defines a computation
+// with a lifecycle:
+// - running (before calling Close),
+// - closing (after calling Close at least once),
+// - closed (after Close returns, and all teardown has _completed_).
+//
+// More specifically, it fits this:
+//
+//   p := WithTeardown(tf) // new process is created, it is now running.
+//   p.AddChild(q)         // can register children **before** Closed().
+//   go p.Close()          // blocks until done running teardown func.
+//   <-p.Closing()         // would now return true.
+//   <-p.childrenDone()    // wait on all children to be done
+//   p.teardown()          // runs the user's teardown function tf.
+//   p.Close()             // now returns, with error teardown returned.
+//   <-p.Closed()          // would now return true.
+//
+// Processes can be arranged in a process "tree", where children are
+// automatically Closed if their parents are closed. (Note, it is actually
+// a Process DAG, children may have multiple parents). A process may also
+// optionally wait for another to fully Close before beginning to Close.
+// This makes it easy to ensure order of operations and proper sequential
+// teardown of resurces. For example:
+//
+//   p1 := goprocess.WithTeardown(func() error {
+//     fmt.Println("closing 1")
+//   })
+//   p2 := goprocess.WithTeardown(func() error {
+//     fmt.Println("closing 2")
+//   })
+//   p3 := goprocess.WithTeardown(func() error {
+//     fmt.Println("closing 3")
+//   })
+//
+//   p1.AddChild(p2)
+//   p2.AddChild(p3)
+//
+//
+//   go p1.Close()
+//   go p2.Close()
+//   go p3.Close()
+//
+//   // Output:
+//   // closing 3
+//   // closing 2
+//   // closing 1
+//
+// Process is modelled after the UNIX processes group idea, and heavily
+// informed by sync.WaitGroup and go.net/context.Context.
+//
+// In the function documentation of this interface, `p` always refers to
+// the self Process.
+type Process interface {
+
+	// WaitFor makes p wait for q before exiting. Thus, p will _always_ close
+	// _after_ q. Note well: a waiting cycle is deadlock.
+	//
+	// If q is already Closed, WaitFor calls p.Close()
+	// If p is already Closing or Closed, WaitFor panics. This is the same thing
+	// as calling Add(1) _after_ calling Done() on a wait group. Calling WaitFor
+	// on an already-closed process is a programming error likely due to bad
+	// synchronization
+	WaitFor(q Process)
+
+	// AddChildNoWait registers child as a "child" of Process. As in UNIX,
+	// when parent is Closed, child is Closed -- child may Close beforehand.
+	// This is the equivalent of calling:
+	//
+	//  go func(parent, child Process) {
+	//    <-parent.Closing()
+	//    child.Close()
+	//  }(p, q)
+	//
+	// Note: the naming of functions is `AddChildNoWait` and `AddChild` (instead
+	// of `AddChild` and `AddChildWaitFor`) because:
+	// - it is the more common operation,
+	// - explicitness is helpful in the less common case (no waiting), and
+	// - usual "child" semantics imply parent Processes should wait for children.
+	AddChildNoWait(q Process)
+
+	// AddChild is the equivalent of calling:
+	//  parent.AddChildNoWait(q)
+	//  parent.WaitFor(q)
+	AddChild(q Process)
+
+	// Go is much like `go`, as it runs a function in a newly spawned goroutine.
+	// The neat part of Process.Go is that the Process object you call it on will:
+	//  * construct a child Process, and call AddChild(child) on it
+	//  * spawn a goroutine, and call the given function
+	//  * Close the child when the function exits.
+	// This way, you can rest assured each goroutine you spawn has its very own
+	// Process context, and that it will be closed when the function exits.
+	// It is the function's responsibility to respect the Closing of its Process,
+	// namely it should exit (return) when <-Closing() is ready. It is basically:
+	//
+	//   func (p Process) Go(f ProcessFunc) Process {
+	//   	child := WithParent(p)
+	//   	go func () {
+	//   		f(child)
+	//   		child.Close()
+	//   	}()
+	//   }
+	//
+	// It is useful to construct simple asynchronous workers, children of p.
+	Go(f ProcessFunc) Process
+
+	// SetTeardown sets the process's teardown to tf.
+	SetTeardown(tf TeardownFunc)
+
+	// Close ends the process. Close blocks until the process has completely
+	// shut down, and any teardown has run _exactly once_. The returned error
+	// is available indefinitely: calling Close twice returns the same error.
+	// If the process has already been closed, Close returns immediately.
+	Close() error
+
+	// CloseAfterChildren calls Close _after_ its children have Closed
+	// normally (i.e. it _does not_ attempt to close them).
+	CloseAfterChildren() error
+
+	// Closing is a signal to wait upon. The returned channel is closed
+	// _after_ Close has been called at least once, but teardown may or may
+	// not be done yet. The primary use case of Closing is for children who
+	// need to know when a parent is shutting down, and therefore also shut
+	// down.
+	Closing() <-chan struct{}
+
+	// Closed is a signal to wait upon. The returned channel is closed
+	// _after_ Close has completed; teardown has finished. The primary use case
+	// of Closed is waiting for a Process to Close without _causing_ the Close.
+	Closed() <-chan struct{}
+
+	// Err waits until the process is closed, and then returns any error that
+	// occurred during shutdown.
+	Err() error
+}
+
+// TeardownFunc is a function used to cleanup state at the end of the
+// lifecycle of a Process.
+type TeardownFunc func() error
+
+// ProcessFunc is a function that takes a process. Its main use case is goprocess.Go,
+// which spawns a ProcessFunc in its own goroutine, and returns a corresponding
+// Process object.
+type ProcessFunc func(proc Process)
+
+var nilProcessFunc = func(Process) {}
+
+// Go is much like `go`: it runs a function in a newly spawned goroutine. The neat
+// part of Go is that it provides Process object to communicate between the
+// function and the outside world. Thus, callers can easily WaitFor, or Close the
+// function. It is the function's responsibility to respect the Closing of its Process,
+// namely it should exit (return) when <-Closing() is ready. It is simply:
+//
+//   func Go(f ProcessFunc) Process {
+//     p := WithParent(Background())
+//     p.Go(f)
+//     return p
+//   }
+//
+// Note that a naive implementation of Go like the following would not work:
+//
+//   func Go(f ProcessFunc) Process {
+//     return Background().Go(f)
+//   }
+//
+// This is because having the process you
+func Go(f ProcessFunc) Process {
+	// return GoChild(Background(), f)
+
+	// we use two processes, one for communication, and
+	// one for ensuring we wait on the function (unclosable from the outside).
+	p := newProcess(nil)
+	waitFor := newProcess(nil)
+	p.WaitFor(waitFor) // prevent p from closing
+	go func() {
+		f(p)
+		waitFor.Close() // allow p to close.
+		p.Close()       // ensure p closes.
+	}()
+	return p
+}
+
+// GoChild is like Go, but it registers the returned Process as a child of parent,
+// **before** spawning the goroutine, which ensures proper synchronization with parent.
+// It is somewhat like
+//
+//   func GoChild(parent Process, f ProcessFunc) Process {
+//     p := WithParent(parent)
+//     p.Go(f)
+//     return p
+//   }
+//
+// And it is similar to the classic WaitGroup use case:
+//
+//   func WaitGroupGo(wg sync.WaitGroup, child func()) {
+//     wg.Add(1)
+//     go func() {
+//       child()
+//       wg.Done()
+//     }()
+//   }
+//
+func GoChild(parent Process, f ProcessFunc) Process {
+	p := WithParent(parent)
+	p.Go(f)
+	return p
+}
+
+// Spawn is an alias of `Go`. In many contexts, Spawn is a
+// well-known Process launching word, which fits our use case.
+var Spawn = Go
+
+// SpawnChild is an alias of `GoChild`. In many contexts, Spawn is a
+// well-known Process launching word, which fits our use case.
+var SpawnChild = GoChild
+
+// WithTeardown constructs and returns a Process with a TeardownFunc.
+// TeardownFunc tf will be called **exactly-once** when Process is
+// Closing, after all Children have fully closed, and before p is Closed.
+// In fact, Process p will not be Closed until tf runs and exits.
+// See lifecycle in Process doc.
+func WithTeardown(tf TeardownFunc) Process {
+	if tf == nil {
+		panic("nil tf TeardownFunc")
+	}
+	return newProcess(tf)
+}
+
+// WithParent constructs and returns a Process with a given parent.
+func WithParent(parent Process) Process {
+	if parent == nil {
+		panic("nil parent Process")
+	}
+	q := newProcess(nil)
+	parent.AddChild(q)
+	return q
+}
+
+// WithSignals returns a Process that will Close() when any given signal fires.
+// This is useful to bind Process trees to syscall.SIGTERM, SIGKILL, etc.
+func WithSignals(sig ...os.Signal) Process {
+	p := WithParent(Background())
+	c := make(chan os.Signal)
+	signal.Notify(c, sig...)
+	go func() {
+		<-c
+		signal.Stop(c)
+		p.Close()
+	}()
+	return p
+}
+
+// Background returns the "background" Process: a statically allocated
+// process that can _never_ close. It also never enters Closing() state.
+// Calling Background().Close() will hang indefinitely.
+func Background() Process {
+	return background
+}
+
+// background is the background process
+var background = &unclosable{Process: newProcess(nil)}
+
+// unclosable is a process that _cannot_ be closed. calling Close simply hangs.
+type unclosable struct {
+	Process
+}
+
+func (p *unclosable) Close() error {
+	var hang chan struct{}
+	<-hang // hang forever
+	return nil
+}
diff --git a/vendor/github.com/jbenet/goprocess/impl-mutex.go b/vendor/github.com/jbenet/goprocess/impl-mutex.go
new file mode 100644
index 000000000..fb86fcce2
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/impl-mutex.go
@@ -0,0 +1,271 @@
+package goprocess
+
+import (
+	"sync"
+)
+
+// process implements Process
+type process struct {
+	children map[*processLink]struct{} // process to close with us
+	waitfors map[*processLink]struct{} // process to only wait for
+	waiters  []*processLink            // processes that wait for us. for gc.
+
+	teardown TeardownFunc  // called to run the teardown logic.
+	waiting  chan struct{} // closed when CloseAfterChildrenClosed is called.
+	closing  chan struct{} // closed once close starts.
+	closed   chan struct{} // closed once close is done.
+	closeErr error         // error to return to clients of Close()
+
+	sync.Mutex
+}
+
+// newProcess constructs and returns a Process.
+// It will call tf TeardownFunc exactly once:
+//  **after** all children have fully Closed,
+//  **after** entering <-Closing(), and
+//  **before** <-Closed().
+func newProcess(tf TeardownFunc) *process {
+	return &process{
+		teardown: tf,
+		closed:   make(chan struct{}),
+		closing:  make(chan struct{}),
+		waitfors: make(map[*processLink]struct{}),
+		children: make(map[*processLink]struct{}),
+	}
+}
+
+func (p *process) WaitFor(q Process) {
+	if q == nil {
+		panic("waiting for nil process")
+	}
+
+	p.Lock()
+
+	select {
+	case <-p.Closed():
+		panic("Process cannot wait after being closed")
+	default:
+	}
+
+	pl := newProcessLink(p, q)
+	p.waitfors[pl] = struct{}{}
+	p.Unlock()
+	go pl.AddToChild()
+}
+
+func (p *process) AddChildNoWait(child Process) {
+	if child == nil {
+		panic("adding nil child process")
+	}
+
+	p.Lock()
+
+	select {
+	case <-p.Closed():
+		panic("Process cannot add children after being closed")
+	case <-p.Closing():
+		go child.Close()
+	default:
+	}
+
+	pl := newProcessLink(p, child)
+	p.children[pl] = struct{}{}
+	p.Unlock()
+	go pl.AddToChild()
+}
+
+func (p *process) AddChild(child Process) {
+	if child == nil {
+		panic("adding nil child process")
+	}
+
+	p.Lock()
+
+	select {
+	case <-p.Closed():
+		panic("Process cannot add children after being closed")
+	case <-p.Closing():
+		go child.Close()
+	default:
+	}
+
+	pl := newProcessLink(p, child)
+	if p.waitfors != nil { // if p.waitfors hasn't been set nil
+		p.waitfors[pl] = struct{}{}
+	}
+	if p.children != nil { // if p.children hasn't been set nil
+		p.children[pl] = struct{}{}
+	}
+	p.Unlock()
+	go pl.AddToChild()
+}
+
+func (p *process) Go(f ProcessFunc) Process {
+	child := newProcess(nil)
+	waitFor := newProcess(nil)
+	child.WaitFor(waitFor) // prevent child from closing
+
+	// add child last, to prevent a closing parent from
+	// closing all of them prematurely, before running the func.
+	p.AddChild(child)
+	go func() {
+		f(child)
+		waitFor.Close()            // allow child to close.
+		child.CloseAfterChildren() // close to tear down.
+	}()
+	return child
+}
+
+// SetTeardown to assign a teardown function
+func (p *process) SetTeardown(tf TeardownFunc) {
+	if tf == nil {
+		panic("cannot set nil TeardownFunc")
+	}
+
+	p.Lock()
+	if p.teardown != nil {
+		panic("cannot SetTeardown twice")
+	}
+
+	p.teardown = tf
+	select {
+	case <-p.Closed():
+		p.closeErr = tf()
+	default:
+	}
+	p.Unlock()
+}
+
+// Close is the external close function.
+// it's a wrapper around internalClose that waits on Closed()
+func (p *process) Close() error {
+	p.Lock()
+
+	// if already closing, or closed, get out. (but wait!)
+	select {
+	case <-p.Closing():
+		p.Unlock()
+		<-p.Closed()
+		return p.closeErr
+	default:
+	}
+
+	p.doClose()
+	p.Unlock()
+	return p.closeErr
+}
+
+func (p *process) Closing() <-chan struct{} {
+	return p.closing
+}
+
+func (p *process) Closed() <-chan struct{} {
+	return p.closed
+}
+
+func (p *process) Err() error {
+	<-p.Closed()
+	return p.closeErr
+}
+
+// the _actual_ close process.
+func (p *process) doClose() {
+	// this function is only be called once (protected by p.Lock()).
+	// and it will panic (on closing channels) otherwise.
+
+	close(p.closing) // signal that we're shutting down (Closing)
+
+	for len(p.children) > 0 || len(p.waitfors) > 0 {
+		for plc, _ := range p.children {
+			child := plc.Child()
+			if child != nil { // check because child may already have been removed.
+				go child.Close() // force all children to shut down
+			}
+			plc.ParentClear()
+		}
+		p.children = nil // clear them. release memory.
+
+		// we must be careful not to iterate over waitfors directly, as it may
+		// change under our feet.
+		wf := p.waitfors
+		p.waitfors = nil // clear them. release memory.
+		for w, _ := range wf {
+			// Here, we wait UNLOCKED, so that waitfors who are in the middle of
+			// adding a child to us can finish. we will immediately close the child.
+			p.Unlock()
+			<-w.ChildClosed() // wait till all waitfors are fully closed (before teardown)
+			p.Lock()
+			w.ParentClear()
+		}
+	}
+
+	if p.teardown != nil {
+		p.closeErr = p.teardown() // actually run the close logic (ok safe to teardown)
+	}
+	close(p.closed) // signal that we're shut down (Closed)
+
+	// go remove all the parents from the process links. optimization.
+	go func(waiters []*processLink) {
+		for _, pl := range waiters {
+			pl.ClearChild()
+			pr, ok := pl.Parent().(*process)
+			if !ok {
+				// parent has already been called to close
+				continue
+			}
+			pr.Lock()
+			delete(pr.waitfors, pl)
+			delete(pr.children, pl)
+			pr.Unlock()
+		}
+	}(p.waiters) // pass in so
+	p.waiters = nil // clear them. release memory.
+}
+
+// We will only wait on the children we have now.
+// We will not wait on children added subsequently.
+// this may change in the future.
+func (p *process) CloseAfterChildren() error {
+	p.Lock()
+	select {
+	case <-p.Closed():
+		p.Unlock()
+		return p.Close() // get error. safe, after p.Closed()
+	case <-p.waiting: // already called it.
+		p.Unlock()
+		<-p.Closed()
+		return p.Close() // get error. safe, after p.Closed()
+	default:
+	}
+	p.Unlock()
+
+	// here only from one goroutine.
+
+	nextToWaitFor := func() Process {
+		p.Lock()
+		defer p.Unlock()
+		for e, _ := range p.waitfors {
+			c := e.Child()
+			if c == nil {
+				continue
+			}
+
+			select {
+			case <-c.Closed():
+			default:
+				return c
+			}
+		}
+		return nil
+	}
+
+	// wait for all processes we're waiting for are closed.
+	// the semantics here are simple: we will _only_ close
+	// if there are no processes currently waiting for.
+	for next := nextToWaitFor(); next != nil; next = nextToWaitFor() {
+		<-next.Closed()
+	}
+
+	// YAY! we're done. close
+	return p.Close()
+}
diff --git a/vendor/github.com/jbenet/goprocess/link.go b/vendor/github.com/jbenet/goprocess/link.go
new file mode 100644
index 000000000..c344c1e61
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/link.go
@@ -0,0 +1,121 @@
+package goprocess
+
+import (
+	"sync"
+)
+
+// closedCh is an alread-closed channel. used to return
+// in cases where we already know a channel is closed.
+var closedCh chan struct{}
+
+func init() {
+	closedCh = make(chan struct{})
+	close(closedCh)
+}
+
+// a processLink is an internal bookkeeping datastructure.
+// it's used to form a relationship between two processes.
+// It is mostly for keeping memory usage down (letting
+// children close and be garbage-collected).
+type processLink struct {
+	// guards all fields.
+	// DO NOT HOLD while holding process locks.
+	// it may be slow, and could deadlock if not careful.
+	sync.Mutex
+	parent Process
+	child  Process
+}
+
+func newProcessLink(p, c Process) *processLink {
+	return &processLink{
+		parent: p,
+		child:  c,
+	}
+}
+
+// Closing returns whether the child is closing
+func (pl *processLink) ChildClosing() <-chan struct{} {
+	// grab a hold of it, and unlock, as .Closing may block.
+	pl.Lock()
+	child := pl.child
+	pl.Unlock()
+
+	if child == nil { // already closed? memory optimization.
+		return closedCh
+	}
+	return child.Closing()
+}
+
+func (pl *processLink) ChildClosed() <-chan struct{} {
+	// grab a hold of it, and unlock, as .Closed may block.
+	pl.Lock()
+	child := pl.child
+	pl.Unlock()
+
+	if child == nil { // already closed? memory optimization.
+		return closedCh
+	}
+	return child.Closed()
+}
+
+func (pl *processLink) ChildClose() {
+	// grab a hold of it, and unlock, as .Closed may block.
+	pl.Lock()
+	child := pl.child
+	pl.Unlock()
+
+	if child != nil { // already closed? memory optimization.
+		child.Close()
+	}
+}
+
+func (pl *processLink) ClearChild() {
+	pl.Lock()
+	pl.child = nil
+	pl.Unlock()
+}
+
+func (pl *processLink) ParentClear() {
+	pl.Lock()
+	pl.parent = nil
+	pl.Unlock()
+}
+
+func (pl *processLink) Child() Process {
+	pl.Lock()
+	defer pl.Unlock()
+	return pl.child
+}
+
+func (pl *processLink) Parent() Process {
+	pl.Lock()
+	defer pl.Unlock()
+	return pl.parent
+}
+
+func (pl *processLink) AddToChild() {
+	cp := pl.Child()
+
+	// is it a *process ? if not... panic.
+	c, ok := cp.(*process)
+	if !ok {
+		panic("goprocess does not yet support other process impls.")
+	}
+
+	// first, is it Closed?
+	c.Lock()
+	select {
+	case <-c.Closed():
+		c.Unlock()
+
+		// already closed. must not add.
+		// we must clear it, though. do so without the lock.
+		pl.ClearChild()
+		return
+
+	default:
+		// put the process link into q's waiters
+		c.waiters = append(c.waiters, pl)
+		c.Unlock()
+	}
+}
diff --git a/vendor/github.com/jbenet/goprocess/periodic/periodic.go b/vendor/github.com/jbenet/goprocess/periodic/periodic.go
new file mode 100644
index 000000000..823c43dcf
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/periodic/periodic.go
@@ -0,0 +1,232 @@
+// Package periodic is part of github.com/jbenet/goprocess.
+// It provides a simple periodic processor that calls a function
+// periodically based on some options.
+//
+// For example:
+//
+//    // use a time.Duration
+//    p := periodicproc.Every(time.Second, func(proc goprocess.Process) {
+//    	fmt.Printf("the time is %s and all is well", time.Now())
+//    })
+//
+//    <-time.After(5*time.Second)
+//    p.Close()
+//
+//    // use a time.Time channel (like time.Ticker)
+//    p := periodicproc.Tick(time.Tick(time.Second), func(proc goprocess.Process) {
+//    	fmt.Printf("the time is %s and all is well", time.Now())
+//    })
+//
+//    <-time.After(5*time.Second)
+//    p.Close()
+//
+//    // or arbitrary signals
+//    signal := make(chan struct{})
+//    p := periodicproc.OnSignal(signal, func(proc goprocess.Process) {
+//    	fmt.Printf("the time is %s and all is well", time.Now())
+//    })
+//
+//    signal<- struct{}{}
+//    signal<- struct{}{}
+//    <-time.After(5 * time.Second)
+//    signal<- struct{}{}
+//    p.Close()
+//
+package periodicproc
+
+import (
+	"time"
+
+	gp "github.com/jbenet/goprocess"
+)
+
+// Every calls the given ProcessFunc at periodic intervals. Internally, it uses
+// <-time.After(interval), so it will have the behavior of waiting _at least_
+// interval in between calls. If you'd prefer the time.Ticker behavior, use
+// periodicproc.Tick instead.
+// This is sequentially rate limited, only one call will be in-flight at a time.
+func Every(interval time.Duration, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		for {
+			select {
+			case <-time.After(interval):
+				select {
+				case <-proc.Go(procfunc).Closed(): // spin it out as a child, and wait till it's done.
+				case <-proc.Closing(): // we're told to close
+					return
+				}
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	})
+}
+
+// EveryGo calls the given ProcessFunc at periodic intervals. Internally, it uses
+// <-time.After(interval)
+// This is not rate limited, multiple calls could be in-flight at the same time.
+func EveryGo(interval time.Duration, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		for {
+			select {
+			case <-time.After(interval):
+				proc.Go(procfunc)
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	})
+}
+
+// Tick constructs a ticker with interval, and calls the given ProcessFunc every
+// time the ticker fires.
+// This is sequentially rate limited, only one call will be in-flight at a time.
+//
+//  p := periodicproc.Tick(time.Second, func(proc goprocess.Process) {
+//  	fmt.Println("fire!")
+//  })
+//
+//  <-time.After(3 * time.Second)
+//  p.Close()
+//
+//  // Output:
+//  // fire!
+//  // fire!
+//  // fire!
+func Tick(interval time.Duration, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		ticker := time.NewTicker(interval)
+		callOnTicker(ticker.C, procfunc)(proc)
+		ticker.Stop()
+	})
+}
+
+// TickGo constructs a ticker with interval, and calls the given ProcessFunc every
+// time the ticker fires.
+// This is not rate limited, multiple calls could be in-flight at the same time.
+//
+//  p := periodicproc.TickGo(time.Second, func(proc goprocess.Process) {
+//  	fmt.Println("fire!")
+//  	<-time.After(10 * time.Second) // will not block sequential execution
+//  })
+//
+//  <-time.After(3 * time.Second)
+//  p.Close()
+//
+//  // Output:
+//  // fire!
+//  // fire!
+//  // fire!
+func TickGo(interval time.Duration, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		ticker := time.NewTicker(interval)
+		goCallOnTicker(ticker.C, procfunc)(proc)
+		ticker.Stop()
+	})
+}
+
+// Ticker calls the given ProcessFunc every time the ticker fires.
+// This is sequentially rate limited, only one call will be in-flight at a time.
+func Ticker(ticker <-chan time.Time, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(callOnTicker(ticker, procfunc))
+}
+
+// TickerGo calls the given ProcessFunc every time the ticker fires.
+// This is not rate limited, multiple calls could be in-flight at the same time.
+func TickerGo(ticker <-chan time.Time, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(goCallOnTicker(ticker, procfunc))
+}
+
+func callOnTicker(ticker <-chan time.Time, pf gp.ProcessFunc) gp.ProcessFunc {
+	return func(proc gp.Process) {
+		for {
+			select {
+			case <-ticker:
+				select {
+				case <-proc.Go(pf).Closed(): // spin it out as a child, and wait till it's done.
+				case <-proc.Closing(): // we're told to close
+					return
+				}
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	}
+}
+
+func goCallOnTicker(ticker <-chan time.Time, pf gp.ProcessFunc) gp.ProcessFunc {
+	return func(proc gp.Process) {
+		for {
+			select {
+			case <-ticker:
+				proc.Go(pf)
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	}
+}
+
+// OnSignal calls the given ProcessFunc every time the signal fires, and waits for it to exit.
+// This is sequentially rate limited, only one call will be in-flight at a time.
+//
+//  sig := make(chan struct{})
+//  p := periodicproc.OnSignal(sig, func(proc goprocess.Process) {
+//  	fmt.Println("fire!")
+//  	<-time.After(time.Second) // delays sequential execution by 1 second
+//  })
+//
+//  sig<- struct{}
+//  sig<- struct{}
+//  sig<- struct{}
+//
+//  // Output:
+//  // fire!
+//  // fire!
+//  // fire!
+func OnSignal(sig <-chan struct{}, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		for {
+			select {
+			case <-sig:
+				select {
+				case <-proc.Go(procfunc).Closed(): // spin it out as a child, and wait till it's done.
+				case <-proc.Closing(): // we're told to close
+					return
+				}
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	})
+}
+
+// OnSignalGo calls the given ProcessFunc every time the signal fires.
+// This is not rate limited, multiple calls could be in-flight at the same time.
+//
+//  sig := make(chan struct{})
+//  p := periodicproc.OnSignalGo(sig, func(proc goprocess.Process) {
+//  	fmt.Println("fire!")
+//  	<-time.After(time.Second) // wont block execution
+//  })
+//
+//  sig<- struct{}
+//  sig<- struct{}
+//  sig<- struct{}
+//
+//  // Output:
+//  // fire!
+//  // fire!
+//  // fire!
+func OnSignalGo(sig <-chan struct{}, procfunc gp.ProcessFunc) gp.Process {
+	return gp.Go(func(proc gp.Process) {
+		for {
+			select {
+			case <-sig:
+				proc.Go(procfunc)
+			case <-proc.Closing(): // we're told to close
+				return
+			}
+		}
+	})
+}
diff --git a/vendor/github.com/jbenet/goprocess/ratelimit/ratelimit.go b/vendor/github.com/jbenet/goprocess/ratelimit/ratelimit.go
new file mode 100644
index 000000000..1838d0537
--- /dev/null
+++ b/vendor/github.com/jbenet/goprocess/ratelimit/ratelimit.go
@@ -0,0 +1,68 @@
+// Package ratelimit is part of github.com/jbenet/goprocess.
+// It provides a simple process that ratelimits child creation.
+// This is done internally with a channel/semaphore.
+// So the call `RateLimiter.LimitedGo` may block until another
+// child is Closed().
+package ratelimit
+
+import (
+	process "github.com/jbenet/goprocess"
+)
+
+// RateLimiter limits the spawning of children. It does so
+// with an internal semaphore. Note that Go will continue
+// to be the unlimited process.Process.Go, and ONLY the
+// added function `RateLimiter.LimitedGo` will honor the
+// limit. This is to improve readability and avoid confusion
+// for the reader, particularly if code changes over time.
+type RateLimiter struct {
+	process.Process
+
+	limiter chan struct{}
+}
+
+func NewRateLimiter(parent process.Process, limit int) *RateLimiter {
+	proc := process.WithParent(parent)
+	return &RateLimiter{Process: proc, limiter: LimitChan(limit)}
+}
+
+// LimitedGo creates a new process, adds it as a child, and spawns the
+// ProcessFunc f in its own goroutine, but may block according to the
+// internal rate limit. It is equivalent to:
+//
+//   func(f process.ProcessFunc) {
+//      <-limitch
+//      p.Go(func (child process.Process) {
+//        f(child)
+//        f.Close() // make sure its children close too!
+//        limitch<- struct{}{}
+//      })
+///  }
+//
+// It is useful to construct simple asynchronous workers, children of p,
+// and rate limit their creation, to avoid spinning up too many, too fast.
+// This is great for providing backpressure to producers.
+func (rl *RateLimiter) LimitedGo(f process.ProcessFunc) {
+
+	<-rl.limiter
+	p := rl.Go(f)
+
+	// this <-closed() is here because the child may have spawned
+	// children of its own, and our rate limiter should capture that.
+	go func() {
+		<-p.Closed()
+		rl.limiter <- struct{}{}
+	}()
+}
+
+// LimitChan returns a rate-limiting channel. it is the usual, simple,
+// golang-idiomatic rate-limiting semaphore. This function merely
+// initializes it with certain buffer size, and sends that many values,
+// so it is ready to be used.
+func LimitChan(limit int) chan struct{} {
+	limitch := make(chan struct{}, limit)
+	for i := 0; i < limit; i++ {
+		limitch <- struct{}{}
+	}
+	return limitch
+}
diff --git a/vendor/github.com/libp2p/go-addr-util/LICENSE b/vendor/github.com/libp2p/go-addr-util/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-addr-util/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-addr-util/addr.go b/vendor/github.com/libp2p/go-addr-util/addr.go
new file mode 100644
index 000000000..f27e5b72c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-addr-util/addr.go
@@ -0,0 +1,197 @@
+package addrutil
+
+import (
+	"context"
+	"fmt"
+
+	logging "github.com/ipfs/go-log"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+var log = logging.Logger("addrutil")
+
+// FilterAddrs is a filter that removes certain addresses, according the given filters.
+// if all filters return true, the address is kept.
+func FilterAddrs(a []ma.Multiaddr, filters ...func(ma.Multiaddr) bool) []ma.Multiaddr {
+	b := make([]ma.Multiaddr, 0, len(a))
+	for _, addr := range a {
+		good := true
+		for _, filter := range filters {
+			good = good && filter(addr)
+		}
+		if good {
+			b = append(b, addr)
+		}
+	}
+	return b
+}
+
+// AddrOverNonLocalIP returns whether the addr uses a non-local ip link
+func AddrOverNonLocalIP(a ma.Multiaddr) bool {
+	split := ma.Split(a)
+	if len(split) < 1 {
+		return false
+	}
+	if manet.IsIP6LinkLocal(split[0]) {
+		return false
+	}
+	return true
+}
+
+// ResolveUnspecifiedAddress expands an unspecified ip addresses (/ip4/0.0.0.0, /ip6/::) to
+// use the known local interfaces. If ifaceAddr is nil, we request interface addresses
+// from the network stack. (this is so you can provide a cached value if resolving many addrs)
+func ResolveUnspecifiedAddress(resolve ma.Multiaddr, ifaceAddrs []ma.Multiaddr) ([]ma.Multiaddr, error) {
+	// split address into its components
+	split := ma.Split(resolve)
+
+	// if first component (ip) is not unspecified, use it as is.
+	if !manet.IsIPUnspecified(split[0]) {
+		return []ma.Multiaddr{resolve}, nil
+	}
+
+	out := make([]ma.Multiaddr, 0, len(ifaceAddrs))
+	for _, ia := range ifaceAddrs {
+		// must match the first protocol to be resolve.
+		if ia.Protocols()[0].Code != resolve.Protocols()[0].Code {
+			continue
+		}
+
+		split[0] = ia
+		joined := ma.Join(split...)
+		out = append(out, joined)
+		log.Debug("adding resolved addr:", resolve, joined, out)
+	}
+	if len(out) < 1 {
+		return nil, fmt.Errorf("failed to resolve: %s", resolve)
+	}
+	return out, nil
+}
+
+// ResolveUnspecifiedAddresses expands unspecified ip addresses (/ip4/0.0.0.0, /ip6/::) to
+// use the known local interfaces.
+func ResolveUnspecifiedAddresses(unspecAddrs, ifaceAddrs []ma.Multiaddr) ([]ma.Multiaddr, error) {
+
+	// todo optimize: only fetch these if we have a "any" addr.
+	if len(ifaceAddrs) < 1 {
+		var err error
+		ifaceAddrs, err = InterfaceAddresses()
+		if err != nil {
+			return nil, err
+		}
+		// log.Debug("InterfaceAddresses:", ifaceAddrs)
+	}
+
+	var outputAddrs []ma.Multiaddr
+	for _, a := range unspecAddrs {
+		// unspecified?
+		resolved, err := ResolveUnspecifiedAddress(a, ifaceAddrs)
+		if err != nil {
+			continue // optimistic. if we cant resolve anything, we'll know at the bottom.
+		}
+		// log.Debug("resolved:", a, resolved)
+		outputAddrs = append(outputAddrs, resolved...)
+	}
+
+	if len(outputAddrs) < 1 {
+		return nil, fmt.Errorf("failed to specify addrs: %s", unspecAddrs)
+	}
+
+	log.Event(context.TODO(), "interfaceListenAddresses", func() logging.Loggable {
+		var addrs []string
+		for _, addr := range outputAddrs {
+			addrs = append(addrs, addr.String())
+		}
+		return logging.Metadata{"addresses": addrs}
+	}())
+
+	log.Debug("ResolveUnspecifiedAddresses:", unspecAddrs, ifaceAddrs, outputAddrs)
+	return outputAddrs, nil
+}
+
+// InterfaceAddresses returns a list of addresses associated with local machine
+// Note: we do not return link local addresses. IP loopback is ok, because we
+// may be connecting to other nodes in the same machine.
+func InterfaceAddresses() ([]ma.Multiaddr, error) {
+	maddrs, err := manet.InterfaceMultiaddrs()
+	if err != nil {
+		return nil, err
+	}
+	log.Debug("InterfaceAddresses: from manet:", maddrs)
+
+	var out []ma.Multiaddr
+	for _, a := range maddrs {
+		if !AddrOverNonLocalIP(a) {
+			// log.Debug("InterfaceAddresses: skipping unusable:", a)
+			continue
+		}
+
+		out = append(out, a)
+	}
+
+	log.Debug("InterfaceAddresses: usable:", out)
+	return out, nil
+}
+
+// AddrInList returns whether or not an address is part of a list.
+// this is useful to check if NAT is happening (or other bugs?)
+func AddrInList(addr ma.Multiaddr, list []ma.Multiaddr) bool {
+	for _, addr2 := range list {
+		if addr.Equal(addr2) {
+			return true
+		}
+	}
+	return false
+}
+
+// AddrIsShareableOnWAN returns whether the given address should be shareable on the
+// wide area network (wide internet).
+func AddrIsShareableOnWAN(addr ma.Multiaddr) bool {
+	s := ma.Split(addr)
+	if len(s) < 1 {
+		return false
+	}
+	a := s[0]
+	if manet.IsIPLoopback(a) || manet.IsIP6LinkLocal(a) || manet.IsIPUnspecified(a) {
+		return false
+	}
+	return manet.IsThinWaist(a)
+}
+
+// WANShareableAddrs filters addresses based on whether they're shareable on WAN
+func WANShareableAddrs(inp []ma.Multiaddr) []ma.Multiaddr {
+	return FilterAddrs(inp, AddrIsShareableOnWAN)
+}
+
+// Subtract filters out all addrs in b from a
+func Subtract(a, b []ma.Multiaddr) []ma.Multiaddr {
+	return FilterAddrs(a, func(m ma.Multiaddr) bool {
+		for _, bb := range b {
+			if m.Equal(bb) {
+				return false
+			}
+		}
+		return true
+	})
+}
+
+// CheckNATWarning checks if our observed addresses differ. if so,
+// informs the user that certain things might not work yet
+func CheckNATWarning(observed, expected ma.Multiaddr, listen []ma.Multiaddr) {
+	if observed.Equal(expected) {
+		return
+	}
+
+	if !AddrInList(observed, listen) { // probably a nat
+		log.Warningf(natWarning, observed, listen)
+	}
+}
+
+const natWarning = `Remote peer observed our address to be: %s
+The local addresses are: %s
+Thus, connection is going through NAT, and other connections may fail.
+
+IPFS NAT traversal is still under development. Please bug us on github or irc to fix this.
+Baby steps: http://jbenet.static.s3.amazonaws.com/271dfcf/baby-steps.gif
+`
diff --git a/vendor/github.com/libp2p/go-addr-util/filter.go b/vendor/github.com/libp2p/go-addr-util/filter.go
new file mode 100644
index 000000000..dc9cddbff
--- /dev/null
+++ b/vendor/github.com/libp2p/go-addr-util/filter.go
@@ -0,0 +1,31 @@
+package addrutil
+
+import (
+	ma "github.com/multiformats/go-multiaddr"
+	mafmt "github.com/whyrusleeping/mafmt"
+)
+
+// SubtractFilter returns a filter func that filters all of the given addresses
+func SubtractFilter(addrs ...ma.Multiaddr) func(ma.Multiaddr) bool {
+	addrmap := make(map[string]bool, len(addrs))
+	for _, a := range addrs {
+		addrmap[string(a.Bytes())] = true
+	}
+
+	return func(a ma.Multiaddr) bool {
+		return !addrmap[string(a.Bytes())]
+	}
+}
+
+// IsFDCostlyTransport returns true for transports that require a new file
+// descriptor per connection created
+func IsFDCostlyTransport(a ma.Multiaddr) bool {
+	return mafmt.TCP.Matches(a)
+}
+
+// FilterNeg returns a negated version of the passed in filter
+func FilterNeg(f func(ma.Multiaddr) bool) func(ma.Multiaddr) bool {
+	return func(a ma.Multiaddr) bool {
+		return !f(a)
+	}
+}
diff --git a/vendor/github.com/libp2p/go-conn-security-multistream/LICENSE b/vendor/github.com/libp2p/go-conn-security-multistream/LICENSE
new file mode 100644
index 000000000..6cccfc2ba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-conn-security-multistream/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Protocol Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-conn-security-multistream/ssms.go b/vendor/github.com/libp2p/go-conn-security-multistream/ssms.go
new file mode 100644
index 000000000..312b775cd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-conn-security-multistream/ssms.go
@@ -0,0 +1,87 @@
+package csms
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	connsec "github.com/libp2p/go-conn-security"
+	peer "github.com/libp2p/go-libp2p-peer"
+	mss "github.com/multiformats/go-multistream"
+)
+
+// SSMuxer is a multistream stream security transport multiplexer.
+//
+// SSMuxer is safe to use without initialization. However, it's not safe to move
+// after use.
+type SSMuxer struct {
+	mux             mss.MultistreamMuxer
+	tpts            map[string]connsec.Transport
+	OrderPreference []string
+}
+
+var _ connsec.Transport = (*SSMuxer)(nil)
+
+// AddTransport adds a stream security transport to this multistream muxer.
+//
+// This method is *not* thread-safe. It should be called only when initializing
+// the SSMuxer.
+func (sm *SSMuxer) AddTransport(path string, transport connsec.Transport) {
+	if sm.tpts == nil {
+		sm.tpts = make(map[string]connsec.Transport, 1)
+	}
+
+	sm.mux.AddHandler(path, nil)
+	sm.tpts[path] = transport
+	sm.OrderPreference = append(sm.OrderPreference, path)
+}
+
+// SecureInbound secures an inbound connection using this multistream
+// multiplexed stream security transport.
+func (sm *SSMuxer) SecureInbound(ctx context.Context, insecure net.Conn) (connsec.Conn, error) {
+	tpt, err := sm.selectProto(ctx, insecure, true)
+	if err != nil {
+		return nil, err
+	}
+	return tpt.SecureInbound(ctx, insecure)
+}
+
+// SecureOutbound secures an outbound connection using this multistream
+// multiplexed stream security transport.
+func (sm *SSMuxer) SecureOutbound(ctx context.Context, insecure net.Conn, p peer.ID) (connsec.Conn, error) {
+	tpt, err := sm.selectProto(ctx, insecure, false)
+	if err != nil {
+		return nil, err
+	}
+	return tpt.SecureOutbound(ctx, insecure, p)
+}
+
+func (sm *SSMuxer) selectProto(ctx context.Context, insecure net.Conn, server bool) (connsec.Transport, error) {
+	var proto string
+	var err error
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		if server {
+			proto, _, err = sm.mux.Negotiate(insecure)
+		} else {
+			proto, err = mss.SelectOneOf(sm.OrderPreference, insecure)
+		}
+	}()
+
+	select {
+	case <-done:
+		if err != nil {
+			return nil, err
+		}
+		if tpt, ok := sm.tpts[proto]; ok {
+			return tpt, nil
+		}
+		return nil, fmt.Errorf("selected unknown security transport")
+	case <-ctx.Done():
+		// We *must* do this. We have outstanding work on the connection
+		// and it's no longer safe to use.
+		insecure.Close()
+		return nil, ctx.Err()
+	}
+}
diff --git a/vendor/github.com/libp2p/go-conn-security/LICENSE b/vendor/github.com/libp2p/go-conn-security/LICENSE
new file mode 100644
index 000000000..6cccfc2ba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-conn-security/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Protocol Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-conn-security/insecure/insecure.go b/vendor/github.com/libp2p/go-conn-security/insecure/insecure.go
new file mode 100644
index 000000000..4c2cf6b0a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-conn-security/insecure/insecure.go
@@ -0,0 +1,86 @@
+package insecure
+
+import (
+	"context"
+	"net"
+
+	security "github.com/libp2p/go-conn-security"
+
+	ci "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// ID is the multistream-select protocol ID that should be used when identifying
+// this security transport.
+const ID = "/plaintext/1.0.0"
+
+// Transport is a no-op stream security transport. It provides no
+// security and simply wraps connections in blank
+type Transport struct {
+	id peer.ID
+}
+
+// New constructs a new insecure transport.
+func New(id peer.ID) *Transport {
+	return &Transport{
+		id: id,
+	}
+}
+
+// LocalPeer returns the transports local peer ID.
+func (t *Transport) LocalPeer() peer.ID {
+	return t.id
+}
+
+// LocalPrivateKey returns nil. This transport is not secure.
+func (t *Transport) LocalPrivateKey() ci.PrivKey {
+	return nil
+}
+
+// SecureInbound *pretends to secure* an outbound connection to the given peer.
+func (t *Transport) SecureInbound(ctx context.Context, insecure net.Conn) (security.Conn, error) {
+	return &Conn{
+		Conn:  insecure,
+		local: t.id,
+	}, nil
+}
+
+// SecureOutbound *pretends to secure* an outbound connection to the given peer.
+func (t *Transport) SecureOutbound(ctx context.Context, insecure net.Conn, p peer.ID) (security.Conn, error) {
+	return &Conn{
+		Conn:   insecure,
+		local:  t.id,
+		remote: p,
+	}, nil
+}
+
+// Conn is the connection type returned by the insecure transport.
+type Conn struct {
+	net.Conn
+	local  peer.ID
+	remote peer.ID
+}
+
+// LocalPeer returns the local peer ID.
+func (ic *Conn) LocalPeer() peer.ID {
+	return ic.local
+}
+
+// RemotePeer returns the remote peer ID if we initiated the dial. Otherwise, it
+// returns "" (because this connection isn't actually secure).
+func (ic *Conn) RemotePeer() peer.ID {
+	return ic.remote
+}
+
+// RemotePublicKey returns nil. This connection is not secure
+func (ic *Conn) RemotePublicKey() ci.PubKey {
+	return nil
+}
+
+// LocalPrivateKey returns nil. This connection is not secure.
+func (ic *Conn) LocalPrivateKey() ci.PrivKey {
+	return nil
+}
+
+var _ security.Transport = (*Transport)(nil)
+var _ security.Conn = (*Conn)(nil)
diff --git a/vendor/github.com/libp2p/go-conn-security/interface.go b/vendor/github.com/libp2p/go-conn-security/interface.go
new file mode 100644
index 000000000..844c13996
--- /dev/null
+++ b/vendor/github.com/libp2p/go-conn-security/interface.go
@@ -0,0 +1,25 @@
+package connsec
+
+import (
+	"context"
+	"net"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// A Transport turns inbound and outbound unauthenticated,
+// plain-text connections into authenticated, encrypted connections.
+type Transport interface {
+	// SecureInbound secures an inbound connection.
+	SecureInbound(ctx context.Context, insecure net.Conn) (Conn, error)
+
+	// SecureOutbound secures an outbound connection.
+	SecureOutbound(ctx context.Context, insecure net.Conn, p peer.ID) (Conn, error)
+}
+
+// Conn is an authenticated, encrypted connection.
+type Conn interface {
+	net.Conn
+	inet.ConnSecurity
+}
diff --git a/vendor/github.com/libp2p/go-flow-metrics/meter.go b/vendor/github.com/libp2p/go-flow-metrics/meter.go
new file mode 100644
index 000000000..412dd3de6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-flow-metrics/meter.go
@@ -0,0 +1,44 @@
+package flow
+
+import (
+	"fmt"
+	"sync/atomic"
+)
+
+// Snapshot is a rate/total snapshot.
+type Snapshot struct {
+	Rate  float64
+	Total uint64
+}
+
+func (s Snapshot) String() string {
+	return fmt.Sprintf("%d (%f/s)", s.Total, s.Rate)
+}
+
+// Meter is a meter for monitoring a flow.
+type Meter struct {
+	accumulator uint64
+
+	// Take lock.
+	snapshot Snapshot
+}
+
+// Mark updates the total.
+func (m *Meter) Mark(count uint64) {
+	if count > 0 && atomic.AddUint64(&m.accumulator, count) == count {
+		// I'm the first one to bump this above 0.
+		// Register it.
+		globalSweeper.Register(m)
+	}
+}
+
+// Snapshot gets a consistent snapshot of the total and rate.
+func (m *Meter) Snapshot() Snapshot {
+	globalSweeper.mutex.RLock()
+	defer globalSweeper.mutex.RUnlock()
+	return m.snapshot
+}
+
+func (m *Meter) String() string {
+	return m.Snapshot().String()
+}
diff --git a/vendor/github.com/libp2p/go-flow-metrics/registry.go b/vendor/github.com/libp2p/go-flow-metrics/registry.go
new file mode 100644
index 000000000..226a4827a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-flow-metrics/registry.go
@@ -0,0 +1,35 @@
+package flow
+
+import (
+	"sync"
+)
+
+// MeterRegistry is a registry for named meters.
+type MeterRegistry struct {
+	meters sync.Map
+}
+
+// Get gets (or creates) a meter by name.
+func (r *MeterRegistry) Get(name string) *Meter {
+	if m, ok := r.meters.Load(name); ok {
+		return m.(*Meter)
+	}
+	m, _ := r.meters.LoadOrStore(name, new(Meter))
+	return m.(*Meter)
+}
+
+// Remove removes the named meter from the registry.
+//
+// Note: The only reason to do this is to save a bit of memory. Unused meters
+// don't consume any CPU (after they go idle).
+func (r *MeterRegistry) Remove(name string) {
+	r.meters.Delete(name)
+}
+
+// ForEach calls the passed function for each registered meter.
+func (r *MeterRegistry) ForEach(iterFunc func(string, *Meter)) {
+	r.meters.Range(func(k, v interface{}) bool {
+		iterFunc(k.(string), v.(*Meter))
+		return true
+	})
+}
diff --git a/vendor/github.com/libp2p/go-flow-metrics/sweeper.go b/vendor/github.com/libp2p/go-flow-metrics/sweeper.go
new file mode 100644
index 000000000..091e02947
--- /dev/null
+++ b/vendor/github.com/libp2p/go-flow-metrics/sweeper.go
@@ -0,0 +1,138 @@
+package flow
+
+import (
+	"math"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// IdleRate the rate at which we declare a meter idle (and stop tracking it
+// until it's re-registered).
+//
+// The default ensures that 1 event every ~30s will keep the meter from going
+// idle.
+var IdleRate = 1e-13
+
+// Alpha for EWMA of 1s
+var alpha = 1 - math.Exp(-1.0)
+
+// The global sweeper.
+var globalSweeper sweeper
+
+type sweeper struct {
+	sweepOnce       sync.Once
+	meters          []*Meter
+	mutex           sync.RWMutex
+	registerChannel chan *Meter
+}
+
+func (sw *sweeper) start() {
+	sw.registerChannel = make(chan *Meter, 16)
+	go sw.run()
+}
+
+func (sw *sweeper) run() {
+	for m := range sw.registerChannel {
+		sw.register(m)
+		sw.runActive()
+	}
+}
+
+func (sw *sweeper) register(m *Meter) {
+	// Add back the snapshot total. If we unregistered this
+	// one, we set it to zero.
+	atomic.AddUint64(&m.accumulator, m.snapshot.Total)
+	sw.meters = append(sw.meters, m)
+}
+
+func (sw *sweeper) runActive() {
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	for len(sw.meters) > 0 {
+		// Scale back allocation.
+		if len(sw.meters)*2 < cap(sw.meters) {
+			newMeters := make([]*Meter, len(sw.meters))
+			copy(newMeters, sw.meters)
+			sw.meters = newMeters
+		}
+
+		select {
+		case t := <-ticker.C:
+			sw.update(t)
+		case m := <-sw.registerChannel:
+			sw.register(m)
+		}
+	}
+	sw.meters = nil
+	// Till next time.
+}
+
+func (sw *sweeper) update(t time.Time) {
+	sw.mutex.Lock()
+	defer sw.mutex.Unlock()
+	for i := 0; i < len(sw.meters); i++ {
+		m := sw.meters[i]
+		total := atomic.LoadUint64(&m.accumulator)
+		diff := total - m.snapshot.Total
+
+		if m.snapshot.Rate == 0 {
+			m.snapshot.Rate = float64(diff)
+		} else {
+			m.snapshot.Rate += alpha * (float64(diff) - m.snapshot.Rate)
+		}
+		m.snapshot.Total = total
+
+		// This is equivalent to one zeros, then one, then 30 zeros.
+		// We'll consider that to be "idle".
+		if m.snapshot.Rate > IdleRate {
+			continue
+		}
+
+		// Ok, so we are idle...
+
+		// Mark this as idle by zeroing the accumulator.
+		swappedTotal := atomic.SwapUint64(&m.accumulator, 0)
+
+		// So..., are we really idle?
+		if swappedTotal > total {
+			// Not so idle...
+			// Now we need to make sure this gets re-registered.
+
+			// First, add back what we removed. If we can do this
+			// fast enough, we can put it back before anyone
+			// notices.
+			currentTotal := atomic.AddUint64(&m.accumulator, swappedTotal)
+
+			// Did we make it?
+			if currentTotal == swappedTotal {
+				// Yes! Nobody noticed, move along.
+				continue
+			}
+			// No. Someone noticed and will (or has) put back into
+			// the registration channel.
+			//
+			// Remove the snapshot total, it'll get added back on
+			// registration.
+			//
+			// `^uint64(total - 1)` is the two's compliment of
+			// `total`. It's the "correct" way to subtract
+			// atomically in go.
+			atomic.AddUint64(&m.accumulator, ^uint64(m.snapshot.Total-1))
+		}
+
+		// Reset the rate, keep the total.
+		m.snapshot.Rate = 0
+
+		// remove it and repeat `i`
+		sw.meters[i] = sw.meters[len(sw.meters)-1]
+		sw.meters[len(sw.meters)-1] = nil
+		sw.meters = sw.meters[:len(sw.meters)-1]
+		i--
+	}
+}
+
+func (sw *sweeper) Register(m *Meter) {
+	sw.sweepOnce.Do(sw.start)
+	sw.registerChannel <- m
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/LICENSE b/vendor/github.com/libp2p/go-libp2p-circuit/LICENSE
new file mode 100644
index 000000000..2f06d0eba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/conn.go b/vendor/github.com/libp2p/go-libp2p-circuit/conn.go
new file mode 100644
index 000000000..b0afbd063
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/conn.go
@@ -0,0 +1,57 @@
+package relay
+
+import (
+	"fmt"
+	"net"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+type Conn struct {
+	inet.Stream
+	remote pstore.PeerInfo
+}
+
+type NetAddr struct {
+	Relay  string
+	Remote string
+}
+
+func (n *NetAddr) Network() string {
+	return "libp2p-circuit-relay"
+}
+
+func (n *NetAddr) String() string {
+	return fmt.Sprintf("relay[%s-%s]", n.Remote, n.Relay)
+}
+
+func (c *Conn) RemoteAddr() net.Addr {
+	return &NetAddr{
+		Relay:  c.Conn().RemotePeer().Pretty(),
+		Remote: c.remote.ID.Pretty(),
+	}
+}
+
+func (c *Conn) RemoteMultiaddr() ma.Multiaddr {
+	a, err := ma.NewMultiaddr(fmt.Sprintf("/ipfs/%s/p2p-circuit/ipfs/%s", c.Conn().RemotePeer().Pretty(), c.remote.ID.Pretty()))
+	if err != nil {
+		panic(err)
+	}
+	return a
+}
+
+func (c *Conn) LocalMultiaddr() ma.Multiaddr {
+	return c.Conn().LocalMultiaddr()
+}
+
+func (c *Conn) LocalAddr() net.Addr {
+	na, err := manet.ToNetAddr(c.Conn().LocalMultiaddr())
+	if err != nil {
+		log.Error("failed to convert local multiaddr to net addr:", err)
+		return nil
+	}
+	return na
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/dial.go b/vendor/github.com/libp2p/go-libp2p-circuit/dial.go
new file mode 100644
index 000000000..3f021fa43
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/dial.go
@@ -0,0 +1,89 @@
+package relay
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	tpt "github.com/libp2p/go-libp2p-transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+func (d *RelayTransport) Dial(ctx context.Context, a ma.Multiaddr, p peer.ID) (tpt.Conn, error) {
+	c, err := d.Relay().Dial(ctx, a)
+	if err != nil {
+		return nil, err
+	}
+	return d.upgrader.UpgradeOutbound(ctx, d, c, p)
+}
+
+func (r *Relay) Dial(ctx context.Context, a ma.Multiaddr) (*Conn, error) {
+	if !r.Matches(a) {
+		return nil, fmt.Errorf("%s is not a relay address", a)
+	}
+	parts := ma.Split(a)
+
+	spl, _ := ma.NewMultiaddr("/p2p-circuit")
+
+	var relayaddr, destaddr ma.Multiaddr
+	for i, p := range parts {
+		if p.Equal(spl) {
+			relayaddr = ma.Join(parts[:i]...)
+			destaddr = ma.Join(parts[i+1:]...)
+			break
+		}
+	}
+
+	dinfo, err := pstore.InfoFromP2pAddr(destaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(relayaddr.Bytes()) == 0 {
+		// unspecific relay address, try dialing using known hop relays
+		return r.tryDialRelays(ctx, *dinfo)
+	}
+
+	var rinfo *pstore.PeerInfo
+	rinfo, err = pstore.InfoFromP2pAddr(relayaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.DialPeer(ctx, *rinfo, *dinfo)
+}
+
+func (r *Relay) tryDialRelays(ctx context.Context, dinfo pstore.PeerInfo) (*Conn, error) {
+	var relays []peer.ID
+	r.mx.Lock()
+	for p := range r.relays {
+		relays = append(relays, p)
+	}
+	r.mx.Unlock()
+
+	// shuffle list of relays, avoid overloading a specific relay
+	for i := range relays {
+		j := rand.Intn(i + 1)
+		relays[i], relays[j] = relays[j], relays[i]
+	}
+
+	for _, relay := range relays {
+		if len(r.host.Network().ConnsToPeer(relay)) == 0 {
+			continue
+		}
+
+		rctx, cancel := context.WithTimeout(ctx, HopConnectTimeout)
+		c, err := r.DialPeer(rctx, pstore.PeerInfo{ID: relay}, dinfo)
+		cancel()
+
+		if err == nil {
+			return c, nil
+		}
+
+		log.Debugf("error opening relay connection through %s: %s", dinfo.ID, err.Error())
+	}
+
+	return nil, fmt.Errorf("Failed to dial through %d known relay hosts", len(relays))
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/listen.go b/vendor/github.com/libp2p/go-libp2p-circuit/listen.go
new file mode 100644
index 000000000..ee1f92e15
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/listen.go
@@ -0,0 +1,63 @@
+package relay
+
+import (
+	"fmt"
+	"net"
+
+	pb "github.com/libp2p/go-libp2p-circuit/pb"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+var _ manet.Listener = (*RelayListener)(nil)
+
+type RelayListener Relay
+
+func (l *RelayListener) Relay() *Relay {
+	return (*Relay)(l)
+}
+
+func (r *Relay) Listener() *RelayListener {
+	// TODO: Only allow one!
+	return (*RelayListener)(r)
+}
+
+func (l *RelayListener) Accept() (manet.Conn, error) {
+	select {
+	case c := <-l.incoming:
+		err := l.Relay().writeResponse(c.Stream, pb.CircuitRelay_SUCCESS)
+		if err != nil {
+			log.Debugf("error writing relay response: %s", err.Error())
+			c.Stream.Reset()
+			return nil, err
+		}
+
+		// TODO: Pretty print.
+		log.Infof("accepted relay connection: %s", c)
+
+		return c, nil
+	case <-l.ctx.Done():
+		return nil, l.ctx.Err()
+	}
+}
+
+func (l *RelayListener) Addr() net.Addr {
+	return &NetAddr{
+		Relay:  "any",
+		Remote: "any",
+	}
+}
+
+func (l *RelayListener) Multiaddr() ma.Multiaddr {
+	a, err := ma.NewMultiaddr(fmt.Sprintf("/p2p-circuit/ipfs/%s", l.self.Pretty()))
+	if err != nil {
+		panic(err)
+	}
+	return a
+}
+
+func (l *RelayListener) Close() error {
+	// TODO: noop?
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/notify.go b/vendor/github.com/libp2p/go-libp2p-circuit/notify.go
new file mode 100644
index 000000000..7ded2b623
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/notify.go
@@ -0,0 +1,55 @@
+package relay
+
+import (
+	"context"
+	"time"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var _ inet.Notifiee = (*RelayNotifiee)(nil)
+
+type RelayNotifiee Relay
+
+func (r *Relay) Notifiee() inet.Notifiee {
+	return (*RelayNotifiee)(r)
+}
+
+func (n *RelayNotifiee) Relay() *Relay {
+	return (*Relay)(n)
+}
+
+func (n *RelayNotifiee) Listen(net inet.Network, a ma.Multiaddr)      {}
+func (n *RelayNotifiee) ListenClose(net inet.Network, a ma.Multiaddr) {}
+func (n *RelayNotifiee) OpenedStream(net inet.Network, s inet.Stream) {}
+func (n *RelayNotifiee) ClosedStream(net inet.Network, s inet.Stream) {}
+
+func (n *RelayNotifiee) Connected(s inet.Network, c inet.Conn) {
+	if n.Relay().Matches(c.RemoteMultiaddr()) {
+		return
+	}
+
+	go func(id peer.ID) {
+		ctx, cancel := context.WithTimeout(n.ctx, time.Second)
+		defer cancel()
+
+		canhop, err := n.Relay().CanHop(ctx, id)
+
+		if err != nil {
+			log.Debugf("Error testing relay hop: %s", err.Error())
+			return
+		}
+
+		if canhop {
+			log.Debugf("Discovered hop relay %s", id.Pretty())
+			n.mx.Lock()
+			n.relays[id] = struct{}{}
+			n.mx.Unlock()
+			n.host.ConnManager().TagPeer(id, "relay-hop", 2)
+		}
+	}(c.RemotePeer())
+}
+
+func (n *RelayNotifiee) Disconnected(s inet.Network, c inet.Conn) {}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/pb/relay.pb.go b/vendor/github.com/libp2p/go-libp2p-circuit/pb/relay.pb.go
new file mode 100644
index 000000000..9c3fc2b46
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/pb/relay.pb.go
@@ -0,0 +1,208 @@
+// Code generated by protoc-gen-gogo.
+// source: relay.proto
+// DO NOT EDIT!
+
+/*
+Package relay_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	relay.proto
+
+It has these top-level messages:
+	CircuitRelay
+*/
+package relay_pb
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type CircuitRelay_Status int32
+
+const (
+	CircuitRelay_SUCCESS                    CircuitRelay_Status = 100
+	CircuitRelay_HOP_SRC_ADDR_TOO_LONG      CircuitRelay_Status = 220
+	CircuitRelay_HOP_DST_ADDR_TOO_LONG      CircuitRelay_Status = 221
+	CircuitRelay_HOP_SRC_MULTIADDR_INVALID  CircuitRelay_Status = 250
+	CircuitRelay_HOP_DST_MULTIADDR_INVALID  CircuitRelay_Status = 251
+	CircuitRelay_HOP_NO_CONN_TO_DST         CircuitRelay_Status = 260
+	CircuitRelay_HOP_CANT_DIAL_DST          CircuitRelay_Status = 261
+	CircuitRelay_HOP_CANT_OPEN_DST_STREAM   CircuitRelay_Status = 262
+	CircuitRelay_HOP_CANT_SPEAK_RELAY       CircuitRelay_Status = 270
+	CircuitRelay_HOP_CANT_RELAY_TO_SELF     CircuitRelay_Status = 280
+	CircuitRelay_STOP_SRC_ADDR_TOO_LONG     CircuitRelay_Status = 320
+	CircuitRelay_STOP_DST_ADDR_TOO_LONG     CircuitRelay_Status = 321
+	CircuitRelay_STOP_SRC_MULTIADDR_INVALID CircuitRelay_Status = 350
+	CircuitRelay_STOP_DST_MULTIADDR_INVALID CircuitRelay_Status = 351
+	CircuitRelay_STOP_RELAY_REFUSED         CircuitRelay_Status = 390
+	CircuitRelay_MALFORMED_MESSAGE          CircuitRelay_Status = 400
+)
+
+var CircuitRelay_Status_name = map[int32]string{
+	100: "SUCCESS",
+	220: "HOP_SRC_ADDR_TOO_LONG",
+	221: "HOP_DST_ADDR_TOO_LONG",
+	250: "HOP_SRC_MULTIADDR_INVALID",
+	251: "HOP_DST_MULTIADDR_INVALID",
+	260: "HOP_NO_CONN_TO_DST",
+	261: "HOP_CANT_DIAL_DST",
+	262: "HOP_CANT_OPEN_DST_STREAM",
+	270: "HOP_CANT_SPEAK_RELAY",
+	280: "HOP_CANT_RELAY_TO_SELF",
+	320: "STOP_SRC_ADDR_TOO_LONG",
+	321: "STOP_DST_ADDR_TOO_LONG",
+	350: "STOP_SRC_MULTIADDR_INVALID",
+	351: "STOP_DST_MULTIADDR_INVALID",
+	390: "STOP_RELAY_REFUSED",
+	400: "MALFORMED_MESSAGE",
+}
+var CircuitRelay_Status_value = map[string]int32{
+	"SUCCESS":                    100,
+	"HOP_SRC_ADDR_TOO_LONG":      220,
+	"HOP_DST_ADDR_TOO_LONG":      221,
+	"HOP_SRC_MULTIADDR_INVALID":  250,
+	"HOP_DST_MULTIADDR_INVALID":  251,
+	"HOP_NO_CONN_TO_DST":         260,
+	"HOP_CANT_DIAL_DST":          261,
+	"HOP_CANT_OPEN_DST_STREAM":   262,
+	"HOP_CANT_SPEAK_RELAY":       270,
+	"HOP_CANT_RELAY_TO_SELF":     280,
+	"STOP_SRC_ADDR_TOO_LONG":     320,
+	"STOP_DST_ADDR_TOO_LONG":     321,
+	"STOP_SRC_MULTIADDR_INVALID": 350,
+	"STOP_DST_MULTIADDR_INVALID": 351,
+	"STOP_RELAY_REFUSED":         390,
+	"MALFORMED_MESSAGE":          400,
+}
+
+func (x CircuitRelay_Status) Enum() *CircuitRelay_Status {
+	p := new(CircuitRelay_Status)
+	*p = x
+	return p
+}
+func (x CircuitRelay_Status) String() string {
+	return proto.EnumName(CircuitRelay_Status_name, int32(x))
+}
+func (x *CircuitRelay_Status) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(CircuitRelay_Status_value, data, "CircuitRelay_Status")
+	if err != nil {
+		return err
+	}
+	*x = CircuitRelay_Status(value)
+	return nil
+}
+
+type CircuitRelay_Type int32
+
+const (
+	CircuitRelay_HOP     CircuitRelay_Type = 1
+	CircuitRelay_STOP    CircuitRelay_Type = 2
+	CircuitRelay_STATUS  CircuitRelay_Type = 3
+	CircuitRelay_CAN_HOP CircuitRelay_Type = 4
+)
+
+var CircuitRelay_Type_name = map[int32]string{
+	1: "HOP",
+	2: "STOP",
+	3: "STATUS",
+	4: "CAN_HOP",
+}
+var CircuitRelay_Type_value = map[string]int32{
+	"HOP":     1,
+	"STOP":    2,
+	"STATUS":  3,
+	"CAN_HOP": 4,
+}
+
+func (x CircuitRelay_Type) Enum() *CircuitRelay_Type {
+	p := new(CircuitRelay_Type)
+	*p = x
+	return p
+}
+func (x CircuitRelay_Type) String() string {
+	return proto.EnumName(CircuitRelay_Type_name, int32(x))
+}
+func (x *CircuitRelay_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(CircuitRelay_Type_value, data, "CircuitRelay_Type")
+	if err != nil {
+		return err
+	}
+	*x = CircuitRelay_Type(value)
+	return nil
+}
+
+type CircuitRelay struct {
+	Type             *CircuitRelay_Type   `protobuf:"varint,1,opt,name=type,enum=relay.pb.CircuitRelay_Type" json:"type,omitempty"`
+	SrcPeer          *CircuitRelay_Peer   `protobuf:"bytes,2,opt,name=srcPeer" json:"srcPeer,omitempty"`
+	DstPeer          *CircuitRelay_Peer   `protobuf:"bytes,3,opt,name=dstPeer" json:"dstPeer,omitempty"`
+	Code             *CircuitRelay_Status `protobuf:"varint,4,opt,name=code,enum=relay.pb.CircuitRelay_Status" json:"code,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *CircuitRelay) Reset()         { *m = CircuitRelay{} }
+func (m *CircuitRelay) String() string { return proto.CompactTextString(m) }
+func (*CircuitRelay) ProtoMessage()    {}
+
+func (m *CircuitRelay) GetType() CircuitRelay_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return CircuitRelay_HOP
+}
+
+func (m *CircuitRelay) GetSrcPeer() *CircuitRelay_Peer {
+	if m != nil {
+		return m.SrcPeer
+	}
+	return nil
+}
+
+func (m *CircuitRelay) GetDstPeer() *CircuitRelay_Peer {
+	if m != nil {
+		return m.DstPeer
+	}
+	return nil
+}
+
+func (m *CircuitRelay) GetCode() CircuitRelay_Status {
+	if m != nil && m.Code != nil {
+		return *m.Code
+	}
+	return CircuitRelay_SUCCESS
+}
+
+type CircuitRelay_Peer struct {
+	Id               []byte   `protobuf:"bytes,1,req,name=id" json:"id,omitempty"`
+	Addrs            [][]byte `protobuf:"bytes,2,rep,name=addrs" json:"addrs,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *CircuitRelay_Peer) Reset()         { *m = CircuitRelay_Peer{} }
+func (m *CircuitRelay_Peer) String() string { return proto.CompactTextString(m) }
+func (*CircuitRelay_Peer) ProtoMessage()    {}
+
+func (m *CircuitRelay_Peer) GetId() []byte {
+	if m != nil {
+		return m.Id
+	}
+	return nil
+}
+
+func (m *CircuitRelay_Peer) GetAddrs() [][]byte {
+	if m != nil {
+		return m.Addrs
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CircuitRelay)(nil), "relay.pb.CircuitRelay")
+	proto.RegisterType((*CircuitRelay_Peer)(nil), "relay.pb.CircuitRelay.Peer")
+	proto.RegisterEnum("relay.pb.CircuitRelay_Status", CircuitRelay_Status_name, CircuitRelay_Status_value)
+	proto.RegisterEnum("relay.pb.CircuitRelay_Type", CircuitRelay_Type_name, CircuitRelay_Type_value)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/relay.go b/vendor/github.com/libp2p/go-libp2p-circuit/relay.go
new file mode 100644
index 000000000..99e89d45f
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/relay.go
@@ -0,0 +1,395 @@
+package relay
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	pb "github.com/libp2p/go-libp2p-circuit/pb"
+
+	logging "github.com/ipfs/go-log"
+	host "github.com/libp2p/go-libp2p-host"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var log = logging.Logger("relay")
+
+const ProtoID = "/libp2p/circuit/relay/0.1.0"
+
+const maxMessageSize = 4096
+
+var RelayAcceptTimeout = time.Minute
+var HopConnectTimeout = 10 * time.Second
+
+type Relay struct {
+	host     host.Host
+	upgrader *tptu.Upgrader
+	ctx      context.Context
+	self     peer.ID
+
+	active bool
+	hop    bool
+
+	incoming chan *Conn
+
+	relays map[peer.ID]struct{}
+	mx     sync.Mutex
+}
+
+type RelayOpt int
+
+var (
+	OptActive = RelayOpt(0)
+	OptHop    = RelayOpt(1)
+)
+
+type RelayError struct {
+	Code pb.CircuitRelay_Status
+}
+
+func (e RelayError) Error() string {
+	return fmt.Sprintf("error opening relay circuit: %s (%d)", pb.CircuitRelay_Status_name[int32(e.Code)], e.Code)
+}
+
+func NewRelay(ctx context.Context, h host.Host, upgrader *tptu.Upgrader, opts ...RelayOpt) (*Relay, error) {
+	r := &Relay{
+		upgrader: upgrader,
+		host:     h,
+		ctx:      ctx,
+		self:     h.ID(),
+		incoming: make(chan *Conn),
+		relays:   make(map[peer.ID]struct{}),
+	}
+
+	for _, opt := range opts {
+		switch opt {
+		case OptActive:
+			r.active = true
+		case OptHop:
+			r.hop = true
+		default:
+			return nil, fmt.Errorf("unrecognized option: %d", opt)
+		}
+	}
+
+	h.SetStreamHandler(ProtoID, r.handleNewStream)
+	h.Network().Notify(r.Notifiee())
+
+	return r, nil
+}
+
+func (r *Relay) DialPeer(ctx context.Context, relay pstore.PeerInfo, dest pstore.PeerInfo) (*Conn, error) {
+
+	log.Debugf("dialing peer %s through relay %s", dest.ID, relay.ID)
+
+	if len(relay.Addrs) > 0 {
+		r.host.Peerstore().AddAddrs(relay.ID, relay.Addrs, pstore.TempAddrTTL)
+	}
+
+	s, err := r.host.NewStream(ctx, relay.ID, ProtoID)
+	if err != nil {
+		return nil, err
+	}
+
+	rd := newDelimitedReader(s, maxMessageSize)
+	wr := newDelimitedWriter(s)
+
+	var msg pb.CircuitRelay
+
+	msg.Type = pb.CircuitRelay_HOP.Enum()
+	msg.SrcPeer = peerInfoToPeer(r.host.Peerstore().PeerInfo(r.self))
+	msg.DstPeer = peerInfoToPeer(dest)
+
+	err = wr.WriteMsg(&msg)
+	if err != nil {
+		s.Reset()
+		return nil, err
+	}
+
+	msg.Reset()
+
+	err = rd.ReadMsg(&msg)
+	if err != nil {
+		s.Reset()
+		return nil, err
+	}
+
+	if msg.GetType() != pb.CircuitRelay_STATUS {
+		s.Reset()
+		return nil, fmt.Errorf("unexpected relay response; not a status message (%d)", msg.GetType())
+	}
+
+	if msg.GetCode() != pb.CircuitRelay_SUCCESS {
+		s.Reset()
+		return nil, RelayError{msg.GetCode()}
+	}
+
+	return &Conn{Stream: s, remote: dest}, nil
+}
+
+func (r *Relay) Matches(addr ma.Multiaddr) bool {
+	// TODO: Look at the prefix transport as well.
+	_, err := addr.ValueForProtocol(P_CIRCUIT)
+	return err == nil
+}
+
+func (r *Relay) CanHop(ctx context.Context, id peer.ID) (bool, error) {
+	s, err := r.host.NewStream(ctx, id, ProtoID)
+	if err != nil {
+		return false, err
+	}
+
+	rd := newDelimitedReader(s, maxMessageSize)
+	wr := newDelimitedWriter(s)
+
+	var msg pb.CircuitRelay
+
+	msg.Type = pb.CircuitRelay_CAN_HOP.Enum()
+
+	if err := wr.WriteMsg(&msg); err != nil {
+		s.Reset()
+		return false, err
+	}
+
+	msg.Reset()
+
+	if err := rd.ReadMsg(&msg); err != nil {
+		s.Reset()
+		return false, err
+	}
+	if err := inet.FullClose(s); err != nil {
+		return false, err
+	}
+
+	if msg.GetType() != pb.CircuitRelay_STATUS {
+		return false, fmt.Errorf("unexpected relay response; not a status message (%d)", msg.GetType())
+	}
+
+	return msg.GetCode() == pb.CircuitRelay_SUCCESS, nil
+}
+
+func (r *Relay) handleNewStream(s inet.Stream) {
+	log.Infof("new relay stream from: %s", s.Conn().RemotePeer())
+
+	rd := newDelimitedReader(s, maxMessageSize)
+
+	var msg pb.CircuitRelay
+
+	err := rd.ReadMsg(&msg)
+	if err != nil {
+		r.handleError(s, pb.CircuitRelay_MALFORMED_MESSAGE)
+		return
+	}
+
+	switch msg.GetType() {
+	case pb.CircuitRelay_HOP:
+		r.handleHopStream(s, &msg)
+	case pb.CircuitRelay_STOP:
+		r.handleStopStream(s, &msg)
+	case pb.CircuitRelay_CAN_HOP:
+		r.handleCanHop(s, &msg)
+	default:
+		log.Warningf("unexpected relay handshake: %d", msg.GetType())
+		r.handleError(s, pb.CircuitRelay_MALFORMED_MESSAGE)
+	}
+}
+
+func (r *Relay) handleHopStream(s inet.Stream, msg *pb.CircuitRelay) {
+	if !r.hop {
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_SPEAK_RELAY)
+		return
+	}
+
+	src, err := peerToPeerInfo(msg.GetSrcPeer())
+	if err != nil {
+		r.handleError(s, pb.CircuitRelay_HOP_SRC_MULTIADDR_INVALID)
+		return
+	}
+
+	if src.ID != s.Conn().RemotePeer() {
+		r.handleError(s, pb.CircuitRelay_HOP_SRC_MULTIADDR_INVALID)
+		return
+	}
+
+	dst, err := peerToPeerInfo(msg.GetDstPeer())
+	if err != nil {
+		r.handleError(s, pb.CircuitRelay_HOP_DST_MULTIADDR_INVALID)
+		return
+	}
+
+	if dst.ID == r.self {
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_RELAY_TO_SELF)
+		return
+	}
+
+	// open stream
+	ctp := r.host.Network().ConnsToPeer(dst.ID)
+
+	if len(ctp) == 0 && !r.active {
+		r.handleError(s, pb.CircuitRelay_HOP_NO_CONN_TO_DST)
+		return
+	}
+
+	if len(dst.Addrs) > 0 {
+		r.host.Peerstore().AddAddrs(dst.ID, dst.Addrs, pstore.TempAddrTTL)
+	}
+
+	ctx, cancel := context.WithTimeout(r.ctx, HopConnectTimeout)
+	defer cancel()
+
+	bs, err := r.host.NewStream(ctx, dst.ID, ProtoID)
+	if err != nil {
+		log.Debugf("error opening relay stream to %s: %s", dst.ID.Pretty(), err.Error())
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_DIAL_DST)
+		return
+	}
+
+	// stop handshake
+	rd := newDelimitedReader(bs, maxMessageSize)
+	wr := newDelimitedWriter(bs)
+
+	msg.Type = pb.CircuitRelay_STOP.Enum()
+
+	err = wr.WriteMsg(msg)
+	if err != nil {
+		log.Debugf("error writing stop handshake: %s", err.Error())
+		bs.Reset()
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_OPEN_DST_STREAM)
+		return
+	}
+
+	msg.Reset()
+
+	err = rd.ReadMsg(msg)
+	if err != nil {
+		log.Debugf("error reading stop response: %s", err.Error())
+		bs.Reset()
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_OPEN_DST_STREAM)
+		return
+	}
+
+	if msg.GetType() != pb.CircuitRelay_STATUS {
+		log.Debugf("unexpected relay stop response: not a status message (%d)", msg.GetType())
+		bs.Reset()
+		r.handleError(s, pb.CircuitRelay_HOP_CANT_OPEN_DST_STREAM)
+		return
+	}
+
+	if msg.GetCode() != pb.CircuitRelay_SUCCESS {
+		log.Debugf("relay stop failure: %d", msg.GetCode())
+		bs.Reset()
+		r.handleError(s, msg.GetCode())
+		return
+	}
+
+	err = r.writeResponse(s, pb.CircuitRelay_SUCCESS)
+	if err != nil {
+		log.Debugf("error writing relay response: %s", err.Error())
+		bs.Reset()
+		s.Reset()
+		return
+	}
+
+	// relay connection
+	log.Infof("relaying connection between %s and %s", src.ID.Pretty(), dst.ID.Pretty())
+
+	// Don't reset streams after finishing or the other side will get an
+	// error, not an EOF.
+	go func() {
+		count, err := io.Copy(s, bs)
+		if err != nil {
+			log.Debugf("relay copy error: %s", err)
+			// Reset both.
+			s.Reset()
+			bs.Reset()
+		} else {
+			// propagate the close
+			s.Close()
+		}
+		log.Debugf("relayed %d bytes from %s to %s", count, dst.ID.Pretty(), src.ID.Pretty())
+	}()
+
+	go func() {
+		count, err := io.Copy(bs, s)
+		if err != nil {
+			log.Debugf("relay copy error: %s", err)
+			// Reset both.
+			bs.Reset()
+			s.Reset()
+		} else {
+			// propagate the close
+			bs.Close()
+		}
+		log.Debugf("relayed %d bytes from %s to %s", count, src.ID.Pretty(), dst.ID.Pretty())
+	}()
+}
+
+func (r *Relay) handleStopStream(s inet.Stream, msg *pb.CircuitRelay) {
+	src, err := peerToPeerInfo(msg.GetSrcPeer())
+	if err != nil {
+		r.handleError(s, pb.CircuitRelay_STOP_SRC_MULTIADDR_INVALID)
+		return
+	}
+
+	dst, err := peerToPeerInfo(msg.GetDstPeer())
+	if err != nil || dst.ID != r.self {
+		r.handleError(s, pb.CircuitRelay_STOP_DST_MULTIADDR_INVALID)
+		return
+	}
+
+	log.Infof("relay connection from: %s", src.ID)
+
+	if len(src.Addrs) > 0 {
+		r.host.Peerstore().AddAddrs(src.ID, src.Addrs, pstore.TempAddrTTL)
+	}
+
+	select {
+	case r.incoming <- &Conn{Stream: s, remote: src}:
+	case <-time.After(RelayAcceptTimeout):
+		r.handleError(s, pb.CircuitRelay_STOP_RELAY_REFUSED)
+	}
+}
+
+func (r *Relay) handleCanHop(s inet.Stream, msg *pb.CircuitRelay) {
+	var err error
+
+	if r.hop {
+		err = r.writeResponse(s, pb.CircuitRelay_SUCCESS)
+	} else {
+		err = r.writeResponse(s, pb.CircuitRelay_HOP_CANT_SPEAK_RELAY)
+	}
+
+	if err != nil {
+		s.Reset()
+		log.Debugf("error writing relay response: %s", err.Error())
+	} else {
+		inet.FullClose(s)
+	}
+}
+
+func (r *Relay) handleError(s inet.Stream, code pb.CircuitRelay_Status) {
+	log.Warningf("relay error: %s (%d)", pb.CircuitRelay_Status_name[int32(code)], code)
+	err := r.writeResponse(s, code)
+	if err != nil {
+		s.Reset()
+		log.Debugf("error writing relay response: %s", err.Error())
+	} else {
+		inet.FullClose(s)
+	}
+}
+
+func (r *Relay) writeResponse(s inet.Stream, code pb.CircuitRelay_Status) error {
+	wr := newDelimitedWriter(s)
+
+	var msg pb.CircuitRelay
+	msg.Type = pb.CircuitRelay_STATUS.Enum()
+	msg.Code = code.Enum()
+
+	return wr.WriteMsg(&msg)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/transport.go b/vendor/github.com/libp2p/go-libp2p-circuit/transport.go
new file mode 100644
index 000000000..86821d327
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/transport.go
@@ -0,0 +1,80 @@
+package relay
+
+import (
+	"context"
+	"fmt"
+
+	host "github.com/libp2p/go-libp2p-host"
+	tpt "github.com/libp2p/go-libp2p-transport"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+const P_CIRCUIT = 290
+
+var Protocol = ma.Protocol{
+	Code:  P_CIRCUIT,
+	Size:  0,
+	Name:  "p2p-circuit",
+	VCode: ma.CodeToVarint(P_CIRCUIT),
+}
+
+func init() {
+	ma.AddProtocol(Protocol)
+}
+
+var _ tpt.Transport = (*RelayTransport)(nil)
+
+type RelayTransport Relay
+
+func (t *RelayTransport) Relay() *Relay {
+	return (*Relay)(t)
+}
+
+func (r *Relay) Transport() *RelayTransport {
+	return (*RelayTransport)(r)
+}
+
+func (t *RelayTransport) Listen(laddr ma.Multiaddr) (tpt.Listener, error) {
+	// TODO: Ensure we have a connection to the relay, if specified. Also,
+	// make sure the multiaddr makes sense.
+	if !t.Relay().Matches(laddr) {
+		return nil, fmt.Errorf("%s is not a relay address", laddr)
+	}
+	return t.upgrader.UpgradeListener(t, t.Relay().Listener()), nil
+}
+
+func (t *RelayTransport) CanDial(raddr ma.Multiaddr) bool {
+	return t.Relay().Matches(raddr)
+}
+
+func (t *RelayTransport) Proxy() bool {
+	return true
+}
+
+func (t *RelayTransport) Protocols() []int {
+	return []int{P_CIRCUIT}
+}
+
+// AddRelayTransport constructs a relay and adds it as a transport to the host network.
+func AddRelayTransport(ctx context.Context, h host.Host, upgrader *tptu.Upgrader, opts ...RelayOpt) error {
+	n, ok := h.Network().(tpt.Network)
+	if !ok {
+		return fmt.Errorf("%v is not a transport network", h.Network())
+	}
+
+	r, err := NewRelay(ctx, h, upgrader, opts...)
+	if err != nil {
+		return err
+	}
+
+	// There's no nice way to handle these errors as we have no way to tear
+	// down the relay.
+	// TODO
+	if err := n.AddTransport(r.Transport()); err != nil {
+		log.Error("failed to add relay transport:", err)
+	} else if err := n.Listen(r.Listener().Multiaddr()); err != nil {
+		log.Error("failed to listen on relay transport:", err)
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-circuit/util.go b/vendor/github.com/libp2p/go-libp2p-circuit/util.go
new file mode 100644
index 000000000..71f4684ea
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-circuit/util.go
@@ -0,0 +1,98 @@
+package relay
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+
+	pb "github.com/libp2p/go-libp2p-circuit/pb"
+
+	ggio "github.com/gogo/protobuf/io"
+	proto "github.com/gogo/protobuf/proto"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	ma "github.com/multiformats/go-multiaddr"
+	mh "github.com/multiformats/go-multihash"
+)
+
+func peerToPeerInfo(p *pb.CircuitRelay_Peer) (pstore.PeerInfo, error) {
+	if p == nil {
+		return pstore.PeerInfo{}, errors.New("nil peer")
+	}
+
+	h, err := mh.Cast(p.Id)
+	if err != nil {
+		return pstore.PeerInfo{}, err
+	}
+
+	addrs := make([]ma.Multiaddr, 0, len(p.Addrs))
+	for _, addrBytes := range p.Addrs {
+		a, err := ma.NewMultiaddrBytes(addrBytes)
+		if err == nil {
+			addrs = append(addrs, a)
+		}
+	}
+
+	return pstore.PeerInfo{ID: peer.ID(h), Addrs: addrs}, nil
+}
+
+func peerInfoToPeer(pi pstore.PeerInfo) *pb.CircuitRelay_Peer {
+	addrs := make([][]byte, len(pi.Addrs))
+	for i, addr := range pi.Addrs {
+		addrs[i] = addr.Bytes()
+	}
+
+	p := new(pb.CircuitRelay_Peer)
+	p.Id = []byte(pi.ID)
+	p.Addrs = addrs
+
+	return p
+}
+
+type delimitedReader struct {
+	r   io.Reader
+	buf []byte
+}
+
+// The gogo protobuf NewDelimitedReader is buffered, which may eat up stream data.
+// So we need to implement a compatible delimited reader that reads unbuffered.
+// There is a slowdown from unbuffered reading: when reading the message
+// it can take multiple single byte Reads to read the length and another Read
+// to read the message payload.
+// However, this is not critical performance degradation as
+// - the reader is utilized to read one (dialer, stop) or two messages (hop) during
+//   the handshake, so it's a drop in the water for the connection lifetime.
+// - messages are small (max 4k) and the length fits in a couple of bytes,
+//   so overall we have at most three reads per message.
+func newDelimitedReader(r io.Reader, maxSize int) *delimitedReader {
+	return &delimitedReader{r: r, buf: make([]byte, maxSize)}
+}
+
+func (d *delimitedReader) ReadByte() (byte, error) {
+	buf := d.buf[:1]
+	_, err := d.r.Read(buf)
+	return buf[0], err
+}
+
+func (d *delimitedReader) ReadMsg(msg proto.Message) error {
+	mlen, err := binary.ReadUvarint(d)
+	if err != nil {
+		return err
+	}
+
+	if uint64(len(d.buf)) < mlen {
+		return errors.New("Message too large")
+	}
+
+	buf := d.buf[:mlen]
+	_, err = io.ReadFull(d.r, buf)
+	if err != nil {
+		return err
+	}
+
+	return proto.Unmarshal(buf, msg)
+}
+
+func newDelimitedWriter(w io.Writer) ggio.WriteCloser {
+	return ggio.NewDelimitedWriter(w)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE b/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go
new file mode 100644
index 000000000..385e0b978
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/ed25519.go
@@ -0,0 +1,133 @@
+package crypto
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/agl/ed25519"
+	extra "github.com/agl/ed25519/extra25519"
+	proto "github.com/gogo/protobuf/proto"
+	pb "github.com/libp2p/go-libp2p-crypto/pb"
+)
+
+type Ed25519PrivateKey struct {
+	sk *[64]byte
+	pk *[32]byte
+}
+
+type Ed25519PublicKey struct {
+	k *[32]byte
+}
+
+func GenerateEd25519Key(src io.Reader) (PrivKey, PubKey, error) {
+	pub, priv, err := ed25519.GenerateKey(src)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &Ed25519PrivateKey{
+			sk: priv,
+			pk: pub,
+		},
+		&Ed25519PublicKey{
+			k: pub,
+		},
+		nil
+}
+
+func (k *Ed25519PrivateKey) Bytes() ([]byte, error) {
+	pbmes := new(pb.PrivateKey)
+	typ := pb.KeyType_Ed25519
+	pbmes.Type = &typ
+
+	buf := make([]byte, 96)
+	copy(buf, k.sk[:])
+	copy(buf[64:], k.pk[:])
+	pbmes.Data = buf
+	return proto.Marshal(pbmes)
+}
+
+func (k *Ed25519PrivateKey) Equals(o Key) bool {
+	edk, ok := o.(*Ed25519PrivateKey)
+	if !ok {
+		return false
+	}
+
+	return bytes.Equal((*k.sk)[:], (*edk.sk)[:]) && bytes.Equal((*k.pk)[:], (*edk.pk)[:])
+}
+
+func (k *Ed25519PrivateKey) GetPublic() PubKey {
+	return &Ed25519PublicKey{k.pk}
+}
+
+func (k *Ed25519PrivateKey) Sign(msg []byte) ([]byte, error) {
+	out := ed25519.Sign(k.sk, msg)
+	return (*out)[:], nil
+}
+
+func (k *Ed25519PrivateKey) ToCurve25519() *[32]byte {
+	var sk [32]byte
+	extra.PrivateKeyToCurve25519(&sk, k.sk)
+	return &sk
+}
+
+func (k *Ed25519PublicKey) Bytes() ([]byte, error) {
+	pbmes := new(pb.PublicKey)
+	typ := pb.KeyType_Ed25519
+	pbmes.Type = &typ
+	pbmes.Data = (*k.k)[:]
+	return proto.Marshal(pbmes)
+}
+
+func (k *Ed25519PublicKey) Equals(o Key) bool {
+	edk, ok := o.(*Ed25519PublicKey)
+	if !ok {
+		return false
+	}
+
+	return bytes.Equal((*k.k)[:], (*edk.k)[:])
+}
+
+func (k *Ed25519PublicKey) Verify(data []byte, sig []byte) (bool, error) {
+	var asig [64]byte
+	copy(asig[:], sig)
+	return ed25519.Verify(k.k, data, &asig), nil
+}
+
+func (k *Ed25519PublicKey) ToCurve25519() (*[32]byte, error) {
+	var pk [32]byte
+	success := extra.PublicKeyToCurve25519(&pk, k.k)
+	if !success {
+		return nil, fmt.Errorf("Error converting ed25519 pubkey to curve25519 pubkey")
+	}
+	return &pk, nil
+}
+
+func UnmarshalEd25519PublicKey(data []byte) (PubKey, error) {
+	if len(data) != 32 {
+		return nil, fmt.Errorf("expect ed25519 public key data size to be 32")
+	}
+
+	var pub [32]byte
+	copy(pub[:], data)
+
+	return &Ed25519PublicKey{
+		k: &pub,
+	}, nil
+}
+
+func UnmarshalEd25519PrivateKey(data []byte) (PrivKey, error) {
+	if len(data) != 96 {
+		return nil, fmt.Errorf("expected ed25519 data size to be 96")
+	}
+	var priv [64]byte
+	var pub [32]byte
+	copy(priv[:], data)
+	copy(pub[:], data[64:])
+
+	return &Ed25519PrivateKey{
+		sk: &priv,
+		pk: &pub,
+	}, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/key.go b/vendor/github.com/libp2p/go-libp2p-crypto/key.go
new file mode 100644
index 000000000..1a9d0ec95
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/key.go
@@ -0,0 +1,318 @@
+// Package crypto implements various cryptographic utilities used by ipfs.
+// This includes a Public and Private key interface and an RSA key implementation
+// that satisfies it.
+package crypto
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+
+	"crypto/elliptic"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/sha512"
+	"hash"
+
+	pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+	"github.com/gogo/protobuf/proto"
+	sha256 "github.com/minio/sha256-simd"
+)
+
+var ErrBadKeyType = errors.New("invalid or unsupported key type")
+
+const (
+	RSA = iota
+	Ed25519
+	Secp256k1
+)
+
+var KeyTypes = []int{
+	RSA,
+	Ed25519,
+	Secp256k1,
+}
+
+// PubKeyUnmarshaller is a func that creates a PubKey from a given slice of bytes
+type PubKeyUnmarshaller func(data []byte) (PubKey, error)
+
+// PrivKeyUnmarshaller is a func that creates a PrivKey from a given slice of bytes
+type PrivKeyUnmarshaller func(data []byte) (PrivKey, error)
+
+var PubKeyUnmarshallers = map[pb.KeyType]PubKeyUnmarshaller{
+	pb.KeyType_RSA:       UnmarshalRsaPublicKey,
+	pb.KeyType_Ed25519:   UnmarshalEd25519PublicKey,
+	pb.KeyType_Secp256k1: UnmarshalSecp256k1PublicKey,
+}
+
+var PrivKeyUnmarshallers = map[pb.KeyType]PrivKeyUnmarshaller{
+	pb.KeyType_RSA:       UnmarshalRsaPrivateKey,
+	pb.KeyType_Ed25519:   UnmarshalEd25519PrivateKey,
+	pb.KeyType_Secp256k1: UnmarshalSecp256k1PrivateKey,
+}
+
+// Key represents a crypto key that can be compared to another key
+type Key interface {
+	// Bytes returns a serialized, storeable representation of this key
+	Bytes() ([]byte, error)
+
+	// Equals checks whether two PubKeys are the same
+	Equals(Key) bool
+}
+
+// PrivKey represents a private key that can be used to generate a public key,
+// sign data, and decrypt data that was encrypted with a public key
+type PrivKey interface {
+	Key
+
+	// Cryptographically sign the given bytes
+	Sign([]byte) ([]byte, error)
+
+	// Return a public key paired with this private key
+	GetPublic() PubKey
+}
+
+type PubKey interface {
+	Key
+
+	// Verify that 'sig' is the signed hash of 'data'
+	Verify(data []byte, sig []byte) (bool, error)
+}
+
+// Given a public key, generates the shared key.
+type GenSharedKey func([]byte) ([]byte, error)
+
+func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error) {
+	return GenerateKeyPairWithReader(typ, bits, rand.Reader)
+}
+
+// Generates a keypair of the given type and bitsize
+func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error) {
+	switch typ {
+	case RSA:
+		priv, err := rsa.GenerateKey(src, bits)
+		if err != nil {
+			return nil, nil, err
+		}
+		pk := &priv.PublicKey
+		return &RsaPrivateKey{sk: priv}, &RsaPublicKey{pk}, nil
+	case Ed25519:
+		return GenerateEd25519Key(src)
+	case Secp256k1:
+		return GenerateSecp256k1Key(src)
+	default:
+		return nil, nil, ErrBadKeyType
+	}
+}
+
+// Generates an ephemeral public key and returns a function that will compute
+// the shared secret key.  Used in the identify module.
+//
+// Focuses only on ECDH now, but can be made more general in the future.
+func GenerateEKeyPair(curveName string) ([]byte, GenSharedKey, error) {
+	var curve elliptic.Curve
+
+	switch curveName {
+	case "P-256":
+		curve = elliptic.P256()
+	case "P-384":
+		curve = elliptic.P384()
+	case "P-521":
+		curve = elliptic.P521()
+	}
+
+	priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	pubKey := elliptic.Marshal(curve, x, y)
+
+	done := func(theirPub []byte) ([]byte, error) {
+		// Verify and unpack node's public key.
+		x, y := elliptic.Unmarshal(curve, theirPub)
+		if x == nil {
+			return nil, fmt.Errorf("Malformed public key: %d %v", len(theirPub), theirPub)
+		}
+
+		if !curve.IsOnCurve(x, y) {
+			return nil, errors.New("Invalid public key.")
+		}
+
+		// Generate shared secret.
+		secret, _ := curve.ScalarMult(x, y, priv)
+
+		return secret.Bytes(), nil
+	}
+
+	return pubKey, done, nil
+}
+
+type StretchedKeys struct {
+	IV        []byte
+	MacKey    []byte
+	CipherKey []byte
+}
+
+// Generates a set of keys for each party by stretching the shared key.
+// (myIV, theirIV, myCipherKey, theirCipherKey, myMACKey, theirMACKey)
+func KeyStretcher(cipherType string, hashType string, secret []byte) (StretchedKeys, StretchedKeys) {
+	var cipherKeySize int
+	var ivSize int
+	switch cipherType {
+	case "AES-128":
+		ivSize = 16
+		cipherKeySize = 16
+	case "AES-256":
+		ivSize = 16
+		cipherKeySize = 32
+	case "Blowfish":
+		ivSize = 8
+		// Note: 24 arbitrarily selected, needs more thought
+		cipherKeySize = 32
+	}
+
+	hmacKeySize := 20
+
+	seed := []byte("key expansion")
+
+	result := make([]byte, 2*(ivSize+cipherKeySize+hmacKeySize))
+
+	var h func() hash.Hash
+
+	switch hashType {
+	case "SHA1":
+		h = sha1.New
+	case "SHA256":
+		h = sha256.New
+	case "SHA512":
+		h = sha512.New
+	default:
+		panic("Unrecognized hash function, programmer error?")
+	}
+
+	m := hmac.New(h, secret)
+	m.Write(seed)
+
+	a := m.Sum(nil)
+
+	j := 0
+	for j < len(result) {
+		m.Reset()
+		m.Write(a)
+		m.Write(seed)
+		b := m.Sum(nil)
+
+		todo := len(b)
+
+		if j+todo > len(result) {
+			todo = len(result) - j
+		}
+
+		copy(result[j:j+todo], b)
+
+		j += todo
+
+		m.Reset()
+		m.Write(a)
+		a = m.Sum(nil)
+	}
+
+	half := len(result) / 2
+	r1 := result[:half]
+	r2 := result[half:]
+
+	var k1 StretchedKeys
+	var k2 StretchedKeys
+
+	k1.IV = r1[0:ivSize]
+	k1.CipherKey = r1[ivSize : ivSize+cipherKeySize]
+	k1.MacKey = r1[ivSize+cipherKeySize:]
+
+	k2.IV = r2[0:ivSize]
+	k2.CipherKey = r2[ivSize : ivSize+cipherKeySize]
+	k2.MacKey = r2[ivSize+cipherKeySize:]
+
+	return k1, k2
+}
+
+// UnmarshalPublicKey converts a protobuf serialized public key into its
+// representative object
+func UnmarshalPublicKey(data []byte) (PubKey, error) {
+	pmes := new(pb.PublicKey)
+	err := proto.Unmarshal(data, pmes)
+	if err != nil {
+		return nil, err
+	}
+
+	um, ok := PubKeyUnmarshallers[pmes.GetType()]
+	if !ok {
+		return nil, ErrBadKeyType
+	}
+
+	return um(pmes.GetData())
+}
+
+// MarshalPublicKey converts a public key object into a protobuf serialized
+// public key
+func MarshalPublicKey(k PubKey) ([]byte, error) {
+	return k.Bytes()
+}
+
+// UnmarshalPrivateKey converts a protobuf serialized private key into its
+// representative object
+func UnmarshalPrivateKey(data []byte) (PrivKey, error) {
+	pmes := new(pb.PrivateKey)
+	err := proto.Unmarshal(data, pmes)
+	if err != nil {
+		return nil, err
+	}
+
+	um, ok := PrivKeyUnmarshallers[pmes.GetType()]
+	if !ok {
+		return nil, ErrBadKeyType
+	}
+
+	return um(pmes.GetData())
+}
+
+// MarshalPrivateKey converts a key object into its protobuf serialized form.
+func MarshalPrivateKey(k PrivKey) ([]byte, error) {
+
+	switch k.(type) {
+	case *Ed25519PrivateKey:
+		return k.Bytes()
+	case *RsaPrivateKey:
+		return k.Bytes()
+	case *Secp256k1PrivateKey:
+		return k.Bytes()
+	default:
+		return nil, ErrBadKeyType
+	}
+}
+
+// ConfigDecodeKey decodes from b64 (for config file), and unmarshals.
+func ConfigDecodeKey(b string) ([]byte, error) {
+	return base64.StdEncoding.DecodeString(b)
+}
+
+// ConfigEncodeKey encodes to b64 (for config file), and marshals.
+func ConfigEncodeKey(b []byte) string {
+	return base64.StdEncoding.EncodeToString(b)
+}
+
+// KeyEqual checks whether two
+func KeyEqual(k1, k2 Key) bool {
+	if k1 == k2 {
+		return true
+	}
+
+	b1, err1 := k1.Bytes()
+	b2, err2 := k2.Bytes()
+	return bytes.Equal(b1, b2) && err1 == err2
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go
new file mode 100644
index 000000000..92a7f1cbe
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/pb/crypto.pb.go
@@ -0,0 +1,110 @@
+// Code generated by protoc-gen-gogo.
+// source: crypto.proto
+// DO NOT EDIT!
+
+/*
+Package crypto_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	crypto.proto
+
+It has these top-level messages:
+	PublicKey
+	PrivateKey
+*/
+package crypto_pb
+
+import proto "github.com/gogo/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = math.Inf
+
+type KeyType int32
+
+const (
+	KeyType_RSA       KeyType = 0
+	KeyType_Ed25519   KeyType = 1
+	KeyType_Secp256k1 KeyType = 2
+)
+
+var KeyType_name = map[int32]string{
+	0: "RSA",
+	1: "Ed25519",
+	2: "Secp256k1",
+}
+var KeyType_value = map[string]int32{
+	"RSA":       0,
+	"Ed25519":   1,
+	"Secp256k1": 2,
+}
+
+func (x KeyType) Enum() *KeyType {
+	p := new(KeyType)
+	*p = x
+	return p
+}
+func (x KeyType) String() string {
+	return proto.EnumName(KeyType_name, int32(x))
+}
+func (x *KeyType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(KeyType_value, data, "KeyType")
+	if err != nil {
+		return err
+	}
+	*x = KeyType(value)
+	return nil
+}
+
+type PublicKey struct {
+	Type             *KeyType `protobuf:"varint,1,req,enum=crypto.pb.KeyType" json:"Type,omitempty"`
+	Data             []byte   `protobuf:"bytes,2,req" json:"Data,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *PublicKey) Reset()         { *m = PublicKey{} }
+func (m *PublicKey) String() string { return proto.CompactTextString(m) }
+func (*PublicKey) ProtoMessage()    {}
+
+func (m *PublicKey) GetType() KeyType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return KeyType_RSA
+}
+
+func (m *PublicKey) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PrivateKey struct {
+	Type             *KeyType `protobuf:"varint,1,req,enum=crypto.pb.KeyType" json:"Type,omitempty"`
+	Data             []byte   `protobuf:"bytes,2,req" json:"Data,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *PrivateKey) Reset()         { *m = PrivateKey{} }
+func (m *PrivateKey) String() string { return proto.CompactTextString(m) }
+func (*PrivateKey) ProtoMessage()    {}
+
+func (m *PrivateKey) GetType() KeyType {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return KeyType_RSA
+}
+
+func (m *PrivateKey) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("crypto.pb.KeyType", KeyType_name, KeyType_value)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go b/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
new file mode 100644
index 000000000..f3c2acd3d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/rsa.go
@@ -0,0 +1,112 @@
+package crypto
+
+import (
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"errors"
+
+	pb "github.com/libp2p/go-libp2p-crypto/pb"
+
+	proto "github.com/gogo/protobuf/proto"
+	sha256 "github.com/minio/sha256-simd"
+)
+
+type RsaPrivateKey struct {
+	sk *rsa.PrivateKey
+	pk *rsa.PublicKey
+}
+
+type RsaPublicKey struct {
+	k *rsa.PublicKey
+}
+
+func (pk *RsaPublicKey) Verify(data, sig []byte) (bool, error) {
+	hashed := sha256.Sum256(data)
+	err := rsa.VerifyPKCS1v15(pk.k, crypto.SHA256, hashed[:], sig)
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (pk *RsaPublicKey) Bytes() ([]byte, error) {
+	b, err := x509.MarshalPKIXPublicKey(pk.k)
+	if err != nil {
+		return nil, err
+	}
+
+	pbmes := new(pb.PublicKey)
+	typ := pb.KeyType_RSA
+	pbmes.Type = &typ
+	pbmes.Data = b
+	return proto.Marshal(pbmes)
+}
+
+func (pk *RsaPublicKey) Encrypt(b []byte) ([]byte, error) {
+	return rsa.EncryptPKCS1v15(rand.Reader, pk.k, b)
+}
+
+// Equals checks whether this key is equal to another
+func (pk *RsaPublicKey) Equals(k Key) bool {
+	return KeyEqual(pk, k)
+}
+
+func (sk *RsaPrivateKey) Sign(message []byte) ([]byte, error) {
+	hashed := sha256.Sum256(message)
+	return rsa.SignPKCS1v15(rand.Reader, sk.sk, crypto.SHA256, hashed[:])
+}
+
+func (sk *RsaPrivateKey) GetPublic() PubKey {
+	if sk.pk == nil {
+		sk.pk = &sk.sk.PublicKey
+	}
+	return &RsaPublicKey{sk.pk}
+}
+
+func (sk *RsaPrivateKey) Decrypt(b []byte) ([]byte, error) {
+	return rsa.DecryptPKCS1v15(rand.Reader, sk.sk, b)
+}
+
+func (sk *RsaPrivateKey) Bytes() ([]byte, error) {
+	b := x509.MarshalPKCS1PrivateKey(sk.sk)
+	pbmes := new(pb.PrivateKey)
+	typ := pb.KeyType_RSA
+	pbmes.Type = &typ
+	pbmes.Data = b
+	return proto.Marshal(pbmes)
+}
+
+// Equals checks whether this key is equal to another
+func (sk *RsaPrivateKey) Equals(k Key) bool {
+	return KeyEqual(sk, k)
+}
+
+func UnmarshalRsaPrivateKey(b []byte) (PrivKey, error) {
+	sk, err := x509.ParsePKCS1PrivateKey(b)
+	if err != nil {
+		return nil, err
+	}
+	return &RsaPrivateKey{sk: sk}, nil
+}
+
+func MarshalRsaPrivateKey(k *RsaPrivateKey) []byte {
+	return x509.MarshalPKCS1PrivateKey(k.sk)
+}
+
+func UnmarshalRsaPublicKey(b []byte) (PubKey, error) {
+	pub, err := x509.ParsePKIXPublicKey(b)
+	if err != nil {
+		return nil, err
+	}
+	pk, ok := pub.(*rsa.PublicKey)
+	if !ok {
+		return nil, errors.New("Not actually an rsa public key.")
+	}
+	return &RsaPublicKey{pk}, nil
+}
+
+func MarshalRsaPublicKey(k *RsaPublicKey) ([]byte, error) {
+	return x509.MarshalPKIXPublicKey(k.k)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go
new file mode 100644
index 000000000..3ed37f1c6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-crypto/secp256k1.go
@@ -0,0 +1,100 @@
+package crypto
+
+import (
+	"fmt"
+	"io"
+
+	btcec "github.com/btcsuite/btcd/btcec"
+	proto "github.com/gogo/protobuf/proto"
+	pb "github.com/libp2p/go-libp2p-crypto/pb"
+	sha256 "github.com/minio/sha256-simd"
+)
+
+type Secp256k1PrivateKey btcec.PrivateKey
+type Secp256k1PublicKey btcec.PublicKey
+
+func GenerateSecp256k1Key(src io.Reader) (PrivKey, PubKey, error) {
+	privk, err := btcec.NewPrivateKey(btcec.S256())
+	if err != nil {
+		return nil, nil, err
+	}
+
+	k := (*Secp256k1PrivateKey)(privk)
+	return k, k.GetPublic(), nil
+}
+
+func UnmarshalSecp256k1PrivateKey(data []byte) (PrivKey, error) {
+	if len(data) != btcec.PrivKeyBytesLen {
+		return nil, fmt.Errorf("expected secp256k1 data size to be %d", btcec.PrivKeyBytesLen)
+	}
+
+	privk, _ := btcec.PrivKeyFromBytes(btcec.S256(), data)
+	return (*Secp256k1PrivateKey)(privk), nil
+}
+
+func UnmarshalSecp256k1PublicKey(data []byte) (PubKey, error) {
+	k, err := btcec.ParsePubKey(data, btcec.S256())
+	if err != nil {
+		return nil, err
+	}
+
+	return (*Secp256k1PublicKey)(k), nil
+}
+
+func (k *Secp256k1PrivateKey) Bytes() ([]byte, error) {
+	pbmes := new(pb.PrivateKey)
+	typ := pb.KeyType_Secp256k1
+	pbmes.Type = &typ
+	pbmes.Data = (*btcec.PrivateKey)(k).Serialize()
+	return proto.Marshal(pbmes)
+}
+
+func (k *Secp256k1PrivateKey) Equals(o Key) bool {
+	sk, ok := o.(*Secp256k1PrivateKey)
+	if !ok {
+		return false
+	}
+
+	return k.D.Cmp(sk.D) == 0
+}
+
+func (k *Secp256k1PrivateKey) Sign(data []byte) ([]byte, error) {
+	hash := sha256.Sum256(data)
+	sig, err := (*btcec.PrivateKey)(k).Sign(hash[:])
+	if err != nil {
+		return nil, err
+	}
+
+	return sig.Serialize(), nil
+}
+
+func (k *Secp256k1PrivateKey) GetPublic() PubKey {
+	return (*Secp256k1PublicKey)((*btcec.PrivateKey)(k).PubKey())
+}
+
+func (k *Secp256k1PublicKey) Bytes() ([]byte, error) {
+	pbmes := new(pb.PublicKey)
+	typ := pb.KeyType_Secp256k1
+	pbmes.Type = &typ
+	pbmes.Data = (*btcec.PublicKey)(k).SerializeCompressed()
+	return proto.Marshal(pbmes)
+}
+
+func (k *Secp256k1PublicKey) Equals(o Key) bool {
+	sk, ok := o.(*Secp256k1PublicKey)
+	if !ok {
+		return false
+	}
+
+	return (*btcec.PublicKey)(k).IsEqual((*btcec.PublicKey)(sk))
+}
+
+func (k *Secp256k1PublicKey) Verify(data []byte, sigStr []byte) (bool, error) {
+	sig, err := btcec.ParseDERSignature(sigStr, btcec.S256())
+	if err != nil {
+		return false, err
+	}
+
+	hash := sha256.Sum256(data)
+	return sig.Verify(hash[:], (*btcec.PublicKey)(k)), nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-host/LICENSE b/vendor/github.com/libp2p/go-libp2p-host/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-host/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-host/host.go b/vendor/github.com/libp2p/go-libp2p-host/host.go
new file mode 100644
index 000000000..3530c6ead
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-host/host.go
@@ -0,0 +1,68 @@
+package host
+
+import (
+	"context"
+
+	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+	ma "github.com/multiformats/go-multiaddr"
+	msmux "github.com/multiformats/go-multistream"
+)
+
+// Host is an object participating in a p2p network, which
+// implements protocols or provides services. It handles
+// requests like a Server, and issues requests like a Client.
+// It is called Host because it is both Server and Client (and Peer
+// may be confusing).
+type Host interface {
+	// ID returns the (local) peer.ID associated with this Host
+	ID() peer.ID
+
+	// Peerstore returns the Host's repository of Peer Addresses and Keys.
+	Peerstore() pstore.Peerstore
+
+	// Returns the listen addresses of the Host
+	Addrs() []ma.Multiaddr
+
+	// Networks returns the Network interface of the Host
+	Network() inet.Network
+
+	// Mux returns the Mux multiplexing incoming streams to protocol handlers
+	Mux() *msmux.MultistreamMuxer
+
+	// Connect ensures there is a connection between this host and the peer with
+	// given peer.ID. Connect will absorb the addresses in pi into its internal
+	// peerstore. If there is not an active connection, Connect will issue a
+	// h.Network.Dial, and block until a connection is open, or an error is
+	// returned. // TODO: Relay + NAT.
+	Connect(ctx context.Context, pi pstore.PeerInfo) error
+
+	// SetStreamHandler sets the protocol handler on the Host's Mux.
+	// This is equivalent to:
+	//   host.Mux().SetHandler(proto, handler)
+	// (Threadsafe)
+	SetStreamHandler(pid protocol.ID, handler inet.StreamHandler)
+
+	// SetStreamHandlerMatch sets the protocol handler on the Host's Mux
+	// using a matching function for protocol selection.
+	SetStreamHandlerMatch(protocol.ID, func(string) bool, inet.StreamHandler)
+
+	// RemoveStreamHandler removes a handler on the mux that was set by
+	// SetStreamHandler
+	RemoveStreamHandler(pid protocol.ID)
+
+	// NewStream opens a new stream to given peer p, and writes a p2p/protocol
+	// header with given protocol.ID. If there is no connection to p, attempts
+	// to create one. If ProtocolID is "", writes no header.
+	// (Threadsafe)
+	NewStream(ctx context.Context, p peer.ID, pids ...protocol.ID) (inet.Stream, error)
+
+	// Close shuts down the host, its Network, and services.
+	Close() error
+
+	// ConnManager returns this hosts connection manager
+	ConnManager() ifconnmgr.ConnManager
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-host/match.go b/vendor/github.com/libp2p/go-libp2p-host/match.go
new file mode 100644
index 000000000..c5ddd650c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-host/match.go
@@ -0,0 +1,36 @@
+package host
+
+import (
+	"strings"
+
+	semver "github.com/coreos/go-semver/semver"
+	"github.com/libp2p/go-libp2p-protocol"
+)
+
+func MultistreamSemverMatcher(base protocol.ID) (func(string) bool, error) {
+	parts := strings.Split(string(base), "/")
+	vers, err := semver.NewVersion(parts[len(parts)-1])
+	if err != nil {
+		return nil, err
+	}
+
+	return func(check string) bool {
+		chparts := strings.Split(check, "/")
+		if len(chparts) != len(parts) {
+			return false
+		}
+
+		for i, v := range chparts[:len(chparts)-1] {
+			if parts[i] != v {
+				return false
+			}
+		}
+
+		chvers, err := semver.NewVersion(chparts[len(chparts)-1])
+		if err != nil {
+			return false
+		}
+
+		return vers.Major == chvers.Major && vers.Minor >= chvers.Minor
+	}, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-connmgr/LICENSE b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/LICENSE
new file mode 100644
index 000000000..2f06d0eba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-connmgr/interface.go b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/interface.go
new file mode 100644
index 000000000..8ceee84e6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/interface.go
@@ -0,0 +1,24 @@
+package ifconnmgr
+
+import (
+	"context"
+	"time"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+type ConnManager interface {
+	TagPeer(peer.ID, string, int)
+	UntagPeer(peer.ID, string)
+	GetTagInfo(peer.ID) *TagInfo
+	TrimOpenConns(context.Context)
+	Notifee() inet.Notifiee
+}
+
+type TagInfo struct {
+	FirstSeen time.Time
+	Value     int
+	Tags      map[string]int
+	Conns     map[string]time.Time
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-connmgr/null.go b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/null.go
new file mode 100644
index 000000000..d7d3fc8a6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-connmgr/null.go
@@ -0,0 +1,26 @@
+package ifconnmgr
+
+import (
+	"context"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+type NullConnMgr struct{}
+
+func (_ NullConnMgr) TagPeer(peer.ID, string, int)  {}
+func (_ NullConnMgr) UntagPeer(peer.ID, string)     {}
+func (_ NullConnMgr) GetTagInfo(peer.ID) *TagInfo   { return &TagInfo{} }
+func (_ NullConnMgr) TrimOpenConns(context.Context) {}
+func (_ NullConnMgr) Notifee() inet.Notifiee        { return &cmNotifee{} }
+
+type cmNotifee struct{}
+
+func (nn *cmNotifee) Connected(n inet.Network, c inet.Conn)         {}
+func (nn *cmNotifee) Disconnected(n inet.Network, c inet.Conn)      {}
+func (nn *cmNotifee) Listen(n inet.Network, addr ma.Multiaddr)      {}
+func (nn *cmNotifee) ListenClose(n inet.Network, addr ma.Multiaddr) {}
+func (nn *cmNotifee) OpenedStream(inet.Network, inet.Stream)        {}
+func (nn *cmNotifee) ClosedStream(inet.Network, inet.Stream)        {}
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-pnet/LICENSE b/vendor/github.com/libp2p/go-libp2p-interface-pnet/LICENSE
new file mode 100644
index 000000000..244b53da1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-pnet/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018 Jakub Sztandera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-pnet/error.go b/vendor/github.com/libp2p/go-libp2p-interface-pnet/error.go
new file mode 100644
index 000000000..e4cb9f7c3
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-pnet/error.go
@@ -0,0 +1,29 @@
+package ipnet
+
+// PNetError is error type for ease of detecting PNet errors
+type PNetError interface {
+	IsPNetError() bool
+}
+
+// NewError creates new PNetError
+func NewError(err string) error {
+	return pnetErr("privnet: " + err)
+}
+
+// IsPNetError checks if given error is PNet Error
+func IsPNetError(err error) bool {
+	v, ok := err.(PNetError)
+	return ok && v.IsPNetError()
+}
+
+type pnetErr string
+
+var _ PNetError = (PNetError)(pnetErr(""))
+
+func (p pnetErr) Error() string {
+	return string(p)
+}
+
+func (pnetErr) IsPNetError() bool {
+	return true
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-interface-pnet/interface.go b/vendor/github.com/libp2p/go-libp2p-interface-pnet/interface.go
new file mode 100644
index 000000000..f26421d0f
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-interface-pnet/interface.go
@@ -0,0 +1,38 @@
+package ipnet
+
+import (
+	"net"
+	"os"
+)
+
+// EnvKey defines environment variable name for forcing usage of PNet in libp2p
+// When environment variable of this name is set to "1" the ForcePrivateNetwork
+// variable will be set to true.
+const EnvKey = "LIBP2P_FORCE_PNET"
+
+// ForcePrivateNetwork is boolean variable that forces usage of PNet in libp2p
+// Setting this variable to true or setting LIBP2P_FORCE_PNET environment variable
+// to true will make libp2p to require private network protector.
+// If no network protector is provided and this variable is set to true libp2p will
+// refuse to connect.
+var ForcePrivateNetwork = false
+
+func init() {
+	ForcePrivateNetwork = os.Getenv(EnvKey) == "1"
+}
+
+// ErrNotInPrivateNetwork is an error that should be returned by libp2p when it
+// tries to dial witt ForcePrivateNetwork set and no PNet Protector
+var ErrNotInPrivateNetwork = NewError("private network was not configured but" +
+	" is enforced by the environment")
+
+// Protector interface is a way for private network implementation to be transparent in
+// libp2p. It is created by implementation and use by libp2p-conn to secure connections
+// so they can be only established with selected number of peers.
+type Protector interface {
+	// Wraps passed connection to protect it
+	Protect(net.Conn) (net.Conn, error)
+
+	// Returns key fingerprint that is safe to expose
+	Fingerprint() []byte
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-loggables/LICENSE b/vendor/github.com/libp2p/go-libp2p-loggables/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-loggables/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-loggables/loggables.go b/vendor/github.com/libp2p/go-libp2p-loggables/loggables.go
new file mode 100644
index 000000000..bd468ad18
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-loggables/loggables.go
@@ -0,0 +1,80 @@
+// Package loggables includes a bunch of transaltor functions for commonplace/stdlib
+// objects. This is boilerplate code that shouldn't change much, and not sprinkled
+// all over the place (i.e. gather it here).
+//
+// Note: it may make sense to put all stdlib Loggable functions in the eventlog
+// package. Putting it here for now in case we don't want to polute it.
+package loggables
+
+import (
+	"net"
+
+	logging "github.com/ipfs/go-log"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+	uuid "github.com/satori/go.uuid"
+)
+
+// NetConn returns an eventlog.Metadata with the conn addresses
+func NetConn(c net.Conn) logging.Loggable {
+	return logging.Metadata{
+		"localAddr":  c.LocalAddr(),
+		"remoteAddr": c.RemoteAddr(),
+	}
+}
+
+// Error returns an eventlog.Metadata with an error
+func Error(e error) logging.Loggable {
+	return logging.Metadata{
+		"error": e.Error(),
+	}
+}
+
+func Uuid(key string) logging.Metadata {
+	ids := "#UUID-ERROR#"
+	if id, err := uuid.NewV4(); err == nil {
+		ids = id.String()
+	}
+	return logging.Metadata{
+		key: ids,
+	}
+}
+
+// Dial metadata is metadata for dial events
+func Dial(sys string, lid, rid peer.ID, laddr, raddr ma.Multiaddr) DeferredMap {
+	m := DeferredMap{}
+	m["subsystem"] = sys
+	if lid != "" {
+		m["localPeer"] = func() interface{} { return lid.Pretty() }
+	}
+	if laddr != nil {
+		m["localAddr"] = func() interface{} { return laddr.String() }
+	}
+	if rid != "" {
+		m["remotePeer"] = func() interface{} { return rid.Pretty() }
+	}
+	if raddr != nil {
+		m["remoteAddr"] = func() interface{} { return raddr.String() }
+	}
+	return m
+}
+
+// DeferredMap is a Loggable which may contain deferred values.
+type DeferredMap map[string]interface{}
+
+// Loggable describes objects that can be marshalled into Metadata for logging
+func (m DeferredMap) Loggable() map[string]interface{} {
+	m2 := map[string]interface{}{}
+	for k, v := range m {
+
+		if vf, ok := v.(func() interface{}); ok {
+			// if it's a DeferredVal, call it.
+			m2[k] = vf()
+
+		} else {
+			// else use the value as is.
+			m2[k] = v
+		}
+	}
+	return m2
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-metrics/LICENSE b/vendor/github.com/libp2p/go-libp2p-metrics/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-metrics/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-metrics/bw_stats.go b/vendor/github.com/libp2p/go-libp2p-metrics/bw_stats.go
new file mode 100644
index 000000000..3936312bd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-metrics/bw_stats.go
@@ -0,0 +1,83 @@
+package metrics
+
+import (
+	flow "github.com/libp2p/go-flow-metrics"
+	peer "github.com/libp2p/go-libp2p-peer"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+)
+
+type Stats struct {
+	TotalIn  int64
+	TotalOut int64
+	RateIn   float64
+	RateOut  float64
+}
+
+type BandwidthCounter struct {
+	totalIn  flow.Meter
+	totalOut flow.Meter
+
+	protocolIn  flow.MeterRegistry
+	protocolOut flow.MeterRegistry
+
+	peerIn  flow.MeterRegistry
+	peerOut flow.MeterRegistry
+}
+
+func NewBandwidthCounter() *BandwidthCounter {
+	return new(BandwidthCounter)
+}
+
+func (bwc *BandwidthCounter) LogSentMessage(size int64) {
+	bwc.totalOut.Mark(uint64(size))
+}
+
+func (bwc *BandwidthCounter) LogRecvMessage(size int64) {
+	bwc.totalIn.Mark(uint64(size))
+}
+
+func (bwc *BandwidthCounter) LogSentMessageStream(size int64, proto protocol.ID, p peer.ID) {
+	bwc.protocolOut.Get(string(proto)).Mark(uint64(size))
+	bwc.peerOut.Get(string(p)).Mark(uint64(size))
+}
+
+func (bwc *BandwidthCounter) LogRecvMessageStream(size int64, proto protocol.ID, p peer.ID) {
+	bwc.protocolIn.Get(string(proto)).Mark(uint64(size))
+	bwc.peerIn.Get(string(p)).Mark(uint64(size))
+}
+
+func (bwc *BandwidthCounter) GetBandwidthForPeer(p peer.ID) (out Stats) {
+	inSnap := bwc.peerIn.Get(string(p)).Snapshot()
+	outSnap := bwc.peerOut.Get(string(p)).Snapshot()
+
+	return Stats{
+		TotalIn:  int64(inSnap.Total),
+		TotalOut: int64(outSnap.Total),
+		RateIn:   inSnap.Rate,
+		RateOut:  outSnap.Rate,
+	}
+}
+
+func (bwc *BandwidthCounter) GetBandwidthForProtocol(proto protocol.ID) (out Stats) {
+	inSnap := bwc.protocolIn.Get(string(proto)).Snapshot()
+	outSnap := bwc.protocolOut.Get(string(proto)).Snapshot()
+
+	return Stats{
+		TotalIn:  int64(inSnap.Total),
+		TotalOut: int64(outSnap.Total),
+		RateIn:   inSnap.Rate,
+		RateOut:  outSnap.Rate,
+	}
+}
+
+func (bwc *BandwidthCounter) GetBandwidthTotals() (out Stats) {
+	inSnap := bwc.totalIn.Snapshot()
+	outSnap := bwc.totalOut.Snapshot()
+
+	return Stats{
+		TotalIn:  int64(inSnap.Total),
+		TotalOut: int64(outSnap.Total),
+		RateIn:   inSnap.Rate,
+		RateOut:  outSnap.Rate,
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-metrics/interface.go b/vendor/github.com/libp2p/go-libp2p-metrics/interface.go
new file mode 100644
index 000000000..ef1bb97ea
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-metrics/interface.go
@@ -0,0 +1,16 @@
+package metrics
+
+import (
+	peer "github.com/libp2p/go-libp2p-peer"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+)
+
+type Reporter interface {
+	LogSentMessage(int64)
+	LogRecvMessage(int64)
+	LogSentMessageStream(int64, protocol.ID, peer.ID)
+	LogRecvMessageStream(int64, protocol.ID, peer.ID)
+	GetBandwidthForPeer(peer.ID) Stats
+	GetBandwidthForProtocol(protocol.ID) Stats
+	GetBandwidthTotals() Stats
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-nat/LICENSE b/vendor/github.com/libp2p/go-libp2p-nat/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-nat/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-nat/mapping.go b/vendor/github.com/libp2p/go-libp2p-nat/mapping.go
new file mode 100644
index 000000000..b03b002d0
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-nat/mapping.go
@@ -0,0 +1,143 @@
+package nat
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/jbenet/goprocess"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+// Mapping represents a port mapping in a NAT.
+type Mapping interface {
+	// NAT returns the NAT object this Mapping belongs to.
+	NAT() *NAT
+
+	// Protocol returns the protocol of this port mapping. This is either
+	// "tcp" or "udp" as no other protocols are likely to be NAT-supported.
+	Protocol() string
+
+	// InternalPort returns the internal device port. Mapping will continue to
+	// try to map InternalPort() to an external facing port.
+	InternalPort() int
+
+	// ExternalPort returns the external facing port. If the mapping is not
+	// established, port will be 0
+	ExternalPort() int
+
+	// InternalAddr returns the internal address.
+	InternalAddr() ma.Multiaddr
+
+	// ExternalAddr returns the external facing address. If the mapping is not
+	// established, addr will be nil, and and ErrNoMapping will be returned.
+	ExternalAddr() (addr ma.Multiaddr, err error)
+
+	// Close closes the port mapping
+	Close() error
+}
+
+// keeps republishing
+type mapping struct {
+	sync.Mutex // guards all fields
+
+	nat       *NAT
+	proto     string
+	intport   int
+	extport   int
+	permanent bool
+	intaddr   ma.Multiaddr
+	proc      goprocess.Process
+
+	comment string
+
+	cached    ma.Multiaddr
+	cacheTime time.Time
+	cacheLk   sync.Mutex
+}
+
+func (m *mapping) NAT() *NAT {
+	m.Lock()
+	defer m.Unlock()
+	return m.nat
+}
+
+func (m *mapping) Protocol() string {
+	m.Lock()
+	defer m.Unlock()
+	return m.proto
+}
+
+func (m *mapping) InternalPort() int {
+	m.Lock()
+	defer m.Unlock()
+	return m.intport
+}
+
+func (m *mapping) ExternalPort() int {
+	m.Lock()
+	defer m.Unlock()
+	return m.extport
+}
+
+func (m *mapping) setExternalPort(p int) {
+	m.Lock()
+	defer m.Unlock()
+	m.extport = p
+}
+
+func (m *mapping) InternalAddr() ma.Multiaddr {
+	m.Lock()
+	defer m.Unlock()
+	return m.intaddr
+}
+
+func (m *mapping) ExternalAddr() (ma.Multiaddr, error) {
+	m.cacheLk.Lock()
+	ctime := m.cacheTime
+	cval := m.cached
+	m.cacheLk.Unlock()
+	if time.Since(ctime) < CacheTime {
+		return cval, nil
+	}
+
+	if m.ExternalPort() == 0 { // dont even try right now.
+		return nil, ErrNoMapping
+	}
+
+	m.nat.natmu.Lock()
+	ip, err := m.nat.nat.GetExternalAddress()
+	m.nat.natmu.Unlock()
+	if err != nil {
+		return nil, err
+	}
+
+	ipmaddr, err := manet.FromIP(ip)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing ip")
+	}
+
+	// call m.ExternalPort again, as mapping may have changed under our feet. (tocttou)
+	extport := m.ExternalPort()
+	if extport == 0 {
+		return nil, ErrNoMapping
+	}
+
+	tcp, err := ma.NewMultiaddr(fmt.Sprintf("/%s/%d", m.Protocol(), extport))
+	if err != nil {
+		return nil, err
+	}
+
+	maddr2 := ipmaddr.Encapsulate(tcp)
+
+	m.cacheLk.Lock()
+	m.cached = maddr2
+	m.cacheTime = time.Now()
+	m.cacheLk.Unlock()
+	return maddr2, nil
+}
+
+func (m *mapping) Close() error {
+	return m.proc.Close()
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-nat/nat.go b/vendor/github.com/libp2p/go-libp2p-nat/nat.go
new file mode 100644
index 000000000..d68aca075
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-nat/nat.go
@@ -0,0 +1,288 @@
+package nat
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	nat "github.com/fd/go-nat"
+	logging "github.com/ipfs/go-log"
+	goprocess "github.com/jbenet/goprocess"
+	periodic "github.com/jbenet/goprocess/periodic"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+var (
+	// ErrNoMapping signals no mapping exists for an address
+	ErrNoMapping = errors.New("mapping not established")
+)
+
+var log = logging.Logger("nat")
+
+// MappingDuration is a default port mapping duration.
+// Port mappings are renewed every (MappingDuration / 3)
+const MappingDuration = time.Second * 60
+
+// CacheTime is the time a mapping will cache an external address for
+const CacheTime = time.Second * 15
+
+// DiscoverNAT looks for a NAT device in the network and
+// returns an object that can manage port mappings.
+func DiscoverNAT() *NAT {
+	nat, err := nat.DiscoverGateway()
+	if err != nil {
+		log.Debug("DiscoverGateway error:", err)
+		return nil
+	}
+	addr, err := nat.GetDeviceAddress()
+	if err != nil {
+		log.Debug("DiscoverGateway address error:", err)
+	} else {
+		log.Debug("DiscoverGateway address:", addr)
+	}
+	return newNAT(nat)
+}
+
+// NAT is an object that manages address port mappings in
+// NATs (Network Address Translators). It is a long-running
+// service that will periodically renew port mappings,
+// and keep an up-to-date list of all the external addresses.
+type NAT struct {
+	natmu sync.Mutex
+	nat   nat.NAT
+	proc  goprocess.Process // manages nat mappings lifecycle
+
+	mappingmu sync.RWMutex // guards mappings
+	mappings  map[*mapping]struct{}
+
+	Notifier
+}
+
+func newNAT(realNAT nat.NAT) *NAT {
+	return &NAT{
+		nat:      realNAT,
+		proc:     goprocess.WithParent(goprocess.Background()),
+		mappings: make(map[*mapping]struct{}),
+	}
+}
+
+// Close shuts down all port mappings. NAT can no longer be used.
+func (nat *NAT) Close() error {
+	return nat.proc.Close()
+}
+
+// Process returns the nat's life-cycle manager, for making it listen
+// to close signals.
+func (nat *NAT) Process() goprocess.Process {
+	return nat.proc
+}
+
+// Mappings returns a slice of all NAT mappings
+func (nat *NAT) Mappings() []Mapping {
+	nat.mappingmu.Lock()
+	maps2 := make([]Mapping, 0, len(nat.mappings))
+	for m := range nat.mappings {
+		maps2 = append(maps2, m)
+	}
+	nat.mappingmu.Unlock()
+	return maps2
+}
+
+func (nat *NAT) addMapping(m *mapping) {
+	// make mapping automatically close when nat is closed.
+	nat.proc.AddChild(m.proc)
+
+	nat.mappingmu.Lock()
+	nat.mappings[m] = struct{}{}
+	nat.mappingmu.Unlock()
+}
+
+func (nat *NAT) rmMapping(m *mapping) {
+	nat.mappingmu.Lock()
+	delete(nat.mappings, m)
+	nat.mappingmu.Unlock()
+}
+
+// NewMapping attemps to construct a mapping on protocol and internal port
+// It will also periodically renew the mapping until the returned Mapping
+// -- or its parent NAT -- is Closed.
+//
+// May not succeed, and mappings may change over time;
+// NAT devices may not respect our port requests, and even lie.
+// Clients should not store the mapped results, but rather always
+// poll our object for the latest mappings.
+func (nat *NAT) NewMapping(maddr ma.Multiaddr) (Mapping, error) {
+	if nat == nil {
+		return nil, fmt.Errorf("no nat available")
+	}
+
+	network, addr, err := manet.DialArgs(maddr)
+	if err != nil {
+		return nil, fmt.Errorf("DialArgs failed on addr: %s", maddr.String())
+	}
+
+	switch network {
+	case "tcp", "tcp4", "tcp6":
+		network = "tcp"
+	case "udp", "udp4", "udp6":
+		network = "udp"
+	default:
+		return nil, fmt.Errorf("transport not supported by NAT: %s", network)
+	}
+
+	intports := strings.Split(addr, ":")[1]
+	intport, err := strconv.Atoi(intports)
+	if err != nil {
+		return nil, err
+	}
+
+	m := &mapping{
+		nat:     nat,
+		proto:   network,
+		intport: intport,
+		intaddr: maddr,
+	}
+	m.proc = goprocess.WithTeardown(func() error {
+		nat.rmMapping(m)
+		return nil
+	})
+	nat.addMapping(m)
+
+	m.proc.AddChild(periodic.Every(MappingDuration/3, func(worker goprocess.Process) {
+		nat.establishMapping(m)
+	}))
+
+	// do it once synchronously, so first mapping is done right away, and before exiting,
+	// allowing users -- in the optimistic case -- to use results right after.
+	nat.establishMapping(m)
+	return m, nil
+}
+
+func (nat *NAT) establishMapping(m *mapping) {
+	oldport := m.ExternalPort()
+
+	log.Debugf("Attempting port map: %s/%d", m.Protocol(), m.InternalPort())
+	comment := "libp2p"
+	if m.comment != "" {
+		comment = "libp2p-" + m.comment
+	}
+
+	nat.natmu.Lock()
+	newport, err := nat.nat.AddPortMapping(m.Protocol(), m.InternalPort(), comment, MappingDuration)
+	if err != nil {
+		// Some hardware does not support mappings with timeout, so try that
+		newport, err = nat.nat.AddPortMapping(m.Protocol(), m.InternalPort(), comment, 0)
+	}
+	nat.natmu.Unlock()
+
+	failure := func() {
+		m.setExternalPort(0) // clear mapping
+		// TODO: log.Event
+		log.Warningf("failed to establish port mapping: %s", err)
+		nat.Notifier.notifyAll(func(n Notifiee) {
+			n.MappingFailed(nat, m, oldport, err)
+		})
+
+		// we do not close if the mapping failed,
+		// because it may work again next time.
+	}
+
+	if err != nil || newport == 0 {
+		failure()
+		return
+	}
+
+	m.setExternalPort(newport)
+	ext, err := m.ExternalAddr()
+	if err != nil {
+		log.Debugf("NAT Mapping addr error: %s %s", m.InternalAddr(), err)
+		failure()
+		return
+	}
+
+	log.Debugf("NAT Mapping: %s --> %s", m.InternalAddr(), ext)
+	if oldport != 0 && newport != oldport {
+		log.Debugf("failed to renew same port mapping: ch %d -> %d", oldport, newport)
+		nat.Notifier.notifyAll(func(n Notifiee) {
+			n.MappingChanged(nat, m, oldport, newport)
+		})
+	}
+
+	nat.Notifier.notifyAll(func(n Notifiee) {
+		n.MappingSuccess(nat, m)
+	})
+}
+
+// PortMapAddrs attempts to open (and continue to keep open)
+// port mappings for given addrs. This function blocks until
+// all  addresses have been tried. This allows clients to
+// retrieve results immediately after:
+//
+//   nat.PortMapAddrs(addrs)
+//   mapped := nat.ExternalAddrs()
+//
+// Some may not succeed, and mappings may change over time;
+// NAT devices may not respect our port requests, and even lie.
+// Clients should not store the mapped results, but rather always
+// poll our object for the latest mappings.
+func (nat *NAT) PortMapAddrs(addrs []ma.Multiaddr) {
+	// spin off addr mappings independently.
+	var wg sync.WaitGroup
+	for _, addr := range addrs {
+		// do all of them concurrently
+		wg.Add(1)
+		go func(addr ma.Multiaddr) {
+			defer wg.Done()
+			nat.NewMapping(addr)
+		}(addr)
+	}
+	wg.Wait()
+}
+
+// MappedAddrs returns address mappings NAT believes have been
+// successfully established. Unsuccessful mappings are nil. This is:
+//
+// 		map[internalAddr]externalAddr
+//
+// This set of mappings _may not_ be correct, as NAT devices are finicky.
+// Consider this with _best effort_ semantics.
+func (nat *NAT) MappedAddrs() map[ma.Multiaddr]ma.Multiaddr {
+
+	mappings := nat.Mappings()
+	addrmap := make(map[ma.Multiaddr]ma.Multiaddr, len(mappings))
+
+	for _, m := range mappings {
+		i := m.InternalAddr()
+		e, err := m.ExternalAddr()
+		if err != nil {
+			addrmap[i] = nil
+		} else {
+			addrmap[i] = e
+		}
+	}
+	return addrmap
+}
+
+// ExternalAddrs returns a list of addresses that NAT believes have
+// been successfully established. Unsuccessful mappings are omitted,
+// so nat.ExternalAddrs() may return less addresses than nat.InternalAddrs().
+// To see which addresses are mapped, use nat.MappedAddrs().
+//
+// This set of mappings _may not_ be correct, as NAT devices are finicky.
+// Consider this with _best effort_ semantics.
+func (nat *NAT) ExternalAddrs() []ma.Multiaddr {
+	mappings := nat.Mappings()
+	addrs := make([]ma.Multiaddr, 0, len(mappings))
+	for _, m := range mappings {
+		a, err := m.ExternalAddr()
+		if err != nil {
+			continue // this mapping not currently successful.
+		}
+		addrs = append(addrs, a)
+	}
+	return addrs
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-nat/notifier.go b/vendor/github.com/libp2p/go-libp2p-nat/notifier.go
new file mode 100644
index 000000000..462a78b95
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-nat/notifier.go
@@ -0,0 +1,47 @@
+package nat
+
+import (
+	notifier "github.com/whyrusleeping/go-notifier"
+)
+
+// Notifier is an object that assists NAT in notifying listeners.
+// It is implemented using thirdparty/notifier
+type Notifier struct {
+	n notifier.Notifier
+}
+
+func (n *Notifier) notifyAll(notify func(n Notifiee)) {
+	n.n.NotifyAll(func(n notifier.Notifiee) {
+		notify(n.(Notifiee))
+	})
+}
+
+// Notify signs up notifiee to listen to NAT events.
+func (n *Notifier) Notify(notifiee Notifiee) {
+	n.n.Notify(n)
+}
+
+// StopNotify stops signaling events to notifiee.
+func (n *Notifier) StopNotify(notifiee Notifiee) {
+	n.n.StopNotify(notifiee)
+}
+
+// Notifiee is an interface objects must implement to listen to NAT events.
+type Notifiee interface {
+
+	// Called every time a successful mapping happens
+	// Warning: the port mapping may have changed. If that is the
+	// case, both MappingSuccess and MappingChanged are called.
+	MappingSuccess(nat *NAT, m Mapping)
+
+	// Called when mapping a port succeeds, but the mapping is
+	// with a different port than an earlier success.
+	MappingChanged(nat *NAT, m Mapping, oldport int, newport int)
+
+	// Called when a port mapping fails. NAT will continue attempting after
+	// the next period. To stop trying, use: mapping.Close(). After this failure,
+	// mapping.ExternalPort() will be zero, and nat.ExternalAddrs() will not
+	// return the address for this mapping. With luck, the next attempt will
+	// succeed, without the client needing to do anything.
+	MappingFailed(nat *NAT, m Mapping, oldport int, err error)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-net/LICENSE b/vendor/github.com/libp2p/go-libp2p-net/LICENSE
new file mode 100644
index 000000000..0c354d06a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-net/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2018 Protocol Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-net/interface.go b/vendor/github.com/libp2p/go-libp2p-net/interface.go
new file mode 100644
index 000000000..c7ccf1e22
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-net/interface.go
@@ -0,0 +1,192 @@
+package net
+
+import (
+	"context"
+	"io"
+
+	"github.com/jbenet/goprocess"
+	ic "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+	smux "github.com/libp2p/go-stream-muxer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// MessageSizeMax is a soft (recommended) maximum for network messages.
+// One can write more, as the interface is a stream. But it is useful
+// to bunch it up into multiple read/writes when the whole message is
+// a single, large serialized object.
+const MessageSizeMax = 1 << 22 // 4 MB
+
+// Stream represents a bidirectional channel between two agents in
+// the IPFS network. "agent" is as granular as desired, potentially
+// being a "request -> reply" pair, or whole protocols.
+// Streams are backed by stream-muxer streams underneath the hood.
+type Stream interface {
+	smux.Stream
+
+	Protocol() protocol.ID
+	SetProtocol(protocol.ID)
+
+	// Conn returns the connection this stream is part of.
+	Conn() Conn
+}
+
+// StreamHandler is the type of function used to listen for
+// streams opened by the remote side.
+type StreamHandler func(Stream)
+
+// ConnSecurity is the interface that one can mix into a connection interface to
+// give it the security methods.
+type ConnSecurity interface {
+	// LocalPeer returns our peer ID
+	LocalPeer() peer.ID
+
+	// LocalPrivateKey returns our private key
+	LocalPrivateKey() ic.PrivKey
+
+	// RemotePeer returns the peer ID of the remote peer.
+	RemotePeer() peer.ID
+
+	// RemotePublicKey returns the public key of the remote peer.
+	RemotePublicKey() ic.PubKey
+}
+
+// ConnMultiaddrs is an interface mixin for connection types that provide multiaddr
+// addresses for the endpoints.
+type ConnMultiaddrs interface {
+	// LocalMultiaddr returns the local Multiaddr associated
+	// with this connection
+	LocalMultiaddr() ma.Multiaddr
+
+	// RemoteMultiaddr returns the remote Multiaddr associated
+	// with this connection
+	RemoteMultiaddr() ma.Multiaddr
+}
+
+// Conn is a connection to a remote peer. It multiplexes streams.
+// Usually there is no need to use a Conn directly, but it may
+// be useful to get information about the peer on the other side:
+//  stream.Conn().RemotePeer()
+type Conn interface {
+	io.Closer
+
+	ConnSecurity
+	ConnMultiaddrs
+
+	// NewStream constructs a new Stream over this conn.
+	NewStream() (Stream, error)
+
+	// GetStreams returns all open streams over this conn.
+	GetStreams() []Stream
+}
+
+// ConnHandler is the type of function used to listen for
+// connections opened by the remote side.
+type ConnHandler func(Conn)
+
+// Network is the interface used to connect to the outside world.
+// It dials and listens for connections. it uses a Swarm to pool
+// connnections (see swarm pkg, and peerstream.Swarm). Connections
+// are encrypted with a TLS-like protocol.
+type Network interface {
+	Dialer
+	io.Closer
+
+	// SetStreamHandler sets the handler for new streams opened by the
+	// remote side. This operation is threadsafe.
+	SetStreamHandler(StreamHandler)
+
+	// SetConnHandler sets the handler for new connections opened by the
+	// remote side. This operation is threadsafe.
+	SetConnHandler(ConnHandler)
+
+	// NewStream returns a new stream to given peer p.
+	// If there is no connection to p, attempts to create one.
+	NewStream(context.Context, peer.ID) (Stream, error)
+
+	// Listen tells the network to start listening on given multiaddrs.
+	Listen(...ma.Multiaddr) error
+
+	// ListenAddresses returns a list of addresses at which this network listens.
+	ListenAddresses() []ma.Multiaddr
+
+	// InterfaceListenAddresses returns a list of addresses at which this network
+	// listens. It expands "any interface" addresses (/ip4/0.0.0.0, /ip6/::) to
+	// use the known local interfaces.
+	InterfaceListenAddresses() ([]ma.Multiaddr, error)
+
+	// Process returns the network's Process
+	Process() goprocess.Process
+}
+
+// Dialer represents a service that can dial out to peers
+// (this is usually just a Network, but other services may not need the whole
+// stack, and thus it becomes easier to mock)
+type Dialer interface {
+
+	// Peerstore returns the internal peerstore
+	// This is useful to tell the dialer about a new address for a peer.
+	// Or use one of the public keys found out over the network.
+	Peerstore() pstore.Peerstore
+
+	// LocalPeer returns the local peer associated with this network
+	LocalPeer() peer.ID
+
+	// DialPeer establishes a connection to a given peer
+	DialPeer(context.Context, peer.ID) (Conn, error)
+
+	// ClosePeer closes the connection to a given peer
+	ClosePeer(peer.ID) error
+
+	// Connectedness returns a state signaling connection capabilities
+	Connectedness(peer.ID) Connectedness
+
+	// Peers returns the peers connected
+	Peers() []peer.ID
+
+	// Conns returns the connections in this Netowrk
+	Conns() []Conn
+
+	// ConnsToPeer returns the connections in this Netowrk for given peer.
+	ConnsToPeer(p peer.ID) []Conn
+
+	// Notify/StopNotify register and unregister a notifiee for signals
+	Notify(Notifiee)
+	StopNotify(Notifiee)
+}
+
+// Connectedness signals the capacity for a connection with a given node.
+// It is used to signal to services and other peers whether a node is reachable.
+type Connectedness int
+
+const (
+	// NotConnected means no connection to peer, and no extra information (default)
+	NotConnected Connectedness = iota
+
+	// Connected means has an open, live connection to peer
+	Connected
+
+	// CanConnect means recently connected to peer, terminated gracefully
+	CanConnect
+
+	// CannotConnect means recently attempted connecting but failed to connect.
+	// (should signal "made effort, failed")
+	CannotConnect
+)
+
+// Notifiee is an interface for an object wishing to receive
+// notifications from a Network.
+type Notifiee interface {
+	Listen(Network, ma.Multiaddr)      // called when network starts listening on an addr
+	ListenClose(Network, ma.Multiaddr) // called when network starts listening on an addr
+	Connected(Network, Conn)           // called when a connection opened
+	Disconnected(Network, Conn)        // called when a connection closed
+	OpenedStream(Network, Stream)      // called when a stream opened
+	ClosedStream(Network, Stream)      // called when a stream closed
+
+	// TODO
+	// PeerConnected(Network, peer.ID)    // called when a peer connected
+	// PeerDisconnected(Network, peer.ID) // called when a peer disconnected
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-net/notifiee.go b/vendor/github.com/libp2p/go-libp2p-net/notifiee.go
new file mode 100644
index 000000000..0d61df4fa
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-net/notifiee.go
@@ -0,0 +1,57 @@
+package net
+
+import (
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// NotifyBundle implements Notifiee by calling any of the functions set on it,
+// and nop'ing if they are unset. This is the easy way to register for
+// notifications.
+type NotifyBundle struct {
+	ListenF      func(Network, ma.Multiaddr)
+	ListenCloseF func(Network, ma.Multiaddr)
+
+	ConnectedF    func(Network, Conn)
+	DisconnectedF func(Network, Conn)
+
+	OpenedStreamF func(Network, Stream)
+	ClosedStreamF func(Network, Stream)
+}
+
+var _ Notifiee = (*NotifyBundle)(nil)
+
+func (nb *NotifyBundle) Listen(n Network, a ma.Multiaddr) {
+	if nb.ListenF != nil {
+		nb.ListenF(n, a)
+	}
+}
+
+func (nb *NotifyBundle) ListenClose(n Network, a ma.Multiaddr) {
+	if nb.ListenCloseF != nil {
+		nb.ListenCloseF(n, a)
+	}
+}
+
+func (nb *NotifyBundle) Connected(n Network, c Conn) {
+	if nb.ConnectedF != nil {
+		nb.ConnectedF(n, c)
+	}
+}
+
+func (nb *NotifyBundle) Disconnected(n Network, c Conn) {
+	if nb.DisconnectedF != nil {
+		nb.DisconnectedF(n, c)
+	}
+}
+
+func (nb *NotifyBundle) OpenedStream(n Network, s Stream) {
+	if nb.OpenedStreamF != nil {
+		nb.OpenedStreamF(n, s)
+	}
+}
+
+func (nb *NotifyBundle) ClosedStream(n Network, s Stream) {
+	if nb.ClosedStreamF != nil {
+		nb.ClosedStreamF(n, s)
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-net/stream_util.go b/vendor/github.com/libp2p/go-libp2p-net/stream_util.go
new file mode 100644
index 000000000..762b8116e
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-net/stream_util.go
@@ -0,0 +1,54 @@
+package net
+
+import (
+	"errors"
+	"io"
+	"time"
+)
+
+// EOFTimeout is the maximum amount of time to wait to successfully observe an
+// EOF on the stream. Defaults to 60 seconds.
+var EOFTimeout = time.Second * 60
+
+// ErrExpectedEOF is returned when we read data while expecting an EOF.
+var ErrExpectedEOF = errors.New("read data when expecting EOF")
+
+// FullClose closes the stream and waits to read an EOF from the other side.
+//
+// * If it reads any data *before* the EOF, it resets the stream.
+// * If it doesn't read an EOF within EOFTimeout, it resets the stream.
+//
+// You'll likely want to invoke this as `go FullClose(stream)` to close the
+// stream in the background.
+func FullClose(s Stream) error {
+	if err := s.Close(); err != nil {
+		s.Reset()
+		return err
+	}
+	return AwaitEOF(s)
+}
+
+// AwaitEOF waits for an EOF on the given stream, returning an error if that
+// fails. It waits at most EOFTimeout (defaults to 1 minute) after which it
+// resets the stream.
+func AwaitEOF(s Stream) error {
+	// So we don't wait forever
+	s.SetDeadline(time.Now().Add(EOFTimeout))
+
+	// We *have* to observe the EOF. Otherwise, we leak the stream.
+	// Now, technically, we should do this *before*
+	// returning from SendMessage as the message
+	// hasn't really been sent yet until we see the
+	// EOF but we don't actually *know* what
+	// protocol the other side is speaking.
+	n, err := s.Read([]byte{0})
+	if n > 0 || err == nil {
+		s.Reset()
+		return ErrExpectedEOF
+	}
+	if err != io.EOF {
+		s.Reset()
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-net/timeouts.go b/vendor/github.com/libp2p/go-libp2p-net/timeouts.go
new file mode 100644
index 000000000..922232c08
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-net/timeouts.go
@@ -0,0 +1,29 @@
+package net
+
+import (
+	"context"
+	"time"
+)
+
+// DialPeerTimeout is the default timeout for a single call to `DialPeer`. When
+// there are multiple concurrent calls to `DialPeer`, this timeout will apply to
+// each independently.
+var DialPeerTimeout = 60 * time.Second
+
+type dialPeerTimeoutCtxKey struct{}
+
+// GetDialPeerTimeout returns the current DialPeer timeout (or the default).
+func GetDialPeerTimeout(ctx context.Context) time.Duration {
+	if to, ok := ctx.Value(dialPeerTimeoutCtxKey{}).(time.Duration); ok {
+		return to
+	}
+	return DialPeerTimeout
+}
+
+// WithDialPeerTimeout returns a new context with the DialPeer timeout applied.
+//
+// This timeout overrides the default DialPeerTimeout and applies per-dial
+// independently.
+func WithDialPeerTimeout(ctx context.Context, timeout time.Duration) context.Context {
+	return context.WithValue(ctx, dialPeerTimeoutCtxKey{}, timeout)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peer/LICENSE b/vendor/github.com/libp2p/go-libp2p-peer/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-peer/peer.go b/vendor/github.com/libp2p/go-libp2p-peer/peer.go
new file mode 100644
index 000000000..14337745b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peer/peer.go
@@ -0,0 +1,165 @@
+// package peer implements an object used to represent peers in the ipfs network.
+package peer
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	logging "github.com/ipfs/go-log" // ID represents the identity of a peer.
+	ic "github.com/libp2p/go-libp2p-crypto"
+	b58 "github.com/mr-tron/base58/base58"
+	mh "github.com/multiformats/go-multihash"
+)
+
+// MaxInlineKeyLength is the maximum length a key can be for it to be inlined in
+// the peer ID.
+//
+// * When `len(pubKey.Bytes()) <= MaxInlineKeyLength`, the peer ID is the
+//   identity multihash hash of the public key.
+// * When `len(pubKey.Bytes()) > MaxInlineKeyLength`, the peer ID is the
+//   sha2-256 multihash of the public key.
+const MaxInlineKeyLength = 42
+
+var log = logging.Logger("peer")
+
+// ID is a libp2p peer identity.
+type ID string
+
+// Pretty returns a b58-encoded string of the ID
+func (id ID) Pretty() string {
+	return IDB58Encode(id)
+}
+
+func (id ID) Loggable() map[string]interface{} {
+	return map[string]interface{}{
+		"peerID": id.Pretty(),
+	}
+}
+
+// String prints out the peer.
+//
+// TODO(brian): ensure correctness at ID generation and
+// enforce this by only exposing functions that generate
+// IDs safely. Then any peer.ID type found in the
+// codebase is known to be correct.
+func (id ID) String() string {
+	pid := id.Pretty()
+
+	//All sha256 nodes start with Qm
+	//We can skip the Qm to make the peer.ID more useful
+	if strings.HasPrefix(pid, "Qm") {
+		pid = pid[2:]
+	}
+
+	maxRunes := 6
+	if len(pid) < maxRunes {
+		maxRunes = len(pid)
+	}
+	return fmt.Sprintf("<peer.ID %s>", pid[:maxRunes])
+}
+
+// MatchesPrivateKey tests whether this ID was derived from sk
+func (id ID) MatchesPrivateKey(sk ic.PrivKey) bool {
+	return id.MatchesPublicKey(sk.GetPublic())
+}
+
+// MatchesPublicKey tests whether this ID was derived from pk
+func (id ID) MatchesPublicKey(pk ic.PubKey) bool {
+	oid, err := IDFromPublicKey(pk)
+	if err != nil {
+		return false
+	}
+	return oid == id
+}
+
+// ExtractPublicKey attempts to extract the public key from an ID
+//
+// This method returns nil, nil if the peer ID looks valid but it can't extract
+// the public key.
+func (id ID) ExtractPublicKey() (ic.PubKey, error) {
+	decoded, err := mh.Decode([]byte(id))
+	if err != nil {
+		return nil, err
+	}
+	if decoded.Code != mh.ID {
+		return nil, nil
+	}
+	pk, err := ic.UnmarshalPublicKey(decoded.Digest)
+	if err != nil {
+		return nil, err
+	}
+	return pk, nil
+}
+
+// IDFromString cast a string to ID type, and validate
+// the id to make sure it is a multihash.
+func IDFromString(s string) (ID, error) {
+	if _, err := mh.Cast([]byte(s)); err != nil {
+		return ID(""), err
+	}
+	return ID(s), nil
+}
+
+// IDFromBytes cast a string to ID type, and validate
+// the id to make sure it is a multihash.
+func IDFromBytes(b []byte) (ID, error) {
+	if _, err := mh.Cast(b); err != nil {
+		return ID(""), err
+	}
+	return ID(b), nil
+}
+
+// IDB58Decode returns a b58-decoded Peer
+func IDB58Decode(s string) (ID, error) {
+	m, err := mh.FromB58String(s)
+	if err != nil {
+		return "", err
+	}
+	return ID(m), err
+}
+
+// IDB58Encode returns b58-encoded string
+func IDB58Encode(id ID) string {
+	return b58.Encode([]byte(id))
+}
+
+// IDHexDecode returns a hex-decoded Peer
+func IDHexDecode(s string) (ID, error) {
+	m, err := mh.FromHexString(s)
+	if err != nil {
+		return "", err
+	}
+	return ID(m), err
+}
+
+// IDHexEncode returns hex-encoded string
+func IDHexEncode(id ID) string {
+	return hex.EncodeToString([]byte(id))
+}
+
+// IDFromPublicKey returns the Peer ID corresponding to pk
+func IDFromPublicKey(pk ic.PubKey) (ID, error) {
+	b, err := pk.Bytes()
+	if err != nil {
+		return "", err
+	}
+	var alg uint64 = mh.SHA2_256
+	if len(b) <= MaxInlineKeyLength {
+		alg = mh.ID
+	}
+	hash, _ := mh.Sum(b, alg, -1)
+	return ID(hash), nil
+}
+
+// IDFromPrivateKey returns the Peer ID corresponding to sk
+func IDFromPrivateKey(sk ic.PrivKey) (ID, error) {
+	return IDFromPublicKey(sk.GetPublic())
+}
+
+// IDSlice for sorting peers
+type IDSlice []ID
+
+func (es IDSlice) Len() int           { return len(es) }
+func (es IDSlice) Swap(i, j int)      { es[i], es[j] = es[j], es[i] }
+func (es IDSlice) Less(i, j int) bool { return string(es[i]) < string(es[j]) }
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/LICENSE b/vendor/github.com/libp2p/go-libp2p-peerstore/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/addr/addrsrcs.go b/vendor/github.com/libp2p/go-libp2p-peerstore/addr/addrsrcs.go
new file mode 100644
index 000000000..9be78d5cc
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/addr/addrsrcs.go
@@ -0,0 +1,70 @@
+// Package addr provides utility functions to handle peer addresses.
+package addr
+
+import (
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// AddrSource is a source of addresses. It allows clients to retrieve
+// a set of addresses at a last possible moment in time. It is used
+// to query a set of addresses that may change over time, as a result
+// of the network changing interfaces or mappings.
+type Source interface {
+	Addrs() []ma.Multiaddr
+}
+
+// CombineSources returns a new AddrSource which is the
+// concatenation of all input AddrSources:
+//
+//   combined := CombinedSources(a, b)
+//   combined.Addrs() // append(a.Addrs(), b.Addrs()...)
+//
+func CombineSources(srcs ...Source) Source {
+	return combinedAS(srcs)
+}
+
+type combinedAS []Source
+
+func (cas combinedAS) Addrs() []ma.Multiaddr {
+	var addrs []ma.Multiaddr
+	for _, s := range cas {
+		addrs = append(addrs, s.Addrs()...)
+	}
+	return addrs
+}
+
+// UniqueSource returns a new AddrSource which omits duplicate
+// addresses from the inputs:
+//
+//   unique := UniqueSource(a, b)
+//   unique.Addrs() // append(a.Addrs(), b.Addrs()...)
+//                  // but only adds each addr once.
+//
+func UniqueSource(srcs ...Source) Source {
+	return uniqueAS(srcs)
+}
+
+type uniqueAS []Source
+
+func (uas uniqueAS) Addrs() []ma.Multiaddr {
+	seen := make(map[string]struct{})
+	var addrs []ma.Multiaddr
+	for _, s := range uas {
+		for _, a := range s.Addrs() {
+			s := a.String()
+			if _, found := seen[s]; !found {
+				addrs = append(addrs, a)
+				seen[s] = struct{}{}
+			}
+		}
+	}
+	return addrs
+}
+
+// Slice is a simple slice of addresses that implements
+// the AddrSource interface.
+type Slice []ma.Multiaddr
+
+func (as Slice) Addrs() []ma.Multiaddr {
+	return as
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/addr/sorting.go b/vendor/github.com/libp2p/go-libp2p-peerstore/addr/sorting.go
new file mode 100644
index 000000000..f8a89150a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/addr/sorting.go
@@ -0,0 +1,62 @@
+package addr
+
+import (
+	"bytes"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+	mafmt "github.com/whyrusleeping/mafmt"
+)
+
+func isFDCostlyTransport(a ma.Multiaddr) bool {
+	return mafmt.TCP.Matches(a)
+}
+
+type AddrList []ma.Multiaddr
+
+func (al AddrList) Len() int {
+	return len(al)
+}
+
+func (al AddrList) Swap(i, j int) {
+	al[i], al[j] = al[j], al[i]
+}
+
+func (al AddrList) Less(i, j int) bool {
+	a := al[i]
+	b := al[j]
+
+	// dial localhost addresses next, they should fail immediately
+	lba := manet.IsIPLoopback(a)
+	lbb := manet.IsIPLoopback(b)
+	if lba {
+		if !lbb {
+			return true
+		}
+	}
+
+	// dial utp and similar 'non-fd-consuming' addresses first
+	fda := isFDCostlyTransport(a)
+	fdb := isFDCostlyTransport(b)
+	if !fda {
+		if fdb {
+			return true
+		}
+
+		// if neither consume fd's, assume equal ordering
+		return false
+	}
+
+	// if 'b' doesnt take a file descriptor
+	if !fdb {
+		return false
+	}
+
+	// if 'b' is loopback and both take file descriptors
+	if lbb {
+		return false
+	}
+
+	// for the rest, just sort by bytes
+	return bytes.Compare(a.Bytes(), b.Bytes()) > 0
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/addr_manager.go b/vendor/github.com/libp2p/go-libp2p-peerstore/addr_manager.go
new file mode 100644
index 000000000..8b06c484d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/addr_manager.go
@@ -0,0 +1,362 @@
+package peerstore
+
+import (
+	"context"
+	"math"
+	"sort"
+	"sync"
+	"time"
+
+	peer "github.com/libp2p/go-libp2p-peer"
+	addr "github.com/libp2p/go-libp2p-peerstore/addr"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var (
+
+	// TempAddrTTL is the ttl used for a short lived address
+	TempAddrTTL = time.Second * 10
+
+	// ProviderAddrTTL is the TTL of an address we've received from a provider.
+	// This is also a temporary address, but lasts longer. After this expires,
+	// the records we return will require an extra lookup.
+	ProviderAddrTTL = time.Minute * 10
+
+	// RecentlyConnectedAddrTTL is used when we recently connected to a peer.
+	// It means that we are reasonably certain of the peer's address.
+	RecentlyConnectedAddrTTL = time.Minute * 10
+
+	// OwnObservedAddrTTL is used for our own external addresses observed by peers.
+	OwnObservedAddrTTL = time.Minute * 10
+)
+
+// Permanent TTLs (distinct so we can distinguish between them, constant as they
+// are, in fact, permanent)
+const (
+	// PermanentAddrTTL is the ttl for a "permanent address" (e.g. bootstrap nodes).
+	PermanentAddrTTL = math.MaxInt64 - iota
+
+	// ConnectedAddrTTL is the ttl used for the addresses of a peer to whom
+	// we're connected directly. This is basically permanent, as we will
+	// clear them + re-add under a TempAddrTTL after disconnecting.
+	ConnectedAddrTTL
+)
+
+type expiringAddr struct {
+	Addr    ma.Multiaddr
+	TTL     time.Duration
+	Expires time.Time
+}
+
+func (e *expiringAddr) ExpiredBy(t time.Time) bool {
+	return t.After(e.Expires)
+}
+
+type addrSlice []expiringAddr
+
+// AddrManager manages addresses.
+// The zero-value is ready to be used.
+type AddrManager struct {
+	addrmu sync.Mutex // guards addrs
+	addrs  map[peer.ID]addrSlice
+
+	addrSubs map[peer.ID][]*addrSub
+}
+
+// ensures the AddrManager is initialized.
+// So we can use the zero value.
+func (mgr *AddrManager) init() {
+	if mgr.addrs == nil {
+		mgr.addrs = make(map[peer.ID]addrSlice)
+	}
+	if mgr.addrSubs == nil {
+		mgr.addrSubs = make(map[peer.ID][]*addrSub)
+	}
+}
+
+func (mgr *AddrManager) Peers() []peer.ID {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+	if mgr.addrs == nil {
+		return nil
+	}
+
+	pids := make([]peer.ID, 0, len(mgr.addrs))
+	for pid := range mgr.addrs {
+		pids = append(pids, pid)
+	}
+	return pids
+}
+
+// AddAddr calls AddAddrs(p, []ma.Multiaddr{addr}, ttl)
+func (mgr *AddrManager) AddAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration) {
+	mgr.AddAddrs(p, []ma.Multiaddr{addr}, ttl)
+}
+
+// AddAddrs gives AddrManager addresses to use, with a given ttl
+// (time-to-live), after which the address is no longer valid.
+// If the manager has a longer TTL, the operation is a no-op for that address
+func (mgr *AddrManager) AddAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration) {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+
+	// if ttl is zero, exit. nothing to do.
+	if ttl <= 0 {
+		return
+	}
+
+	// so zero value can be used
+	mgr.init()
+
+	oldAddrs := mgr.addrs[p]
+	amap := make(map[string]expiringAddr, len(oldAddrs))
+	for _, ea := range oldAddrs {
+		amap[string(ea.Addr.Bytes())] = ea
+	}
+
+	subs := mgr.addrSubs[p]
+
+	// only expand ttls
+	exp := time.Now().Add(ttl)
+	for _, addr := range addrs {
+		if addr == nil {
+			log.Warningf("was passed nil multiaddr for %s", p)
+			continue
+		}
+
+		addrstr := string(addr.Bytes())
+		a, found := amap[addrstr]
+		if !found || exp.After(a.Expires) {
+			amap[addrstr] = expiringAddr{Addr: addr, Expires: exp, TTL: ttl}
+
+			for _, sub := range subs {
+				sub.pubAddr(addr)
+			}
+		}
+	}
+	newAddrs := make([]expiringAddr, 0, len(amap))
+	for _, ea := range amap {
+		newAddrs = append(newAddrs, ea)
+	}
+	mgr.addrs[p] = newAddrs
+}
+
+// SetAddr calls mgr.SetAddrs(p, addr, ttl)
+func (mgr *AddrManager) SetAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration) {
+	mgr.SetAddrs(p, []ma.Multiaddr{addr}, ttl)
+}
+
+// SetAddrs sets the ttl on addresses. This clears any TTL there previously.
+// This is used when we receive the best estimate of the validity of an address.
+func (mgr *AddrManager) SetAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration) {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+
+	// so zero value can be used
+	mgr.init()
+
+	oldAddrs := mgr.addrs[p]
+	amap := make(map[string]expiringAddr, len(oldAddrs))
+	for _, ea := range oldAddrs {
+		amap[string(ea.Addr.Bytes())] = ea
+	}
+
+	subs := mgr.addrSubs[p]
+
+	exp := time.Now().Add(ttl)
+	for _, addr := range addrs {
+		if addr == nil {
+			log.Warningf("was passed nil multiaddr for %s", p)
+			continue
+		}
+		// re-set all of them for new ttl.
+		addrs := string(addr.Bytes())
+
+		if ttl > 0 {
+			amap[addrs] = expiringAddr{Addr: addr, Expires: exp, TTL: ttl}
+
+			for _, sub := range subs {
+				sub.pubAddr(addr)
+			}
+		} else {
+			delete(amap, addrs)
+		}
+	}
+	newAddrs := make([]expiringAddr, 0, len(amap))
+	for _, ea := range amap {
+		newAddrs = append(newAddrs, ea)
+	}
+	mgr.addrs[p] = newAddrs
+}
+
+// UpdateAddrs updates the addresses associated with the given peer that have
+// the given oldTTL to have the given newTTL.
+func (mgr *AddrManager) UpdateAddrs(p peer.ID, oldTTL time.Duration, newTTL time.Duration) {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+
+	if mgr.addrs == nil {
+		return
+	}
+
+	addrs, found := mgr.addrs[p]
+	if !found {
+		return
+	}
+
+	exp := time.Now().Add(newTTL)
+	for i := range addrs {
+		aexp := &addrs[i]
+		if oldTTL == aexp.TTL {
+			aexp.TTL = newTTL
+			aexp.Expires = exp
+		}
+	}
+}
+
+// Addresses returns all known (and valid) addresses for a given
+func (mgr *AddrManager) Addrs(p peer.ID) []ma.Multiaddr {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+
+	// not initialized? nothing to give.
+	if mgr.addrs == nil {
+		return nil
+	}
+
+	maddrs, found := mgr.addrs[p]
+	if !found {
+		return nil
+	}
+
+	now := time.Now()
+	good := make([]ma.Multiaddr, 0, len(maddrs))
+	cleaned := make([]expiringAddr, 0, len(maddrs))
+	for _, m := range maddrs {
+		if !m.ExpiredBy(now) {
+			cleaned = append(cleaned, m)
+			good = append(good, m.Addr)
+		}
+	}
+
+	// clean up the expired ones.
+	if len(cleaned) == 0 {
+		delete(mgr.addrs, p)
+	} else {
+		mgr.addrs[p] = cleaned
+	}
+	return good
+}
+
+// ClearAddresses removes all previously stored addresses
+func (mgr *AddrManager) ClearAddrs(p peer.ID) {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+	mgr.init()
+
+	delete(mgr.addrs, p)
+}
+
+func (mgr *AddrManager) removeSub(p peer.ID, s *addrSub) {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+	subs := mgr.addrSubs[p]
+	if len(subs) == 1 {
+		if subs[0] != s {
+			return
+		}
+		delete(mgr.addrSubs, p)
+		return
+	}
+	for i, v := range subs {
+		if v == s {
+			subs[i] = subs[len(subs)-1]
+			subs[len(subs)-1] = nil
+			mgr.addrSubs[p] = subs[:len(subs)-1]
+			return
+		}
+	}
+}
+
+type addrSub struct {
+	pubch  chan ma.Multiaddr
+	lk     sync.Mutex
+	buffer []ma.Multiaddr
+	ctx    context.Context
+}
+
+func (s *addrSub) pubAddr(a ma.Multiaddr) {
+	select {
+	case s.pubch <- a:
+	case <-s.ctx.Done():
+	}
+}
+
+func (mgr *AddrManager) AddrStream(ctx context.Context, p peer.ID) <-chan ma.Multiaddr {
+	mgr.addrmu.Lock()
+	defer mgr.addrmu.Unlock()
+	mgr.init()
+
+	sub := &addrSub{pubch: make(chan ma.Multiaddr), ctx: ctx}
+
+	out := make(chan ma.Multiaddr)
+
+	mgr.addrSubs[p] = append(mgr.addrSubs[p], sub)
+
+	baseaddrslice := mgr.addrs[p]
+	initial := make([]ma.Multiaddr, 0, len(baseaddrslice))
+	for _, a := range baseaddrslice {
+		initial = append(initial, a.Addr)
+	}
+
+	sort.Sort(addr.AddrList(initial))
+
+	go func(buffer []ma.Multiaddr) {
+		defer close(out)
+
+		sent := make(map[string]bool, len(buffer))
+		var outch chan ma.Multiaddr
+
+		for _, a := range buffer {
+			sent[string(a.Bytes())] = true
+		}
+
+		var next ma.Multiaddr
+		if len(buffer) > 0 {
+			next = buffer[0]
+			buffer = buffer[1:]
+			outch = out
+		}
+
+		for {
+			select {
+			case outch <- next:
+				if len(buffer) > 0 {
+					next = buffer[0]
+					buffer = buffer[1:]
+				} else {
+					outch = nil
+					next = nil
+				}
+			case naddr := <-sub.pubch:
+				if sent[string(naddr.Bytes())] {
+					continue
+				}
+
+				sent[string(naddr.Bytes())] = true
+				if next == nil {
+					next = naddr
+					outch = out
+				} else {
+					buffer = append(buffer, naddr)
+				}
+			case <-ctx.Done():
+				mgr.removeSub(p, sub)
+				return
+			}
+		}
+
+	}(initial)
+
+	return out
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/metrics.go b/vendor/github.com/libp2p/go-libp2p-peerstore/metrics.go
new file mode 100644
index 000000000..05b867692
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/metrics.go
@@ -0,0 +1,65 @@
+package peerstore
+
+import (
+	"sync"
+	"time"
+
+	"github.com/libp2p/go-libp2p-peer"
+)
+
+// LatencyEWMASmooting governs the decay of the EWMA (the speed
+// at which it changes). This must be a normalized (0-1) value.
+// 1 is 100% change, 0 is no change.
+var LatencyEWMASmoothing = 0.1
+
+// Metrics is just an object that tracks metrics
+// across a set of peers.
+type Metrics interface {
+
+	// RecordLatency records a new latency measurement
+	RecordLatency(peer.ID, time.Duration)
+
+	// LatencyEWMA returns an exponentially-weighted moving avg.
+	// of all measurements of a peer's latency.
+	LatencyEWMA(peer.ID) time.Duration
+}
+
+type metrics struct {
+	latmap map[peer.ID]time.Duration
+	latmu  sync.RWMutex
+}
+
+func NewMetrics() *metrics {
+	return &metrics{
+		latmap: make(map[peer.ID]time.Duration),
+	}
+}
+
+// RecordLatency records a new latency measurement
+func (m *metrics) RecordLatency(p peer.ID, next time.Duration) {
+	nextf := float64(next)
+	s := LatencyEWMASmoothing
+	if s > 1 || s < 0 {
+		s = 0.1 // ignore the knob. it's broken. look, it jiggles.
+	}
+
+	m.latmu.Lock()
+	ewma, found := m.latmap[p]
+	ewmaf := float64(ewma)
+	if !found {
+		m.latmap[p] = next // when no data, just take it as the mean.
+	} else {
+		nextf = ((1.0 - s) * ewmaf) + (s * nextf)
+		m.latmap[p] = time.Duration(nextf)
+	}
+	m.latmu.Unlock()
+}
+
+// LatencyEWMA returns an exponentially-weighted moving avg.
+// of all measurements of a peer's latency.
+func (m *metrics) LatencyEWMA(p peer.ID) time.Duration {
+	m.latmu.RLock()
+	lat := m.latmap[p]
+	m.latmu.RUnlock()
+	return time.Duration(lat)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/peerinfo.go b/vendor/github.com/libp2p/go-libp2p-peerstore/peerinfo.go
new file mode 100644
index 000000000..cb216264b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/peerinfo.go
@@ -0,0 +1,109 @@
+package peerstore
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// PeerInfo is a small struct used to pass around a peer with
+// a set of addresses (and later, keys?). This is not meant to be
+// a complete view of the system, but rather to model updates to
+// the peerstore. It is used by things like the routing system.
+type PeerInfo struct {
+	ID    peer.ID
+	Addrs []ma.Multiaddr
+}
+
+var ErrInvalidAddr = fmt.Errorf("invalid p2p multiaddr")
+
+func InfoFromP2pAddr(m ma.Multiaddr) (*PeerInfo, error) {
+	if m == nil {
+		return nil, ErrInvalidAddr
+	}
+
+	// make sure it's an IPFS addr
+	parts := ma.Split(m)
+	if len(parts) < 1 {
+		return nil, ErrInvalidAddr
+	}
+
+	// TODO(lgierth): we shouldn't assume /ipfs is the last part
+	ipfspart := parts[len(parts)-1]
+	if ipfspart.Protocols()[0].Code != ma.P_IPFS {
+		return nil, ErrInvalidAddr
+	}
+
+	// make sure the /ipfs value parses as a peer.ID
+	peerIdParts := strings.Split(ipfspart.String(), "/")
+	peerIdStr := peerIdParts[len(peerIdParts)-1]
+	id, err := peer.IDB58Decode(peerIdStr)
+	if err != nil {
+		return nil, err
+	}
+
+	// we might have received just an /ipfs part, which means there's no addr.
+	var addrs []ma.Multiaddr
+	if len(parts) > 1 {
+		addrs = append(addrs, ma.Join(parts[:len(parts)-1]...))
+	}
+
+	return &PeerInfo{
+		ID:    id,
+		Addrs: addrs,
+	}, nil
+}
+
+func InfoToP2pAddrs(pi *PeerInfo) ([]ma.Multiaddr, error) {
+	addrs := []ma.Multiaddr{}
+	tpl := "/" + ma.ProtocolWithCode(ma.P_IPFS).Name + "/"
+	for _, addr := range pi.Addrs {
+		p2paddr, err := ma.NewMultiaddr(tpl + peer.IDB58Encode(pi.ID))
+		if err != nil {
+			return nil, err
+		}
+		addrs = append(addrs, addr.Encapsulate(p2paddr))
+	}
+	return addrs, nil
+}
+
+func (pi *PeerInfo) Loggable() map[string]interface{} {
+	return map[string]interface{}{
+		"peerID": pi.ID.Pretty(),
+		"addrs":  pi.Addrs,
+	}
+}
+
+func (pi *PeerInfo) MarshalJSON() ([]byte, error) {
+	out := make(map[string]interface{})
+	out["ID"] = pi.ID.Pretty()
+	var addrs []string
+	for _, a := range pi.Addrs {
+		addrs = append(addrs, a.String())
+	}
+	out["Addrs"] = addrs
+	return json.Marshal(out)
+}
+
+func (pi *PeerInfo) UnmarshalJSON(b []byte) error {
+	var data map[string]interface{}
+	err := json.Unmarshal(b, &data)
+	if err != nil {
+		return err
+	}
+	pid, err := peer.IDB58Decode(data["ID"].(string))
+	if err != nil {
+		return err
+	}
+	pi.ID = pid
+	addrs, ok := data["Addrs"].([]interface{})
+	if ok {
+		for _, a := range addrs {
+			pi.Addrs = append(pi.Addrs, ma.StringCast(a.(string)))
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-peerstore/peerstore.go b/vendor/github.com/libp2p/go-libp2p-peerstore/peerstore.go
new file mode 100644
index 000000000..abfdeae6d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-peerstore/peerstore.go
@@ -0,0 +1,344 @@
+package peerstore
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	ic "github.com/libp2p/go-libp2p-crypto"
+
+	//ds "github.com/jbenet/go-datastore"
+	//dssync "github.com/jbenet/go-datastore/sync"
+	logging "github.com/ipfs/go-log"
+	"github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var log = logging.Logger("peerstore")
+
+const (
+	// AddressTTL is the expiration time of addresses.
+	AddressTTL = time.Hour
+)
+
+// Peerstore provides a threadsafe store of Peer related
+// information.
+type Peerstore interface {
+	AddrBook
+	KeyBook
+	Metrics
+
+	// Peers returns a list of all peer.IDs in this Peerstore
+	Peers() []peer.ID
+
+	// PeerInfo returns a peer.PeerInfo struct for given peer.ID.
+	// This is a small slice of the information Peerstore has on
+	// that peer, useful to other services.
+	PeerInfo(peer.ID) PeerInfo
+
+	// Get/Put is a simple registry for other peer-related key/value pairs.
+	// if we find something we use often, it should become its own set of
+	// methods. this is a last resort.
+	Get(id peer.ID, key string) (interface{}, error)
+	Put(id peer.ID, key string, val interface{}) error
+
+	GetProtocols(peer.ID) ([]string, error)
+	AddProtocols(peer.ID, ...string) error
+	SetProtocols(peer.ID, ...string) error
+	SupportsProtocols(peer.ID, ...string) ([]string, error)
+}
+
+// AddrBook is an interface that fits the new AddrManager. I'm patching
+// it up in here to avoid changing a ton of the codebase.
+type AddrBook interface {
+
+	// AddAddr calls AddAddrs(p, []ma.Multiaddr{addr}, ttl)
+	AddAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration)
+
+	// AddAddrs gives AddrManager addresses to use, with a given ttl
+	// (time-to-live), after which the address is no longer valid.
+	// If the manager has a longer TTL, the operation is a no-op for that address
+	AddAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration)
+
+	// SetAddr calls mgr.SetAddrs(p, addr, ttl)
+	SetAddr(p peer.ID, addr ma.Multiaddr, ttl time.Duration)
+
+	// SetAddrs sets the ttl on addresses. This clears any TTL there previously.
+	// This is used when we receive the best estimate of the validity of an address.
+	SetAddrs(p peer.ID, addrs []ma.Multiaddr, ttl time.Duration)
+
+	// UpdateAddrs updates the addresses associated with the given peer that have
+	// the given oldTTL to have the given newTTL.
+	UpdateAddrs(p peer.ID, oldTTL time.Duration, newTTL time.Duration)
+
+	// Addresses returns all known (and valid) addresses for a given peer
+	Addrs(p peer.ID) []ma.Multiaddr
+
+	// AddrStream returns a channel that gets all addresses for a given
+	// peer sent on it. If new addresses are added after the call is made
+	// they will be sent along through the channel as well.
+	AddrStream(context.Context, peer.ID) <-chan ma.Multiaddr
+
+	// ClearAddresses removes all previously stored addresses
+	ClearAddrs(p peer.ID)
+}
+
+// KeyBook tracks the Public keys of Peers.
+type KeyBook interface {
+	PubKey(peer.ID) ic.PubKey
+	AddPubKey(peer.ID, ic.PubKey) error
+
+	PrivKey(peer.ID) ic.PrivKey
+	AddPrivKey(peer.ID, ic.PrivKey) error
+}
+
+type keybook struct {
+	pks map[peer.ID]ic.PubKey
+	sks map[peer.ID]ic.PrivKey
+
+	sync.RWMutex // same lock. wont happen a ton.
+}
+
+func newKeybook() *keybook {
+	return &keybook{
+		pks: map[peer.ID]ic.PubKey{},
+		sks: map[peer.ID]ic.PrivKey{},
+	}
+}
+
+func (kb *keybook) Peers() []peer.ID {
+	kb.RLock()
+	ps := make([]peer.ID, 0, len(kb.pks)+len(kb.sks))
+	for p := range kb.pks {
+		ps = append(ps, p)
+	}
+	for p := range kb.sks {
+		if _, found := kb.pks[p]; !found {
+			ps = append(ps, p)
+		}
+	}
+	kb.RUnlock()
+	return ps
+}
+
+func (kb *keybook) PubKey(p peer.ID) ic.PubKey {
+	kb.RLock()
+	pk := kb.pks[p]
+	kb.RUnlock()
+	if pk != nil {
+		return pk
+	}
+	pk, err := p.ExtractPublicKey()
+	if err == nil && pk != nil {
+		kb.Lock()
+		kb.pks[p] = pk
+		kb.Unlock()
+	}
+	return pk
+}
+
+func (kb *keybook) AddPubKey(p peer.ID, pk ic.PubKey) error {
+
+	// check it's correct first
+	if !p.MatchesPublicKey(pk) {
+		return errors.New("ID does not match PublicKey")
+	}
+
+	kb.Lock()
+	kb.pks[p] = pk
+	kb.Unlock()
+	return nil
+}
+
+func (kb *keybook) PrivKey(p peer.ID) ic.PrivKey {
+	kb.RLock()
+	sk := kb.sks[p]
+	kb.RUnlock()
+	return sk
+}
+
+func (kb *keybook) AddPrivKey(p peer.ID, sk ic.PrivKey) error {
+
+	if sk == nil {
+		return errors.New("sk is nil (PrivKey)")
+	}
+
+	// check it's correct first
+	if !p.MatchesPrivateKey(sk) {
+		return errors.New("ID does not match PrivateKey")
+	}
+
+	kb.Lock()
+	kb.sks[p] = sk
+	kb.Unlock()
+	return nil
+}
+
+type peerstore struct {
+	*keybook
+	*metrics
+	AddrManager
+
+	// store other data, like versions
+	//ds ds.ThreadSafeDatastore
+	// TODO: use a datastore for this
+	ds     map[string]interface{}
+	dslock sync.Mutex
+
+	// lock for protocol information, separate from datastore lock
+	protolock sync.Mutex
+}
+
+// NewPeerstore creates a threadsafe collection of peers.
+func NewPeerstore() Peerstore {
+	return &peerstore{
+		keybook:     newKeybook(),
+		metrics:     NewMetrics(),
+		AddrManager: AddrManager{},
+		//ds:          dssync.MutexWrap(ds.NewMapDatastore()),
+		ds: make(map[string]interface{}),
+	}
+}
+
+func (ps *peerstore) Put(p peer.ID, key string, val interface{}) error {
+	//dsk := ds.NewKey(string(p) + "/" + key)
+	//return ps.ds.Put(dsk, val)
+	ps.dslock.Lock()
+	defer ps.dslock.Unlock()
+	ps.ds[string(p)+"/"+key] = val
+	return nil
+}
+
+var ErrNotFound = errors.New("item not found")
+
+func (ps *peerstore) Get(p peer.ID, key string) (interface{}, error) {
+	//dsk := ds.NewKey(string(p) + "/" + key)
+	//return ps.ds.Get(dsk)
+
+	ps.dslock.Lock()
+	defer ps.dslock.Unlock()
+	i, ok := ps.ds[string(p)+"/"+key]
+	if !ok {
+		return nil, ErrNotFound
+	}
+	return i, nil
+}
+
+func (ps *peerstore) Peers() []peer.ID {
+	set := map[peer.ID]struct{}{}
+	for _, p := range ps.keybook.Peers() {
+		set[p] = struct{}{}
+	}
+	for _, p := range ps.AddrManager.Peers() {
+		set[p] = struct{}{}
+	}
+
+	pps := make([]peer.ID, 0, len(set))
+	for p := range set {
+		pps = append(pps, p)
+	}
+	return pps
+}
+
+func (ps *peerstore) PeerInfo(p peer.ID) PeerInfo {
+	return PeerInfo{
+		ID:    p,
+		Addrs: ps.AddrManager.Addrs(p),
+	}
+}
+
+func (ps *peerstore) SetProtocols(p peer.ID, protos ...string) error {
+	ps.protolock.Lock()
+	defer ps.protolock.Unlock()
+
+	protomap := make(map[string]struct{})
+	for _, proto := range protos {
+		protomap[proto] = struct{}{}
+	}
+
+	return ps.Put(p, "protocols", protomap)
+}
+
+func (ps *peerstore) AddProtocols(p peer.ID, protos ...string) error {
+	ps.protolock.Lock()
+	defer ps.protolock.Unlock()
+	protomap, err := ps.getProtocolMap(p)
+	if err != nil {
+		return err
+	}
+
+	for _, proto := range protos {
+		protomap[proto] = struct{}{}
+	}
+
+	return ps.Put(p, "protocols", protomap)
+}
+
+func (ps *peerstore) getProtocolMap(p peer.ID) (map[string]struct{}, error) {
+	iprotomap, err := ps.Get(p, "protocols")
+	switch err {
+	default:
+		return nil, err
+	case ErrNotFound:
+		return make(map[string]struct{}), nil
+	case nil:
+		cast, ok := iprotomap.(map[string]struct{})
+		if !ok {
+			return nil, fmt.Errorf("stored protocol set was not a map")
+		}
+
+		return cast, nil
+	}
+}
+
+func (ps *peerstore) GetProtocols(p peer.ID) ([]string, error) {
+	ps.protolock.Lock()
+	defer ps.protolock.Unlock()
+	pmap, err := ps.getProtocolMap(p)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []string
+	for k, _ := range pmap {
+		out = append(out, k)
+	}
+
+	return out, nil
+}
+
+func (ps *peerstore) SupportsProtocols(p peer.ID, protos ...string) ([]string, error) {
+	ps.protolock.Lock()
+	defer ps.protolock.Unlock()
+	pmap, err := ps.getProtocolMap(p)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []string
+	for _, proto := range protos {
+		if _, ok := pmap[proto]; ok {
+			out = append(out, proto)
+		}
+	}
+
+	return out, nil
+}
+
+func PeerInfos(ps Peerstore, peers []peer.ID) []PeerInfo {
+	pi := make([]PeerInfo, len(peers))
+	for i, p := range peers {
+		pi[i] = ps.PeerInfo(p)
+	}
+	return pi
+}
+
+func PeerInfoIDs(pis []PeerInfo) []peer.ID {
+	ps := make([]peer.ID, len(pis))
+	for i, pi := range pis {
+		ps[i] = pi.ID
+	}
+	return ps
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-protocol/protocol.go b/vendor/github.com/libp2p/go-libp2p-protocol/protocol.go
new file mode 100644
index 000000000..f7e4a32ba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-protocol/protocol.go
@@ -0,0 +1,9 @@
+package protocol
+
+// ID is an identifier used to write protocol headers in streams.
+type ID string
+
+// These are reserved protocol.IDs.
+const (
+	TestingID ID = "/p2p/_testing"
+)
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/LICENSE b/vendor/github.com/libp2p/go-libp2p-secio/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/al.go b/vendor/github.com/libp2p/go-libp2p-secio/al.go
new file mode 100644
index 000000000..7f557d282
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/al.go
@@ -0,0 +1,122 @@
+package secio
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hmac"
+	"crypto/sha1"
+	"crypto/sha512"
+	"hash"
+
+	ci "github.com/libp2p/go-libp2p-crypto"
+	sha256 "github.com/minio/sha256-simd"
+	bfish "golang.org/x/crypto/blowfish"
+)
+
+// SupportedExchanges is the list of supported ECDH curves
+var SupportedExchanges = DefaultSupportedExchanges
+
+const DefaultSupportedExchanges = "P-256,P-384,P-521"
+
+// SupportedCiphers is the list of supported Ciphers
+var SupportedCiphers = DefaultSupportedCiphers
+
+const DefaultSupportedCiphers = "AES-256,AES-128,Blowfish"
+
+// SupportedHashes is the list of supported Hashes
+var SupportedHashes = DefaultSupportedHashes
+
+const DefaultSupportedHashes = "SHA256,SHA512"
+
+// HMAC carries a hash and its size
+type HMAC struct {
+	hash.Hash
+	size int
+}
+
+// encParams represent encryption parameters
+type encParams struct {
+	// keys
+	permanentPubKey ci.PubKey
+	ephemeralPubKey []byte
+	keys            ci.StretchedKeys
+
+	// selections
+	curveT  string
+	cipherT string
+	hashT   string
+
+	// cipher + mac
+	cipher cipher.Stream
+	mac    HMAC
+}
+
+func (e *encParams) makeMacAndCipher() error {
+	m, err := newMac(e.hashT, e.keys.MacKey)
+	if err != nil {
+		return err
+	}
+
+	bc, err := newBlockCipher(e.cipherT, e.keys.CipherKey)
+	if err != nil {
+		return err
+	}
+
+	e.cipher = cipher.NewCTR(bc, e.keys.IV)
+	e.mac = m
+	return nil
+}
+
+func newMac(hashType string, key []byte) (HMAC, error) {
+	switch hashType {
+	case "SHA1":
+		return HMAC{hmac.New(sha1.New, key), sha1.Size}, nil
+	case "SHA512":
+		return HMAC{hmac.New(sha512.New, key), sha512.Size}, nil
+	case "SHA256":
+		return HMAC{hmac.New(sha256.New, key), sha256.Size}, nil
+	default:
+		return HMAC{}, fmt.Errorf("Unrecognized hash type: %s", hashType)
+	}
+}
+
+func newBlockCipher(cipherT string, key []byte) (cipher.Block, error) {
+	switch cipherT {
+	case "AES-128", "AES-256":
+		return aes.NewCipher(key)
+	case "Blowfish":
+		return bfish.NewCipher(key)
+	default:
+		return nil, fmt.Errorf("Unrecognized cipher type: %s", cipherT)
+	}
+}
+
+// Determines which algorithm to use.  Note:  f(a, b) = f(b, a)
+func selectBest(order int, p1, p2 string) (string, error) {
+	var f, s []string
+	switch {
+	case order < 0:
+		f = strings.Split(p2, ",")
+		s = strings.Split(p1, ",")
+	case order > 0:
+		f = strings.Split(p1, ",")
+		s = strings.Split(p2, ",")
+	default: // Exact same preferences.
+		p := strings.Split(p1, ",")
+		return p[0], nil
+	}
+
+	for _, fc := range f {
+		for _, sc := range s {
+			if fc == sc {
+				return fc, nil
+			}
+		}
+	}
+
+	return "", errors.New("No algorithms in common!")
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/pb/spipe.pb.go b/vendor/github.com/libp2p/go-libp2p-secio/pb/spipe.pb.go
new file mode 100644
index 000000000..0b4919b82
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/pb/spipe.pb.go
@@ -0,0 +1,97 @@
+// Code generated by protoc-gen-gogo.
+// source: spipe.proto
+// DO NOT EDIT!
+
+/*
+Package spipe_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	spipe.proto
+
+It has these top-level messages:
+	Propose
+	Exchange
+*/
+package spipe_pb
+
+import proto "github.com/gogo/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = math.Inf
+
+type Propose struct {
+	Rand             []byte  `protobuf:"bytes,1,opt,name=rand" json:"rand,omitempty"`
+	Pubkey           []byte  `protobuf:"bytes,2,opt,name=pubkey" json:"pubkey,omitempty"`
+	Exchanges        *string `protobuf:"bytes,3,opt,name=exchanges" json:"exchanges,omitempty"`
+	Ciphers          *string `protobuf:"bytes,4,opt,name=ciphers" json:"ciphers,omitempty"`
+	Hashes           *string `protobuf:"bytes,5,opt,name=hashes" json:"hashes,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Propose) Reset()         { *m = Propose{} }
+func (m *Propose) String() string { return proto.CompactTextString(m) }
+func (*Propose) ProtoMessage()    {}
+
+func (m *Propose) GetRand() []byte {
+	if m != nil {
+		return m.Rand
+	}
+	return nil
+}
+
+func (m *Propose) GetPubkey() []byte {
+	if m != nil {
+		return m.Pubkey
+	}
+	return nil
+}
+
+func (m *Propose) GetExchanges() string {
+	if m != nil && m.Exchanges != nil {
+		return *m.Exchanges
+	}
+	return ""
+}
+
+func (m *Propose) GetCiphers() string {
+	if m != nil && m.Ciphers != nil {
+		return *m.Ciphers
+	}
+	return ""
+}
+
+func (m *Propose) GetHashes() string {
+	if m != nil && m.Hashes != nil {
+		return *m.Hashes
+	}
+	return ""
+}
+
+type Exchange struct {
+	Epubkey          []byte `protobuf:"bytes,1,opt,name=epubkey" json:"epubkey,omitempty"`
+	Signature        []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *Exchange) Reset()         { *m = Exchange{} }
+func (m *Exchange) String() string { return proto.CompactTextString(m) }
+func (*Exchange) ProtoMessage()    {}
+
+func (m *Exchange) GetEpubkey() []byte {
+	if m != nil {
+		return m.Epubkey
+	}
+	return nil
+}
+
+func (m *Exchange) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func init() {
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/protocol.go b/vendor/github.com/libp2p/go-libp2p-secio/protocol.go
new file mode 100644
index 000000000..9fc9ed2e0
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/protocol.go
@@ -0,0 +1,386 @@
+package secio
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+
+	proto "github.com/gogo/protobuf/proto"
+	logging "github.com/ipfs/go-log"
+	cs "github.com/libp2p/go-conn-security"
+	ci "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pb "github.com/libp2p/go-libp2p-secio/pb"
+	msgio "github.com/libp2p/go-msgio"
+	mh "github.com/multiformats/go-multihash"
+)
+
+var log = logging.Logger("secio")
+
+// ErrUnsupportedKeyType is returned when a private key cast/type switch fails.
+var ErrUnsupportedKeyType = errors.New("unsupported key type")
+
+// ErrClosed signals the closing of a connection.
+var ErrClosed = errors.New("connection closed")
+
+// ErrWrongPeer is returned when we attempt to handshake with the wrong peer.
+var ErrWrongPeer = errors.New("connected to wrong peer")
+
+// ErrBadSig signals that the peer sent us a handshake packet with a bad signature.
+var ErrBadSig = errors.New("bad signature")
+
+// ErrEcho is returned when we're attempting to handshake with the same keys and nonces.
+var ErrEcho = errors.New("same keys and nonces. one side talking to self")
+
+// HandshakeTimeout governs how long the handshake will be allowed to take place for.
+// Making this number large means there could be many bogus connections waiting to
+// timeout in flight. Typical handshakes take ~3RTTs, so it should be completed within
+// seconds across a typical planet in the solar system.
+var HandshakeTimeout = time.Second * 30
+
+// nonceSize is the size of our nonces (in bytes)
+const nonceSize = 16
+
+// secureSession encapsulates all the parameters needed for encrypting
+// and decrypting traffic from an insecure channel.
+type secureSession struct {
+	msgio.ReadWriteCloser
+
+	insecure  net.Conn
+	insecureM msgio.ReadWriter
+
+	localKey   ci.PrivKey
+	localPeer  peer.ID
+	remotePeer peer.ID
+
+	local  encParams
+	remote encParams
+
+	sharedSecret []byte
+}
+
+var _ cs.Conn = &secureSession{}
+
+func (s *secureSession) Loggable() map[string]interface{} {
+	m := make(map[string]interface{})
+	m["localPeer"] = s.localPeer.Pretty()
+	m["remotePeer"] = s.remotePeer.Pretty()
+	m["established"] = (s.ReadWriteCloser != nil)
+	return m
+}
+
+func newSecureSession(ctx context.Context, local peer.ID, key ci.PrivKey, insecure net.Conn, remotePeer peer.ID) (*secureSession, error) {
+	s := &secureSession{localPeer: local, localKey: key}
+
+	switch {
+	case s.localPeer == "":
+		return nil, errors.New("no local id provided")
+	case s.localKey == nil:
+		return nil, errors.New("no local private key provided")
+	case !s.localPeer.MatchesPrivateKey(s.localKey):
+		return nil, fmt.Errorf("peer.ID does not match PrivateKey")
+	case insecure == nil:
+		return nil, fmt.Errorf("insecure ReadWriter is nil")
+	}
+
+	s.insecure = insecure
+	s.insecureM = msgio.NewReadWriter(insecure)
+	s.remotePeer = remotePeer
+
+	handshakeCtx, cancel := context.WithTimeout(ctx, HandshakeTimeout) // remove
+	defer cancel()
+	if err := s.runHandshake(handshakeCtx); err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}
+
+func hashSha256(data []byte) mh.Multihash {
+	h, err := mh.Sum(data, mh.SHA2_256, -1)
+	if err != nil {
+		// this error can be safely ignored (panic) because multihash only fails
+		// from the selection of hash function. If the fn + length are valid, it
+		// won't error.
+		panic("multihash failed to hash using SHA2_256.")
+	}
+	return h
+}
+
+// runHandshake performs initial communication over insecure channel to share
+// keys, IDs, and initiate communication, assigning all necessary params.
+// requires the duplex channel to be a msgio.ReadWriter (for framed messaging)
+func (s *secureSession) runHandshake(ctx context.Context) error {
+	defer log.EventBegin(ctx, "secureHandshake", s).Done()
+
+	result := make(chan error, 1)
+	go func() {
+		// do *not* close the channel (will look like a success).
+		result <- s.runHandshakeSync()
+	}()
+
+	var err error
+	select {
+	case <-ctx.Done():
+		// State unknown. We *have* to close this.
+		s.insecure.Close()
+		err = ctx.Err()
+	case err = <-result:
+	}
+	return err
+}
+
+func (s *secureSession) runHandshakeSync() error {
+	// =============================================================================
+	// step 1. Propose -- propose cipher suite + send pubkeys + nonce
+
+	// Generate and send Hello packet.
+	// Hello = (rand, PublicKey, Supported)
+	nonceOut := make([]byte, nonceSize)
+	_, err := rand.Read(nonceOut)
+	if err != nil {
+		return err
+	}
+
+	s.local.permanentPubKey = s.localKey.GetPublic()
+	myPubKeyBytes, err := s.local.permanentPubKey.Bytes()
+	if err != nil {
+		return err
+	}
+
+	proposeOut := new(pb.Propose)
+	proposeOut.Rand = nonceOut
+	proposeOut.Pubkey = myPubKeyBytes
+	proposeOut.Exchanges = &SupportedExchanges
+	proposeOut.Ciphers = &SupportedCiphers
+	proposeOut.Hashes = &SupportedHashes
+
+	// log.Debugf("1.0 Propose: nonce:%s exchanges:%s ciphers:%s hashes:%s",
+	// 	nonceOut, SupportedExchanges, SupportedCiphers, SupportedHashes)
+
+	// Marshal our propose packet
+	proposeOutBytes, err := proto.Marshal(proposeOut)
+	if err != nil {
+		return err
+	}
+
+	// Send Propose packet and Receive their Propose packet
+	proposeInBytes, err := readWriteMsg(s.insecureM, proposeOutBytes)
+	if err != nil {
+		return err
+	}
+	defer s.insecureM.ReleaseMsg(proposeInBytes)
+
+	// Parse their propose packet
+	proposeIn := new(pb.Propose)
+	if err = proto.Unmarshal(proposeInBytes, proposeIn); err != nil {
+		return err
+	}
+
+	// log.Debugf("1.0.1 Propose recv: nonce:%s exchanges:%s ciphers:%s hashes:%s",
+	// 	proposeIn.GetRand(), proposeIn.GetExchanges(), proposeIn.GetCiphers(), proposeIn.GetHashes())
+
+	// =============================================================================
+	// step 1.1 Identify -- get identity from their key
+
+	// get remote identity
+	s.remote.permanentPubKey, err = ci.UnmarshalPublicKey(proposeIn.GetPubkey())
+	if err != nil {
+		return err
+	}
+
+	// get peer id
+	actualRemotePeer, err := peer.IDFromPublicKey(s.remote.permanentPubKey)
+	if err != nil {
+		return err
+	}
+	switch s.remotePeer {
+	case actualRemotePeer:
+		// All good.
+	case "":
+		// No peer set. We're accepting a remote connection.
+		s.remotePeer = actualRemotePeer
+	default:
+		// Peer mismatch. Bail.
+		s.insecure.Close()
+		log.Debugf("expected peer %s, got peer %s", s.remotePeer, actualRemotePeer)
+		return ErrWrongPeer
+	}
+
+	log.Debugf("1.1 Identify: %s Remote Peer Identified as %s", s.localPeer, s.remotePeer)
+
+	// =============================================================================
+	// step 1.2 Selection -- select/agree on best encryption parameters
+
+	// to determine order, use cmp(H(remote_pubkey||local_rand), H(local_pubkey||remote_rand)).
+	oh1 := hashSha256(append(proposeIn.GetPubkey(), nonceOut...))
+	oh2 := hashSha256(append(myPubKeyBytes, proposeIn.GetRand()...))
+	order := bytes.Compare(oh1, oh2)
+	if order == 0 {
+		return ErrEcho // talking to self (same socket. must be reuseport + dialing self)
+	}
+
+	s.local.curveT, err = selectBest(order, SupportedExchanges, proposeIn.GetExchanges())
+	if err != nil {
+		return err
+	}
+
+	s.local.cipherT, err = selectBest(order, SupportedCiphers, proposeIn.GetCiphers())
+	if err != nil {
+		return err
+	}
+
+	s.local.hashT, err = selectBest(order, SupportedHashes, proposeIn.GetHashes())
+	if err != nil {
+		return err
+	}
+
+	// we use the same params for both directions (must choose same curve)
+	// WARNING: if they dont SelectBest the same way, this won't work...
+	s.remote.curveT = s.local.curveT
+	s.remote.cipherT = s.local.cipherT
+	s.remote.hashT = s.local.hashT
+
+	// log.Debugf("1.2 selection: exchange:%s cipher:%s hash:%s",
+	// 	s.local.curveT, s.local.cipherT, s.local.hashT)
+
+	// =============================================================================
+	// step 2. Exchange -- exchange (signed) ephemeral keys. verify signatures.
+
+	// Generate EphemeralPubKey
+	var genSharedKey ci.GenSharedKey
+	s.local.ephemeralPubKey, genSharedKey, err = ci.GenerateEKeyPair(s.local.curveT)
+	if err != nil {
+		return err
+	}
+
+	// Gather corpus to sign.
+	selectionOut := new(bytes.Buffer)
+	selectionOut.Write(proposeOutBytes)
+	selectionOut.Write(proposeInBytes)
+	selectionOut.Write(s.local.ephemeralPubKey)
+	selectionOutBytes := selectionOut.Bytes()
+
+	// log.Debugf("2.0 exchange: %v", selectionOutBytes)
+	exchangeOut := new(pb.Exchange)
+	exchangeOut.Epubkey = s.local.ephemeralPubKey
+	exchangeOut.Signature, err = s.localKey.Sign(selectionOutBytes)
+	if err != nil {
+		return err
+	}
+
+	// Marshal our exchange packet
+	exchangeOutBytes, err := proto.Marshal(exchangeOut)
+	if err != nil {
+		return err
+	}
+
+	// Send Exchange packet and receive their Exchange packet
+	exchangeInBytes, err := readWriteMsg(s.insecureM, exchangeOutBytes)
+	if err != nil {
+		return err
+	}
+	defer s.insecureM.ReleaseMsg(exchangeInBytes)
+
+	// Parse their Exchange packet.
+	exchangeIn := new(pb.Exchange)
+	if err = proto.Unmarshal(exchangeInBytes, exchangeIn); err != nil {
+		return err
+	}
+
+	// =============================================================================
+	// step 2.1. Verify -- verify their exchange packet is good.
+
+	// get their ephemeral pub key
+	s.remote.ephemeralPubKey = exchangeIn.GetEpubkey()
+
+	selectionIn := new(bytes.Buffer)
+	selectionIn.Write(proposeInBytes)
+	selectionIn.Write(proposeOutBytes)
+	selectionIn.Write(s.remote.ephemeralPubKey)
+	selectionInBytes := selectionIn.Bytes()
+	// log.Debugf("2.0.1 exchange recv: %v", selectionInBytes)
+
+	// u.POut("Remote Peer Identified as %s\n", s.remote)
+	sigOK, err := s.remote.permanentPubKey.Verify(selectionInBytes, exchangeIn.GetSignature())
+	if err != nil {
+		// log.Error("2.1 Verify: failed: %s", err)
+		return err
+	}
+
+	if !sigOK {
+		// log.Error("2.1 Verify: failed: %s", ErrBadSig)
+		return ErrBadSig
+	}
+	// log.Debugf("2.1 Verify: signature verified.")
+
+	// =============================================================================
+	// step 2.2. Keys -- generate keys for mac + encryption
+
+	// OK! seems like we're good to go.
+	s.sharedSecret, err = genSharedKey(exchangeIn.GetEpubkey())
+	if err != nil {
+		return err
+	}
+
+	// generate two sets of keys (stretching)
+	k1, k2 := ci.KeyStretcher(s.local.cipherT, s.local.hashT, s.sharedSecret)
+
+	// use random nonces to decide order.
+	switch {
+	case order > 0:
+		// just break
+	case order < 0:
+		k1, k2 = k2, k1 // swap
+	default:
+		// we should've bailed before this. but if not, bail here.
+		return ErrEcho
+	}
+	s.local.keys = k1
+	s.remote.keys = k2
+
+	// log.Debug("2.2 keys:\n\tshared: %v\n\tk1: %v\n\tk2: %v",
+	// 	s.sharedSecret, s.local.keys, s.remote.keys)
+
+	// =============================================================================
+	// step 2.3. MAC + Cipher -- prepare MAC + cipher
+
+	if err := s.local.makeMacAndCipher(); err != nil {
+		return err
+	}
+
+	if err := s.remote.makeMacAndCipher(); err != nil {
+		return err
+	}
+
+	// log.Debug("2.3 mac + cipher.")
+
+	// =============================================================================
+	// step 3. Finish -- send expected message to verify encryption works (send local nonce)
+
+	// setup ETM ReadWriter
+	w := NewETMWriter(s.insecure, s.local.cipher, s.local.mac)
+	r := NewETMReader(s.insecure, s.remote.cipher, s.remote.mac)
+	s.ReadWriteCloser = msgio.Combine(w, r).(msgio.ReadWriteCloser)
+
+	// log.Debug("3.0 finish. sending: %v", proposeIn.GetRand())
+
+	// send their Nonce and receive ours
+	nonceOut2, err := readWriteMsg(s.ReadWriteCloser, proposeIn.GetRand())
+	if err != nil {
+		return err
+	}
+	defer s.ReleaseMsg(nonceOut2)
+
+	// log.Debug("3.0 finish.\n\texpect: %v\n\tactual: %v", nonceOut, nonceOut2)
+	if !bytes.Equal(nonceOut, nonceOut2) {
+		return fmt.Errorf("Failed to read our encrypted nonce: %s != %s", nonceOut2, nonceOut)
+	}
+
+	// Whew! ok, that's all folks.
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/rw.go b/vendor/github.com/libp2p/go-libp2p-secio/rw.go
new file mode 100644
index 000000000..f5dcab112
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/rw.go
@@ -0,0 +1,265 @@
+package secio
+
+import (
+	"crypto/cipher"
+	"crypto/hmac"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+
+	msgio "github.com/libp2p/go-msgio"
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+// ErrMACInvalid signals that a MAC verification failed
+var ErrMACInvalid = errors.New("MAC verification failed")
+
+type etmWriter struct {
+	str cipher.Stream // the stream cipher to encrypt with
+	mac HMAC          // the mac to authenticate data with
+	w   io.Writer
+
+	sync.Mutex
+}
+
+// NewETMWriter Encrypt-Then-MAC
+func NewETMWriter(w io.Writer, s cipher.Stream, mac HMAC) msgio.WriteCloser {
+	return &etmWriter{w: w, str: s, mac: mac}
+}
+
+// Write writes passed in buffer as a single message.
+func (w *etmWriter) Write(b []byte) (int, error) {
+	if err := w.WriteMsg(b); err != nil {
+		return 0, err
+	}
+	return len(b), nil
+}
+
+// WriteMsg writes the msg in the passed in buffer.
+func (w *etmWriter) WriteMsg(b []byte) error {
+	w.Lock()
+	defer w.Unlock()
+
+	bufsize := uint32(4 + len(b) + w.mac.Size())
+	// encrypt.
+	buf := mpool.ByteSlicePool.Get(bufsize).([]byte)
+	data := buf[4 : 4+len(b)] // the pool's buffer may be larger
+	w.str.XORKeyStream(data, b)
+
+	// log.Debugf("ENC plaintext (%d): %s %v", len(b), b, b)
+	// log.Debugf("ENC ciphertext (%d): %s %v", len(data), data, data)
+
+	// then, mac.
+	if _, err := w.mac.Write(data); err != nil {
+		return err
+	}
+
+	// Sum appends.
+	data = w.mac.Sum(data)
+	w.mac.Reset()
+	binary.BigEndian.PutUint32(buf[:4], uint32(len(data)))
+
+	_, err := w.w.Write(buf[:bufsize])
+	mpool.ByteSlicePool.Put(bufsize, buf)
+	return err
+}
+
+func (w *etmWriter) Close() error {
+	if c, ok := w.w.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+type etmReader struct {
+	msgio.Reader
+	io.Closer
+
+	// internal buffer returned from the msgio
+	buf []byte
+
+	// low and high watermark for the buffered data
+	lowat int
+	hiwat int
+
+	// params
+	msg msgio.ReadCloser // msgio for knowing where boundaries lie
+	str cipher.Stream    // the stream cipher to encrypt with
+	mac HMAC             // the mac to authenticate data with
+
+	sync.Mutex
+}
+
+// NewETMReader Encrypt-Then-MAC
+func NewETMReader(r io.Reader, s cipher.Stream, mac HMAC) msgio.ReadCloser {
+	return &etmReader{msg: msgio.NewReader(r), str: s, mac: mac}
+}
+
+func (r *etmReader) NextMsgLen() (int, error) {
+	return r.msg.NextMsgLen()
+}
+
+func (r *etmReader) drain(buf []byte) int {
+	// Return zero if there is no data remaining in the internal buffer.
+	if r.lowat == r.hiwat {
+		return 0
+	}
+
+	// Copy data to the output buffer.
+	n := copy(buf, r.buf[r.lowat:r.hiwat])
+
+	// Update the low watermark.
+	r.lowat += n
+
+	// Release the buffer and reset the watermarks if it has been fully read.
+	if r.lowat == r.hiwat {
+		r.msg.ReleaseMsg(r.buf)
+		r.buf = nil
+		r.lowat = 0
+		r.hiwat = 0
+	}
+
+	return n
+}
+
+func (r *etmReader) fill() error {
+	// Read a message from the underlying msgio.
+	msg, err := r.msg.ReadMsg()
+	if err != nil {
+		return err
+	}
+
+	// Check the MAC.
+	n, err := r.macCheckThenDecrypt(msg)
+	if err != nil {
+		r.msg.ReleaseMsg(msg)
+		return err
+	}
+
+	// Retain the buffer so it can be drained from and later released.
+	r.buf = msg
+	r.lowat = 0
+	r.hiwat = n
+
+	return nil
+}
+
+func (r *etmReader) Read(buf []byte) (int, error) {
+	r.Lock()
+	defer r.Unlock()
+
+	// Return buffered data without reading more, if possible.
+	copied := r.drain(buf)
+	if copied > 0 {
+		return copied, nil
+	}
+
+	// Check the length of the next message.
+	fullLen, err := r.msg.NextMsgLen()
+	if err != nil {
+		return 0, err
+	}
+
+	// If the destination buffer is too short, fill an internal buffer and then
+	// drain as much of that into the output buffer as will fit.
+	if cap(buf) < fullLen {
+		err := r.fill()
+		if err != nil {
+			return 0, err
+		}
+
+		copied := r.drain(buf)
+		return copied, nil
+	}
+
+	// Otherwise, read directly into the destination buffer.
+	n, err := io.ReadFull(r.msg, buf[:fullLen])
+	if err != nil {
+		return 0, err
+	}
+
+	m, err := r.macCheckThenDecrypt(buf[:n])
+	if err != nil {
+		return 0, err
+	}
+
+	return m, nil
+}
+
+func (r *etmReader) ReadMsg() ([]byte, error) {
+	r.Lock()
+	defer r.Unlock()
+
+	msg, err := r.msg.ReadMsg()
+	if err != nil {
+		return nil, err
+	}
+
+	n, err := r.macCheckThenDecrypt(msg)
+	if err != nil {
+		r.msg.ReleaseMsg(msg)
+		return nil, err
+	}
+	return msg[:n], nil
+}
+
+func (r *etmReader) macCheckThenDecrypt(m []byte) (int, error) {
+	l := len(m)
+	if l < r.mac.size {
+		return 0, fmt.Errorf("buffer (%d) shorter than MAC size (%d)", l, r.mac.size)
+	}
+
+	mark := l - r.mac.size
+	data := m[:mark]
+	macd := m[mark:]
+
+	r.mac.Write(data)
+	expected := r.mac.Sum(nil)
+	r.mac.Reset()
+
+	// check mac. if failed, return error.
+	if !hmac.Equal(macd, expected) {
+		log.Debug("MAC Invalid:", expected, "!=", macd)
+		return 0, ErrMACInvalid
+	}
+
+	// ok seems good. decrypt. (can decrypt in place, yay!)
+	// log.Debugf("DEC ciphertext (%d): %s %v", len(data), data, data)
+	r.str.XORKeyStream(data, data)
+	// log.Debugf("DEC plaintext (%d): %s %v", len(data), data, data)
+
+	return mark, nil
+}
+
+func (r *etmReader) Close() error {
+	return r.msg.Close()
+}
+
+// ReleaseMsg signals a buffer can be reused.
+func (r *etmReader) ReleaseMsg(b []byte) {
+	r.msg.ReleaseMsg(b)
+}
+
+// read and write a message at the same time.
+func readWriteMsg(c msgio.ReadWriter, out []byte) ([]byte, error) {
+	wresult := make(chan error)
+	go func() {
+		wresult <- c.WriteMsg(out)
+	}()
+
+	msg, err1 := c.ReadMsg()
+
+	// Always wait for the read to finish.
+	err2 := <-wresult
+
+	if err1 != nil {
+		return nil, err1
+	}
+	if err2 != nil {
+		c.ReleaseMsg(msg)
+		return nil, err2
+	}
+	return msg, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-secio/transport.go b/vendor/github.com/libp2p/go-libp2p-secio/transport.go
new file mode 100644
index 000000000..323f32fa1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-secio/transport.go
@@ -0,0 +1,81 @@
+// Package secio is used to encrypt `go-libp2p-conn` connections. Connections wrapped by secio use secure sessions provided by this package to encrypt all traffic. A TLS-like handshake is used to setup the communication channel.
+package secio
+
+import (
+	"context"
+	"net"
+	"time"
+
+	cs "github.com/libp2p/go-conn-security"
+	ci "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// ID is secio's protocol ID (used when negotiating with multistream)
+const ID = "/secio/1.0.0"
+
+// SessionGenerator constructs secure communication sessions for a peer.
+type Transport struct {
+	LocalID    peer.ID
+	PrivateKey ci.PrivKey
+}
+
+func New(sk ci.PrivKey) (*Transport, error) {
+	id, err := peer.IDFromPrivateKey(sk)
+	if err != nil {
+		return nil, err
+	}
+	return &Transport{
+		LocalID:    id,
+		PrivateKey: sk,
+	}, nil
+}
+
+var _ cs.Transport = (*Transport)(nil)
+
+func (sg *Transport) SecureInbound(ctx context.Context, insecure net.Conn) (cs.Conn, error) {
+	return newSecureSession(ctx, sg.LocalID, sg.PrivateKey, insecure, "")
+}
+func (sg *Transport) SecureOutbound(ctx context.Context, insecure net.Conn, p peer.ID) (cs.Conn, error) {
+	return newSecureSession(ctx, sg.LocalID, sg.PrivateKey, insecure, p)
+}
+
+func (s *secureSession) SetReadDeadline(t time.Time) error {
+	return s.insecure.SetReadDeadline(t)
+}
+
+func (s *secureSession) SetWriteDeadline(t time.Time) error {
+	return s.insecure.SetWriteDeadline(t)
+}
+
+func (s *secureSession) SetDeadline(t time.Time) error {
+	return s.insecure.SetDeadline(t)
+}
+
+func (s *secureSession) RemoteAddr() net.Addr {
+	return s.insecure.RemoteAddr()
+}
+
+func (s *secureSession) LocalAddr() net.Addr {
+	return s.insecure.LocalAddr()
+}
+
+// LocalPeer retrieves the local peer.
+func (s *secureSession) LocalPeer() peer.ID {
+	return s.localPeer
+}
+
+// LocalPrivateKey retrieves the local peer's PrivateKey
+func (s *secureSession) LocalPrivateKey() ci.PrivKey {
+	return s.localKey
+}
+
+// RemotePeer retrieves the remote peer.
+func (s *secureSession) RemotePeer() peer.ID {
+	return s.remotePeer
+}
+
+// RemotePublicKey retrieves the remote public key.
+func (s *secureSession) RemotePublicKey() ci.PubKey {
+	return s.remote.permanentPubKey
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/LICENSE b/vendor/github.com/libp2p/go-libp2p-swarm/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/addrs.go b/vendor/github.com/libp2p/go-libp2p-swarm/addrs.go
new file mode 100644
index 000000000..ed510f262
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/addrs.go
@@ -0,0 +1,35 @@
+package swarm
+
+import (
+	mafilter "github.com/libp2p/go-maddr-filter"
+	mamask "github.com/whyrusleeping/multiaddr-filter"
+)
+
+// http://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
+var lowTimeoutFilters = mafilter.NewFilters()
+
+func init() {
+	for _, p := range []string{
+		"/ip4/10.0.0.0/ipcidr/8",
+		"/ip4/100.64.0.0/ipcidr/10",
+		"/ip4/169.254.0.0/ipcidr/16",
+		"/ip4/172.16.0.0/ipcidr/12",
+		"/ip4/192.0.0.0/ipcidr/24",
+		"/ip4/192.0.0.0/ipcidr/29",
+		"/ip4/192.0.0.8/ipcidr/32",
+		"/ip4/192.0.0.170/ipcidr/32",
+		"/ip4/192.0.0.171/ipcidr/32",
+		"/ip4/192.0.2.0/ipcidr/24",
+		"/ip4/192.168.0.0/ipcidr/16",
+		"/ip4/198.18.0.0/ipcidr/15",
+		"/ip4/198.51.100.0/ipcidr/24",
+		"/ip4/203.0.113.0/ipcidr/24",
+		"/ip4/240.0.0.0/ipcidr/4",
+	} {
+		f, err := mamask.NewMask(p)
+		if err != nil {
+			panic("error in lowTimeoutFilters init: " + err.Error())
+		}
+		lowTimeoutFilters.AddDialFilter(f)
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/dial_sync.go b/vendor/github.com/libp2p/go-libp2p-swarm/dial_sync.go
new file mode 100644
index 000000000..82256eca4
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/dial_sync.go
@@ -0,0 +1,122 @@
+package swarm
+
+import (
+	"context"
+	"sync"
+
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// DialFunc is the type of function expected by DialSync.
+type DialFunc func(context.Context, peer.ID) (*Conn, error)
+
+// NewDialSync constructs a new DialSync
+func NewDialSync(dfn DialFunc) *DialSync {
+	return &DialSync{
+		dials:    make(map[peer.ID]*activeDial),
+		dialFunc: dfn,
+	}
+}
+
+// DialSync is a dial synchronization helper that ensures that at most one dial
+// to any given peer is active at any given time.
+type DialSync struct {
+	dials    map[peer.ID]*activeDial
+	dialsLk  sync.Mutex
+	dialFunc DialFunc
+}
+
+type activeDial struct {
+	id       peer.ID
+	refCnt   int
+	refCntLk sync.Mutex
+	cancel   func()
+
+	err    error
+	conn   *Conn
+	waitch chan struct{}
+
+	ds *DialSync
+}
+
+func (ad *activeDial) wait(ctx context.Context) (*Conn, error) {
+	defer ad.decref()
+	select {
+	case <-ad.waitch:
+		return ad.conn, ad.err
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (ad *activeDial) incref() {
+	ad.refCntLk.Lock()
+	defer ad.refCntLk.Unlock()
+	ad.refCnt++
+}
+
+func (ad *activeDial) decref() {
+	ad.refCntLk.Lock()
+	ad.refCnt--
+	maybeZero := (ad.refCnt <= 0)
+	ad.refCntLk.Unlock()
+
+	// make sure to always take locks in correct order.
+	if maybeZero {
+		ad.ds.dialsLk.Lock()
+		ad.refCntLk.Lock()
+		// check again after lock swap drop to make sure nobody else called incref
+		// in between locks
+		if ad.refCnt <= 0 {
+			ad.cancel()
+			delete(ad.ds.dials, ad.id)
+		}
+		ad.refCntLk.Unlock()
+		ad.ds.dialsLk.Unlock()
+	}
+}
+
+func (ad *activeDial) start(ctx context.Context) {
+	ad.conn, ad.err = ad.ds.dialFunc(ctx, ad.id)
+	close(ad.waitch)
+	ad.cancel()
+}
+
+func (ds *DialSync) getActiveDial(p peer.ID) *activeDial {
+	ds.dialsLk.Lock()
+	defer ds.dialsLk.Unlock()
+
+	actd, ok := ds.dials[p]
+	if !ok {
+		adctx, cancel := context.WithCancel(context.Background())
+		actd = &activeDial{
+			id:     p,
+			cancel: cancel,
+			waitch: make(chan struct{}),
+			ds:     ds,
+		}
+		ds.dials[p] = actd
+
+		go actd.start(adctx)
+	}
+
+	// increase ref count before dropping dialsLk
+	actd.incref()
+
+	return actd
+}
+
+// DialLock initiates a dial to the given peer if there are none in progress
+// then waits for the dial to that peer to complete.
+func (ds *DialSync) DialLock(ctx context.Context, p peer.ID) (*Conn, error) {
+	return ds.getActiveDial(p).wait(ctx)
+}
+
+// CancelDial cancels all in-progress dials to the given peer.
+func (ds *DialSync) CancelDial(p peer.ID) {
+	ds.dialsLk.Lock()
+	defer ds.dialsLk.Unlock()
+	if ad, ok := ds.dials[p]; ok {
+		ad.cancel()
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/limiter.go b/vendor/github.com/libp2p/go-libp2p-swarm/limiter.go
new file mode 100644
index 000000000..02aed50a2
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/limiter.go
@@ -0,0 +1,192 @@
+package swarm
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	addrutil "github.com/libp2p/go-addr-util"
+	peer "github.com/libp2p/go-libp2p-peer"
+	transport "github.com/libp2p/go-libp2p-transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+type dialResult struct {
+	Conn transport.Conn
+	Addr ma.Multiaddr
+	Err  error
+}
+
+type dialJob struct {
+	addr ma.Multiaddr
+	peer peer.ID
+	ctx  context.Context
+	resp chan dialResult
+}
+
+func (dj *dialJob) cancelled() bool {
+	select {
+	case <-dj.ctx.Done():
+		return true
+	default:
+		return false
+	}
+}
+
+func (dj *dialJob) dialTimeout() time.Duration {
+	timeout := transport.DialTimeout
+	if lowTimeoutFilters.AddrBlocked(dj.addr) {
+		timeout = DialTimeoutLocal
+	}
+
+	return timeout
+}
+
+type dialLimiter struct {
+	lk sync.Mutex
+
+	fdConsuming int
+	fdLimit     int
+	waitingOnFd []*dialJob
+
+	dialFunc dialfunc
+
+	activePerPeer      map[peer.ID]int
+	perPeerLimit       int
+	waitingOnPeerLimit map[peer.ID][]*dialJob
+}
+
+type dialfunc func(context.Context, peer.ID, ma.Multiaddr) (transport.Conn, error)
+
+func newDialLimiter(df dialfunc) *dialLimiter {
+	return newDialLimiterWithParams(df, ConcurrentFdDials, DefaultPerPeerRateLimit)
+}
+
+func newDialLimiterWithParams(df dialfunc, fdLimit, perPeerLimit int) *dialLimiter {
+	return &dialLimiter{
+		fdLimit:            fdLimit,
+		perPeerLimit:       perPeerLimit,
+		waitingOnPeerLimit: make(map[peer.ID][]*dialJob),
+		activePerPeer:      make(map[peer.ID]int),
+		dialFunc:           df,
+	}
+}
+
+// freeFDToken frees FD token and if there are any schedules another waiting dialJob
+// in it's place
+func (dl *dialLimiter) freeFDToken() {
+	dl.fdConsuming--
+
+	if len(dl.waitingOnFd) > 0 {
+		next := dl.waitingOnFd[0]
+		dl.waitingOnFd[0] = nil // clear out memory
+		dl.waitingOnFd = dl.waitingOnFd[1:]
+		if len(dl.waitingOnFd) == 0 {
+			dl.waitingOnFd = nil // clear out memory
+		}
+		dl.fdConsuming++
+
+		// we already have activePerPeer token at this point so we can just dial
+		go dl.executeDial(next)
+	}
+}
+
+func (dl *dialLimiter) freePeerToken(dj *dialJob) {
+	// release tokens in reverse order than we take them
+	dl.activePerPeer[dj.peer]--
+	if dl.activePerPeer[dj.peer] == 0 {
+		delete(dl.activePerPeer, dj.peer)
+	}
+
+	waitlist := dl.waitingOnPeerLimit[dj.peer]
+	if len(waitlist) > 0 {
+		next := waitlist[0]
+		if len(waitlist) == 1 {
+			delete(dl.waitingOnPeerLimit, next.peer)
+		} else {
+			waitlist[0] = nil // clear out memory
+			dl.waitingOnPeerLimit[next.peer] = waitlist[1:]
+		}
+
+		dl.activePerPeer[next.peer]++ // just kidding, we still want this token
+
+		dl.addCheckFdLimit(next)
+	}
+}
+
+func (dl *dialLimiter) finishedDial(dj *dialJob) {
+	dl.lk.Lock()
+	defer dl.lk.Unlock()
+
+	if addrutil.IsFDCostlyTransport(dj.addr) {
+		dl.freeFDToken()
+	}
+
+	dl.freePeerToken(dj)
+}
+
+func (dl *dialLimiter) addCheckFdLimit(dj *dialJob) {
+	if addrutil.IsFDCostlyTransport(dj.addr) {
+		if dl.fdConsuming >= dl.fdLimit {
+			dl.waitingOnFd = append(dl.waitingOnFd, dj)
+			return
+		}
+
+		// take token
+		dl.fdConsuming++
+	}
+
+	go dl.executeDial(dj)
+}
+
+func (dl *dialLimiter) addCheckPeerLimit(dj *dialJob) {
+	if dl.activePerPeer[dj.peer] >= dl.perPeerLimit {
+		wlist := dl.waitingOnPeerLimit[dj.peer]
+		dl.waitingOnPeerLimit[dj.peer] = append(wlist, dj)
+		return
+	}
+	dl.activePerPeer[dj.peer]++
+
+	dl.addCheckFdLimit(dj)
+}
+
+// AddDialJob tries to take the needed tokens for starting the given dial job.
+// If it acquires all needed tokens, it immediately starts the dial, otherwise
+// it will put it on the waitlist for the requested token.
+func (dl *dialLimiter) AddDialJob(dj *dialJob) {
+	dl.lk.Lock()
+	defer dl.lk.Unlock()
+
+	dl.addCheckPeerLimit(dj)
+}
+
+func (dl *dialLimiter) clearAllPeerDials(p peer.ID) {
+	dl.lk.Lock()
+	defer dl.lk.Unlock()
+	delete(dl.waitingOnPeerLimit, p)
+	// NB: the waitingOnFd list doesn't need to be cleaned out here, we will
+	// remove them as we encounter them because they are 'cancelled' at this
+	// point
+}
+
+// executeDial calls the dialFunc, and reports the result through the response
+// channel when finished. Once the response is sent it also releases all tokens
+// it held during the dial.
+func (dl *dialLimiter) executeDial(j *dialJob) {
+	defer dl.finishedDial(j)
+	if j.cancelled() {
+		return
+	}
+
+	dctx, cancel := context.WithTimeout(j.ctx, j.dialTimeout())
+	defer cancel()
+
+	con, err := dl.dialFunc(dctx, j.peer, j.addr)
+	select {
+	case j.resp <- dialResult{Conn: con, Addr: j.addr, Err: err}:
+	case <-j.ctx.Done():
+		if err == nil {
+			con.Close()
+		}
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm.go
new file mode 100644
index 000000000..7d795abd8
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm.go
@@ -0,0 +1,498 @@
+package swarm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	"github.com/jbenet/goprocess"
+	goprocessctx "github.com/jbenet/goprocess/context"
+	metrics "github.com/libp2p/go-libp2p-metrics"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	transport "github.com/libp2p/go-libp2p-transport"
+	filter "github.com/libp2p/go-maddr-filter"
+	mafilter "github.com/whyrusleeping/multiaddr-filter"
+)
+
+// DialTimeoutLocal is the maximum duration a Dial to local network address
+// is allowed to take.
+// This includes the time between dialing the raw network connection,
+// protocol selection as well the handshake, if applicable.
+var DialTimeoutLocal = 5 * time.Second
+
+var log = logging.Logger("swarm2")
+
+// ErrSwarmClosed is returned when one attempts to operate on a closed swarm.
+var ErrSwarmClosed = errors.New("swarm closed")
+
+// ErrAddrFiltered is returned when trying to register a connection to a
+// filtered address. You shouldn't see this error unless some underlying
+// transport is misbehaving.
+var ErrAddrFiltered = errors.New("address filtered")
+
+// Swarm is a connection muxer, allowing connections to other peers to
+// be opened and closed, while still using the same Chan for all
+// communication. The Chan sends/receives Messages, which note the
+// destination or source Peer.
+type Swarm struct {
+	// Close refcount. This allows us to fully wait for the swarm to be torn
+	// down before continuing.
+	refs sync.WaitGroup
+
+	local peer.ID
+	peers pstore.Peerstore
+
+	conns struct {
+		sync.RWMutex
+		m map[peer.ID][]*Conn
+	}
+
+	listeners struct {
+		sync.RWMutex
+		m map[transport.Listener]struct{}
+	}
+
+	notifs struct {
+		sync.RWMutex
+		m map[inet.Notifiee]struct{}
+	}
+
+	transports struct {
+		sync.RWMutex
+		m map[int]transport.Transport
+	}
+
+	// new connection and stream handlers
+	connh   atomic.Value
+	streamh atomic.Value
+
+	// dialing helpers
+	dsync   *DialSync
+	backf   DialBackoff
+	limiter *dialLimiter
+
+	// filters for addresses that shouldnt be dialed (or accepted)
+	Filters *filter.Filters
+
+	proc goprocess.Process
+	ctx  context.Context
+	bwc  metrics.Reporter
+}
+
+// NewSwarm constructs a Swarm
+func NewSwarm(ctx context.Context, local peer.ID, peers pstore.Peerstore, bwc metrics.Reporter) *Swarm {
+	s := &Swarm{
+		local:   local,
+		peers:   peers,
+		bwc:     bwc,
+		Filters: filter.NewFilters(),
+	}
+
+	s.conns.m = make(map[peer.ID][]*Conn)
+	s.listeners.m = make(map[transport.Listener]struct{})
+	s.transports.m = make(map[int]transport.Transport)
+	s.notifs.m = make(map[inet.Notifiee]struct{})
+
+	s.dsync = NewDialSync(s.doDial)
+	s.limiter = newDialLimiter(s.dialAddr)
+	s.proc = goprocessctx.WithContextAndTeardown(ctx, s.teardown)
+	s.ctx = goprocessctx.OnClosingContext(s.proc)
+
+	return s
+}
+
+func (s *Swarm) teardown() error {
+	// Prevents new connections and/or listeners from being added to the swarm.
+
+	s.listeners.Lock()
+	listeners := s.listeners.m
+	s.listeners.m = nil
+	s.listeners.Unlock()
+
+	s.conns.Lock()
+	conns := s.conns.m
+	s.conns.m = nil
+	s.conns.Unlock()
+
+	// Lots of go routines but we might as well do this in parallel. We want
+	// to shut down as fast as possible.
+
+	for l := range listeners {
+		go func(l transport.Listener) {
+			if err := l.Close(); err != nil {
+				log.Errorf("error when shutting down listener: %s", err)
+			}
+		}(l)
+	}
+
+	for _, cs := range conns {
+		for _, c := range cs {
+			go func(c *Conn) {
+				if err := c.Close(); err != nil {
+					log.Errorf("error when shutting down connection: %s", err)
+				}
+			}(c)
+		}
+	}
+
+	// Wait for everything to finish.
+	s.refs.Wait()
+
+	return nil
+}
+
+// AddAddrFilter adds a multiaddr filter to the set of filters the swarm will
+// use to determine which addresses not to dial to.
+func (s *Swarm) AddAddrFilter(f string) error {
+	m, err := mafilter.NewMask(f)
+	if err != nil {
+		return err
+	}
+
+	s.Filters.AddDialFilter(m)
+	return nil
+}
+
+// Process returns the Process of the swarm
+func (s *Swarm) Process() goprocess.Process {
+	return s.proc
+}
+
+func (s *Swarm) addConn(tc transport.Conn) (*Conn, error) {
+	// The underlying transport (or the dialer) *should* filter it's own
+	// connections but we should double check anyways.
+	raddr := tc.RemoteMultiaddr()
+	if s.Filters.AddrBlocked(raddr) {
+		tc.Close()
+		return nil, ErrAddrFiltered
+	}
+
+	p := tc.RemotePeer()
+
+	// Add the public key.
+	if pk := tc.RemotePublicKey(); pk != nil {
+		s.peers.AddPubKey(p, pk)
+	}
+
+	// Clear any backoffs
+	s.backf.Clear(p)
+
+	// Finally, add the peer.
+	s.conns.Lock()
+	// Check if we're still online
+	if s.conns.m == nil {
+		s.conns.Unlock()
+		tc.Close()
+		return nil, ErrSwarmClosed
+	}
+
+	// Wrap and register the connection.
+	c := &Conn{
+		conn:  tc,
+		swarm: s,
+	}
+	c.streams.m = make(map[*Stream]struct{})
+	s.conns.m[p] = append(s.conns.m[p], c)
+
+	// Add two swarm refs:
+	// * One will be decremented after the close notifications fire in Conn.doClose
+	// * The other will be decremented when Conn.start exits.
+	s.refs.Add(2)
+
+	// Take the notification lock before releasing the conns lock to block
+	// Disconnect notifications until after the Connect notifications done.
+	c.notifyLk.Lock()
+	s.conns.Unlock()
+
+	// We have a connection now. Cancel all other in-progress dials.
+	// This should be fast, no reason to wait till later.
+	s.dsync.CancelDial(p)
+
+	s.notifyAll(func(f inet.Notifiee) {
+		f.Connected(s, c)
+	})
+	c.notifyLk.Unlock()
+
+	c.start()
+
+	// TODO: Get rid of this. We use it for identify but that happen much
+	// earlier (really, inside the transport and, if not then, during the
+	// notifications).
+	if h := s.ConnHandler(); h != nil {
+		go h(c)
+	}
+
+	return c, nil
+}
+
+// Peerstore returns this swarms internal Peerstore.
+func (s *Swarm) Peerstore() pstore.Peerstore {
+	return s.peers
+}
+
+// Context returns the context of the swarm
+func (s *Swarm) Context() context.Context {
+	return s.ctx
+}
+
+// Close stops the Swarm.
+func (s *Swarm) Close() error {
+	return s.proc.Close()
+}
+
+// TODO: We probably don't need the conn handlers.
+
+// SetConnHandler assigns the handler for new connections.
+// You will rarely use this. See SetStreamHandler
+func (s *Swarm) SetConnHandler(handler inet.ConnHandler) {
+	s.connh.Store(handler)
+}
+
+// ConnHandler gets the handler for new connections.
+func (s *Swarm) ConnHandler() inet.ConnHandler {
+	handler, _ := s.connh.Load().(inet.ConnHandler)
+	return handler
+}
+
+// SetStreamHandler assigns the handler for new streams.
+func (s *Swarm) SetStreamHandler(handler inet.StreamHandler) {
+	s.streamh.Store(handler)
+}
+
+// StreamHandler gets the handler for new streams.
+func (s *Swarm) StreamHandler() inet.StreamHandler {
+	handler, _ := s.streamh.Load().(inet.StreamHandler)
+	return handler
+}
+
+// NewStream creates a new stream on any available connection to peer, dialing
+// if necessary.
+func (s *Swarm) NewStream(ctx context.Context, p peer.ID) (inet.Stream, error) {
+	log.Debugf("[%s] opening stream to peer [%s]", s.local, p)
+
+	// Algorithm:
+	// 1. Find the best connection, otherwise, dial.
+	// 2. Try opening a stream.
+	// 3. If the underlying connection is, in fact, closed, close the outer
+	//    connection and try again. We do this in case we have a closed
+	//    connection but don't notice it until we actually try to open a
+	//    stream.
+	//
+	// Note: We only dial once.
+	//
+	// TODO: Try all connections even if we get an error opening a stream on
+	// a non-closed connection.
+	dials := 0
+	for {
+		c := s.bestConnToPeer(p)
+		if c == nil {
+			if dials >= DialAttempts {
+				return nil, errors.New("max dial attempts exceeded")
+			}
+			dials++
+
+			var err error
+			c, err = s.dialPeer(ctx, p)
+			if err != nil {
+				return nil, err
+			}
+		}
+		s, err := c.NewStream()
+		if err != nil {
+			if c.conn.IsClosed() {
+				continue
+			}
+			return nil, err
+		}
+		return s, nil
+	}
+}
+
+// ConnsToPeer returns all the live connections to peer.
+func (s *Swarm) ConnsToPeer(p peer.ID) []inet.Conn {
+	// TODO: Consider sorting the connection list best to worst. Currently,
+	// it's sorted oldest to newest.
+	s.conns.RLock()
+	defer s.conns.RUnlock()
+	conns := s.conns.m[p]
+	output := make([]inet.Conn, len(conns))
+	for i, c := range conns {
+		output[i] = c
+	}
+	return output
+}
+
+// bestConnToPeer returns the best connection to peer.
+func (s *Swarm) bestConnToPeer(p peer.ID) *Conn {
+	// Selects the best connection we have to the peer.
+	// TODO: Prefer some transports over others. Currently, we just select
+	// the newest non-closed connection with the most streams.
+	s.conns.RLock()
+	defer s.conns.RUnlock()
+
+	var best *Conn
+	bestLen := 0
+	for _, c := range s.conns.m[p] {
+		if c.conn.IsClosed() {
+			// We *will* garbage collect this soon anyways.
+			continue
+		}
+		c.streams.Lock()
+		cLen := len(c.streams.m)
+		c.streams.Unlock()
+
+		if cLen >= bestLen {
+			best = c
+			bestLen = cLen
+		}
+
+	}
+	return best
+}
+
+// Connectedness returns our "connectedness" state with the given peer.
+//
+// To check if we have an open connection, use `s.Connectedness(p) ==
+// inet.Connected`.
+func (s *Swarm) Connectedness(p peer.ID) inet.Connectedness {
+	if s.bestConnToPeer(p) != nil {
+		return inet.Connected
+	}
+	return inet.NotConnected
+}
+
+// Conns returns a slice of all connections.
+func (s *Swarm) Conns() []inet.Conn {
+	s.conns.RLock()
+	defer s.conns.RUnlock()
+
+	conns := make([]inet.Conn, 0, len(s.conns.m))
+	for _, cs := range s.conns.m {
+		for _, c := range cs {
+			conns = append(conns, c)
+		}
+	}
+	return conns
+}
+
+// ClosePeer closes all connections to the given peer.
+func (s *Swarm) ClosePeer(p peer.ID) error {
+	conns := s.ConnsToPeer(p)
+	switch len(conns) {
+	case 0:
+		return nil
+	case 1:
+		return conns[0].Close()
+	default:
+		errCh := make(chan error)
+		for _, c := range conns {
+			go func(c inet.Conn) {
+				errCh <- c.Close()
+			}(c)
+		}
+
+		var errs []string
+		for _ = range conns {
+			err := <-errCh
+			if err != nil {
+				errs = append(errs, err.Error())
+			}
+		}
+		if len(errs) > 0 {
+			return fmt.Errorf("when disconnecting from peer %s: %s", p, strings.Join(errs, ", "))
+		}
+		return nil
+	}
+}
+
+// Peers returns a copy of the set of peers swarm is connected to.
+func (s *Swarm) Peers() []peer.ID {
+	s.conns.RLock()
+	defer s.conns.RUnlock()
+	peers := make([]peer.ID, 0, len(s.conns.m))
+	for p := range s.conns.m {
+		peers = append(peers, p)
+	}
+
+	return peers
+}
+
+// LocalPeer returns the local peer swarm is associated to.
+func (s *Swarm) LocalPeer() peer.ID {
+	return s.local
+}
+
+// Backoff returns the DialBackoff object for this swarm.
+func (s *Swarm) Backoff() *DialBackoff {
+	return &s.backf
+}
+
+// notifyAll sends a signal to all Notifiees
+func (s *Swarm) notifyAll(notify func(inet.Notifiee)) {
+	var wg sync.WaitGroup
+
+	s.notifs.RLock()
+	wg.Add(len(s.notifs.m))
+	for f := range s.notifs.m {
+		go func(f inet.Notifiee) {
+			defer wg.Done()
+			notify(f)
+		}(f)
+	}
+
+	wg.Wait()
+	s.notifs.RUnlock()
+}
+
+// Notify signs up Notifiee to receive signals when events happen
+func (s *Swarm) Notify(f inet.Notifiee) {
+	s.notifs.Lock()
+	s.notifs.m[f] = struct{}{}
+	s.notifs.Unlock()
+}
+
+// StopNotify unregisters Notifiee fromr receiving signals
+func (s *Swarm) StopNotify(f inet.Notifiee) {
+	s.notifs.Lock()
+	delete(s.notifs.m, f)
+	s.notifs.Unlock()
+}
+
+func (s *Swarm) removeConn(c *Conn) {
+	p := c.RemotePeer()
+
+	s.conns.Lock()
+	defer s.conns.Unlock()
+	cs := s.conns.m[p]
+	for i, ci := range cs {
+		if ci == c {
+			if len(cs) == 1 {
+				delete(s.conns.m, p)
+			} else {
+				// NOTE: We're intentionally preserving order.
+				// This way, connections to a peer are always
+				// sorted oldest to newest.
+				copy(cs[i:], cs[i+1:])
+				cs[len(cs)-1] = nil
+				s.conns.m[p] = cs[:len(cs)-1]
+			}
+			return
+		}
+	}
+}
+
+// String returns a string representation of Network.
+func (s *Swarm) String() string {
+	return fmt.Sprintf("<Swarm %s>", s.LocalPeer())
+}
+
+// Swarm is a Network.
+var _ inet.Network = (*Swarm)(nil)
+var _ transport.Network = (*Swarm)(nil)
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_addr.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_addr.go
new file mode 100644
index 000000000..c86d58bb4
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_addr.go
@@ -0,0 +1,24 @@
+package swarm
+
+import (
+	addrutil "github.com/libp2p/go-addr-util"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// ListenAddresses returns a list of addresses at which this swarm listens.
+func (s *Swarm) ListenAddresses() []ma.Multiaddr {
+	s.listeners.RLock()
+	defer s.listeners.RUnlock()
+	addrs := make([]ma.Multiaddr, 0, len(s.listeners.m))
+	for l := range s.listeners.m {
+		addrs = append(addrs, l.Multiaddr())
+	}
+	return addrs
+}
+
+// InterfaceListenAddresses returns a list of addresses at which this swarm
+// listens. It expands "any interface" addresses (/ip4/0.0.0.0, /ip6/::) to
+// use the known local interfaces.
+func (s *Swarm) InterfaceListenAddresses() ([]ma.Multiaddr, error) {
+	return addrutil.ResolveUnspecifiedAddresses(s.ListenAddresses(), nil)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_conn.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_conn.go
new file mode 100644
index 000000000..5b2420cd5
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_conn.go
@@ -0,0 +1,213 @@
+package swarm
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	ic "github.com/libp2p/go-libp2p-crypto"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	transport "github.com/libp2p/go-libp2p-transport"
+	smux "github.com/libp2p/go-stream-muxer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// TODO: Put this elsewhere.
+
+// ErrConnClosed is returned when operating on a closed connection.
+var ErrConnClosed = errors.New("connection closed")
+
+// Conn is the connection type used by swarm. In general, you won't use this
+// type directly.
+type Conn struct {
+	conn  transport.Conn
+	swarm *Swarm
+
+	closeOnce sync.Once
+	err       error
+
+	notifyLk sync.Mutex
+
+	streams struct {
+		sync.Mutex
+		m map[*Stream]struct{}
+	}
+}
+
+// Close closes this connection.
+//
+// Note: This method won't wait for the close notifications to finish as that
+// would create a deadlock when called from an open notification (because all
+// open notifications must finish before we can fire off the close
+// notifications).
+func (c *Conn) Close() error {
+	c.closeOnce.Do(c.doClose)
+	return c.err
+}
+
+func (c *Conn) doClose() {
+	c.swarm.removeConn(c)
+
+	// Prevent new streams from opening.
+	c.streams.Lock()
+	streams := c.streams.m
+	c.streams.m = nil
+	c.streams.Unlock()
+
+	c.err = c.conn.Close()
+
+	// This is just for cleaning up state. The connection has already been closed.
+	// We *could* optimize this but it really isn't worth it.
+	for s := range streams {
+		s.Reset()
+	}
+
+	// do this in a goroutine to avoid deadlocking if we call close in an open notification.
+	go func() {
+		// prevents us from issuing close notifications before finishing the open notifications
+		c.notifyLk.Lock()
+		defer c.notifyLk.Unlock()
+
+		c.swarm.notifyAll(func(f inet.Notifiee) {
+			f.Disconnected(c.swarm, c)
+		})
+		c.swarm.refs.Done() // taken in Swarm.addConn
+	}()
+}
+
+func (c *Conn) removeStream(s *Stream) {
+	c.streams.Lock()
+	delete(c.streams.m, s)
+	c.streams.Unlock()
+}
+
+// listens for new streams.
+//
+// The caller must take a swarm ref before calling. This function decrements the
+// swarm ref count.
+func (c *Conn) start() {
+	go func() {
+		defer c.swarm.refs.Done()
+		defer c.Close()
+
+		for {
+			ts, err := c.conn.AcceptStream()
+			if err != nil {
+				return
+			}
+			c.swarm.refs.Add(1)
+			go func() {
+				s, err := c.addStream(ts)
+
+				// Don't defer this. We don't want to block
+				// swarm shutdown on the connection handler.
+				c.swarm.refs.Done()
+
+				// We only get an error here when the swarm is closed or closing.
+				if err != nil {
+					return
+				}
+
+				if h := c.swarm.StreamHandler(); h != nil {
+					h(s)
+				}
+			}()
+		}
+	}()
+}
+
+func (c *Conn) String() string {
+	return fmt.Sprintf(
+		"<swarm.Conn[%s] %s (%s) <-> %s (%s)>",
+		c.conn.Transport(),
+		c.conn.LocalMultiaddr(),
+		c.conn.LocalPeer().Pretty(),
+		c.conn.RemoteMultiaddr(),
+		c.conn.RemotePeer().Pretty(),
+	)
+}
+
+// LocalMultiaddr is the Multiaddr on this side
+func (c *Conn) LocalMultiaddr() ma.Multiaddr {
+	return c.conn.LocalMultiaddr()
+}
+
+// LocalPeer is the Peer on our side of the connection
+func (c *Conn) LocalPeer() peer.ID {
+	return c.conn.LocalPeer()
+}
+
+// RemoteMultiaddr is the Multiaddr on the remote side
+func (c *Conn) RemoteMultiaddr() ma.Multiaddr {
+	return c.conn.RemoteMultiaddr()
+}
+
+// RemotePeer is the Peer on the remote side
+func (c *Conn) RemotePeer() peer.ID {
+	return c.conn.RemotePeer()
+}
+
+// LocalPrivateKey is the public key of the peer on this side
+func (c *Conn) LocalPrivateKey() ic.PrivKey {
+	return c.conn.LocalPrivateKey()
+}
+
+// RemotePublicKey is the public key of the peer on the remote side
+func (c *Conn) RemotePublicKey() ic.PubKey {
+	return c.conn.RemotePublicKey()
+}
+
+// NewStream returns a new Stream from this connection
+func (c *Conn) NewStream() (inet.Stream, error) {
+	ts, err := c.conn.OpenStream()
+	if err != nil {
+		return nil, err
+	}
+	return c.addStream(ts)
+}
+
+func (c *Conn) addStream(ts smux.Stream) (*Stream, error) {
+	c.streams.Lock()
+	// Are we still online?
+	if c.streams.m == nil {
+		c.streams.Unlock()
+		ts.Reset()
+		return nil, ErrConnClosed
+	}
+
+	// Wrap and register the stream.
+	s := &Stream{
+		stream: ts,
+		conn:   c,
+	}
+	c.streams.m[s] = struct{}{}
+
+	// Released once the stream disconnect notifications have finished
+	// firing (in Swarm.remove).
+	c.swarm.refs.Add(1)
+
+	// Take the notification lock before releasing the streams lock to block
+	// StreamClose notifications until after the StreamOpen notifications
+	// done.
+	s.notifyLk.Lock()
+	c.streams.Unlock()
+
+	c.swarm.notifyAll(func(f inet.Notifiee) {
+		f.OpenedStream(c.swarm, s)
+	})
+	s.notifyLk.Unlock()
+
+	return s, nil
+}
+
+// GetStreams returns the streams associated with this connection.
+func (c *Conn) GetStreams() []inet.Stream {
+	c.streams.Lock()
+	defer c.streams.Unlock()
+	streams := make([]inet.Stream, 0, len(c.streams.m))
+	for s := range c.streams.m {
+		streams = append(streams, s)
+	}
+	return streams
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_dial.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_dial.go
new file mode 100644
index 000000000..59adb037c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_dial.go
@@ -0,0 +1,423 @@
+package swarm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	addrutil "github.com/libp2p/go-addr-util"
+	lgbl "github.com/libp2p/go-libp2p-loggables"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	transport "github.com/libp2p/go-libp2p-transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// Diagram of dial sync:
+//
+//   many callers of Dial()   synched w.  dials many addrs       results to callers
+//  ----------------------\    dialsync    use earliest            /--------------
+//  -----------------------\              |----------\           /----------------
+//  ------------------------>------------<-------     >---------<-----------------
+//  -----------------------|              \----x                 \----------------
+//  ----------------------|                \-----x                \---------------
+//                                         any may fail          if no addr at end
+//                                                             retry dialAttempt x
+
+var (
+	// ErrDialBackoff is returned by the backoff code when a given peer has
+	// been dialed too frequently
+	ErrDialBackoff = errors.New("dial backoff")
+
+	// ErrDialFailed is returned when connecting to a peer has ultimately failed
+	ErrDialFailed = errors.New("dial attempt failed")
+
+	// ErrDialToSelf is returned if we attempt to dial our own peer
+	ErrDialToSelf = errors.New("dial to self attempted")
+
+	// ErrNoTransport is returned when we don't know a transport for the
+	// given multiaddr.
+	ErrNoTransport = errors.New("no transport for protocol")
+)
+
+// DialAttempts governs how many times a goroutine will try to dial a given peer.
+// Note: this is down to one, as we have _too many dials_ atm. To add back in,
+// add loop back in Dial(.)
+const DialAttempts = 1
+
+// ConcurrentFdDials is the number of concurrent outbound dials over transports
+// that consume file descriptors
+const ConcurrentFdDials = 160
+
+// DefaultPerPeerRateLimit is the number of concurrent outbound dials to make
+// per peer
+const DefaultPerPeerRateLimit = 8
+
+// dialbackoff is a struct used to avoid over-dialing the same, dead peers.
+// Whenever we totally time out on a peer (all three attempts), we add them
+// to dialbackoff. Then, whenevers goroutines would _wait_ (dialsync), they
+// check dialbackoff. If it's there, they don't wait and exit promptly with
+// an error. (the single goroutine that is actually dialing continues to
+// dial). If a dial is successful, the peer is removed from backoff.
+// Example:
+//
+//  for {
+//  	if ok, wait := dialsync.Lock(p); !ok {
+//  		if backoff.Backoff(p) {
+//  			return errDialFailed
+//  		}
+//  		<-wait
+//  		continue
+//  	}
+//  	defer dialsync.Unlock(p)
+//  	c, err := actuallyDial(p)
+//  	if err != nil {
+//  		dialbackoff.AddBackoff(p)
+//  		continue
+//  	}
+//  	dialbackoff.Clear(p)
+//  }
+//
+
+// DialBackoff is a type for tracking peer dial backoffs.
+//
+// * It's safe to use it's zero value.
+// * It's thread-safe.
+// * It's *not* safe to move this type after using.
+type DialBackoff struct {
+	entries map[peer.ID]*backoffPeer
+	lock    sync.RWMutex
+}
+
+type backoffPeer struct {
+	tries int
+	until time.Time
+}
+
+func (db *DialBackoff) init() {
+	if db.entries == nil {
+		db.entries = make(map[peer.ID]*backoffPeer)
+	}
+}
+
+// Backoff returns whether the client should backoff from dialing
+// peer p
+func (db *DialBackoff) Backoff(p peer.ID) (backoff bool) {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+	db.init()
+	bp, found := db.entries[p]
+	if found && time.Now().Before(bp.until) {
+		return true
+	}
+
+	return false
+}
+
+// BackoffBase is the base amount of time to backoff (default: 5s).
+var BackoffBase = time.Second * 5
+
+// BackoffCoef is the backoff coefficient (default: 1s).
+var BackoffCoef = time.Second
+
+// BackoffMax is the maximum backoff time (default: 5m).
+var BackoffMax = time.Minute * 5
+
+// AddBackoff lets other nodes know that we've entered backoff with
+// peer p, so dialers should not wait unnecessarily. We still will
+// attempt to dial with one goroutine, in case we get through.
+//
+// Backoff is not exponential, it's quadratic and computed according to the
+// following formula:
+//
+//     BackoffBase + BakoffCoef * PriorBackoffs^2
+//
+// Where PriorBackoffs is the number of previous backoffs.
+func (db *DialBackoff) AddBackoff(p peer.ID) {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+	db.init()
+	bp, ok := db.entries[p]
+	if !ok {
+		db.entries[p] = &backoffPeer{
+			tries: 1,
+			until: time.Now().Add(BackoffBase),
+		}
+		return
+	}
+
+	backoffTime := BackoffBase + BackoffCoef*time.Duration(bp.tries*bp.tries)
+	if backoffTime > BackoffMax {
+		backoffTime = BackoffMax
+	}
+	bp.until = time.Now().Add(backoffTime)
+	bp.tries++
+}
+
+// Clear removes a backoff record. Clients should call this after a
+// successful Dial.
+func (db *DialBackoff) Clear(p peer.ID) {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+	db.init()
+	delete(db.entries, p)
+}
+
+// DialPeer connects to a peer.
+//
+// The idea is that the client of Swarm does not need to know what network
+// the connection will happen over. Swarm can use whichever it choses.
+// This allows us to use various transport protocols, do NAT traversal/relay,
+// etc. to achieve connection.
+func (s *Swarm) DialPeer(ctx context.Context, p peer.ID) (inet.Conn, error) {
+	return s.dialPeer(ctx, p)
+}
+
+// internal dial method that returns an unwrapped conn
+//
+// It is gated by the swarm's dial synchronization systems: dialsync and
+// dialbackoff.
+func (s *Swarm) dialPeer(ctx context.Context, p peer.ID) (*Conn, error) {
+	log.Debugf("[%s] swarm dialing peer [%s]", s.local, p)
+	var logdial = lgbl.Dial("swarm", s.LocalPeer(), p, nil, nil)
+	if p == s.local {
+		log.Event(ctx, "swarmDialSelf", logdial)
+		return nil, ErrDialToSelf
+	}
+
+	defer log.EventBegin(ctx, "swarmDialAttemptSync", p).Done()
+
+	// check if we already have an open connection first
+	conn := s.bestConnToPeer(p)
+	if conn != nil {
+		return conn, nil
+	}
+
+	// if this peer has been backed off, lets get out of here
+	if s.backf.Backoff(p) {
+		log.Event(ctx, "swarmDialBackoff", p)
+		return nil, ErrDialBackoff
+	}
+
+	// apply the DialPeer timeout
+	ctx, cancel := context.WithTimeout(ctx, inet.GetDialPeerTimeout(ctx))
+	defer cancel()
+
+	conn, err := s.dsync.DialLock(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugf("network for %s finished dialing %s", s.local, p)
+	return conn, err
+}
+
+// doDial is an ugly shim method to retain all the logging and backoff logic
+// of the old dialsync code
+func (s *Swarm) doDial(ctx context.Context, p peer.ID) (*Conn, error) {
+	// Short circuit.
+	// By the time we take the dial lock, we may already *have* a connection
+	// to the peer.
+	c := s.bestConnToPeer(p)
+	if c != nil {
+		return c, nil
+	}
+
+	logdial := lgbl.Dial("swarm", s.LocalPeer(), p, nil, nil)
+
+	// ok, we have been charged to dial! let's do it.
+	// if it succeeds, dial will add the conn to the swarm itself.
+	defer log.EventBegin(ctx, "swarmDialAttemptStart", logdial).Done()
+
+	conn, err := s.dial(ctx, p)
+	if err != nil {
+		conn = s.bestConnToPeer(p)
+		if conn != nil {
+			// Hm? What error?
+			// Could have canceled the dial because we received a
+			// connection or some other random reason.
+			// Just ignore the error and return the connection.
+			log.Debugf("ignoring dial error because we have a connection: %s", err)
+			return conn, nil
+		}
+		if err != context.Canceled {
+			log.Event(ctx, "swarmDialBackoffAdd", logdial)
+			s.backf.AddBackoff(p) // let others know to backoff
+		}
+
+		// ok, we failed.
+		return nil, fmt.Errorf("dial attempt failed: %s", err)
+	}
+	return conn, nil
+}
+
+func (s *Swarm) canDial(addr ma.Multiaddr) bool {
+	t := s.TransportForDialing(addr)
+	return t != nil && t.CanDial(addr)
+}
+
+// dial is the actual swarm's dial logic, gated by Dial.
+func (s *Swarm) dial(ctx context.Context, p peer.ID) (*Conn, error) {
+	var logdial = lgbl.Dial("swarm", s.LocalPeer(), p, nil, nil)
+	if p == s.local {
+		log.Event(ctx, "swarmDialDoDialSelf", logdial)
+		return nil, ErrDialToSelf
+	}
+	defer log.EventBegin(ctx, "swarmDialDo", logdial).Done()
+	logdial["dial"] = "failure" // start off with failure. set to "success" at the end.
+
+	sk := s.peers.PrivKey(s.local)
+	logdial["encrypted"] = (sk != nil) // log wether this will be an encrypted dial or not.
+	if sk == nil {
+		// fine for sk to be nil, just log.
+		log.Debug("Dial not given PrivateKey, so WILL NOT SECURE conn.")
+	}
+
+	ila, _ := s.InterfaceListenAddresses()
+	subtractFilter := addrutil.SubtractFilter(append(ila, s.peers.Addrs(s.local)...)...)
+
+	// get live channel of addresses for peer, filtered by the given filters
+	/*
+		remoteAddrChan := s.peers.AddrsChan(ctx, p,
+			addrutil.AddrUsableFilter,
+			subtractFilter,
+			s.Filters.AddrBlocked)
+	*/
+
+	//////
+	/*
+		This code is temporary, the peerstore can currently provide
+		a channel as an interface for receiving addresses, but more thought
+		needs to be put into the execution. For now, this allows us to use
+		the improved rate limiter, while maintaining the outward behaviour
+		that we previously had (halting a dial when we run out of addrs)
+	*/
+	paddrs := s.peers.Addrs(p)
+	goodAddrs := addrutil.FilterAddrs(paddrs,
+		subtractFilter,
+		s.canDial,
+		// TODO: Consider allowing this?
+		addrutil.AddrOverNonLocalIP,
+		addrutil.FilterNeg(s.Filters.AddrBlocked),
+	)
+	remoteAddrChan := make(chan ma.Multiaddr, len(goodAddrs))
+	for _, a := range goodAddrs {
+		remoteAddrChan <- a
+	}
+	close(remoteAddrChan)
+	/////////
+
+	// try to get a connection to any addr
+	connC, err := s.dialAddrs(ctx, p, remoteAddrChan)
+	if err != nil {
+		logdial["error"] = err.Error()
+		return nil, err
+	}
+	logdial["conn"] = logging.Metadata{
+		"localAddr":  connC.LocalMultiaddr(),
+		"remoteAddr": connC.RemoteMultiaddr(),
+	}
+	swarmC, err := s.addConn(connC)
+	if err != nil {
+		logdial["error"] = err.Error()
+		connC.Close() // close the connection. didn't work out :(
+		return nil, err
+	}
+
+	logdial["dial"] = "success"
+	return swarmC, nil
+}
+
+func (s *Swarm) dialAddrs(ctx context.Context, p peer.ID, remoteAddrs <-chan ma.Multiaddr) (transport.Conn, error) {
+	log.Debugf("%s swarm dialing %s", s.local, p)
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel() // cancel work when we exit func
+
+	// use a single response type instead of errs and conns, reduces complexity *a ton*
+	respch := make(chan dialResult)
+
+	defaultDialFail := fmt.Errorf("failed to dial %s (default failure)", p)
+	exitErr := defaultDialFail
+
+	defer s.limiter.clearAllPeerDials(p)
+
+	var active int
+	for {
+		select {
+		case addr, ok := <-remoteAddrs:
+			if !ok {
+				remoteAddrs = nil
+				if active == 0 {
+					return nil, exitErr
+				}
+				continue
+			}
+
+			s.limitedDial(ctx, p, addr, respch)
+			active++
+		case <-ctx.Done():
+			if exitErr == defaultDialFail {
+				exitErr = ctx.Err()
+			}
+			return nil, exitErr
+		case resp := <-respch:
+			active--
+			if resp.Err != nil {
+				log.Infof("got error on dial to %s: %s", resp.Addr, resp.Err)
+				// Errors are normal, lots of dials will fail
+				exitErr = resp.Err
+
+				if remoteAddrs == nil && active == 0 {
+					return nil, exitErr
+				}
+			} else if resp.Conn != nil {
+				return resp.Conn, nil
+			}
+		}
+	}
+}
+
+// limitedDial will start a dial to the given peer when
+// it is able, respecting the various different types of rate
+// limiting that occur without using extra goroutines per addr
+func (s *Swarm) limitedDial(ctx context.Context, p peer.ID, a ma.Multiaddr, resp chan dialResult) {
+	s.limiter.AddDialJob(&dialJob{
+		addr: a,
+		peer: p,
+		resp: resp,
+		ctx:  ctx,
+	})
+}
+
+func (s *Swarm) dialAddr(ctx context.Context, p peer.ID, addr ma.Multiaddr) (transport.Conn, error) {
+	// Just to double check. Costs nothing.
+	if s.local == p {
+		return nil, ErrDialToSelf
+	}
+	log.Debugf("%s swarm dialing %s %s", s.local, p, addr)
+
+	tpt := s.TransportForDialing(addr)
+	if tpt == nil {
+		return nil, ErrNoTransport
+	}
+
+	connC, err := tpt.Dial(ctx, addr, p)
+	if err != nil {
+		return nil, fmt.Errorf("%s --> %s dial attempt failed: %s", s.local, p, err)
+	}
+
+	// Trust the transport? Yeah... right.
+	if connC.RemotePeer() != p {
+		connC.Close()
+		err = fmt.Errorf("BUG in transport %T: tried to dial %s, dialed %s", p, connC.RemotePeer(), tpt)
+		log.Error(err)
+		return nil, err
+	}
+
+	// success! we got one!
+	return connC, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_listen.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_listen.go
new file mode 100644
index 000000000..df0a97f24
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_listen.go
@@ -0,0 +1,94 @@
+package swarm
+
+import (
+	"fmt"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// Listen sets up listeners for all of the given addresses.
+// It returns as long as we successfully listen on at least *one* address.
+func (s *Swarm) Listen(addrs ...ma.Multiaddr) error {
+	errs := make([]error, len(addrs))
+	var succeeded int
+	for i, a := range addrs {
+		if err := s.AddListenAddr(a); err != nil {
+			errs[i] = err
+		} else {
+			succeeded++
+		}
+	}
+
+	for i, e := range errs {
+		if e != nil {
+			log.Warningf("listen on %s failed: %s", addrs[i], errs[i])
+		}
+	}
+
+	if succeeded == 0 && len(addrs) > 0 {
+		return fmt.Errorf("failed to listen on any addresses: %s", errs)
+	}
+
+	return nil
+}
+
+// AddListenAddr tells the swarm to listen on a single address. Unlike Listen,
+// this method does not attempt to filter out bad addresses.
+func (s *Swarm) AddListenAddr(a ma.Multiaddr) error {
+	tpt := s.TransportForListening(a)
+	if tpt == nil {
+		return ErrNoTransport
+	}
+
+	list, err := tpt.Listen(a)
+	if err != nil {
+		return err
+	}
+
+	s.listeners.Lock()
+	if s.listeners.m == nil {
+		s.listeners.Unlock()
+		list.Close()
+		return ErrSwarmClosed
+	}
+	s.refs.Add(1)
+	s.listeners.m[list] = struct{}{}
+	s.listeners.Unlock()
+
+	maddr := list.Multiaddr()
+
+	// signal to our notifiees on successful conn.
+	s.notifyAll(func(n inet.Notifiee) {
+		n.Listen(s, maddr)
+	})
+
+	go func() {
+		defer func() {
+			list.Close()
+			s.listeners.Lock()
+			delete(s.listeners.m, list)
+			s.listeners.Unlock()
+			s.refs.Done()
+		}()
+		for {
+			c, err := list.Accept()
+			if err != nil {
+				log.Warningf("swarm listener accept error: %s", err)
+				return
+			}
+			log.Debugf("swarm listener accepted connection: %s", c)
+			s.refs.Add(1)
+			go func() {
+				defer s.refs.Done()
+				_, err := s.addConn(c)
+				if err != nil {
+					// Probably just means that the swarm has been closed.
+					log.Warningf("add conn failed: ", err)
+					return
+				}
+			}()
+		}
+	}()
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_stream.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_stream.go
new file mode 100644
index 000000000..30b44bd28
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_stream.go
@@ -0,0 +1,167 @@
+package swarm
+
+import (
+	"fmt"
+	"io"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+	smux "github.com/libp2p/go-stream-muxer"
+)
+
+type streamState int
+
+const (
+	streamOpen streamState = iota
+	streamCloseRead
+	streamCloseWrite
+	streamCloseBoth
+	streamReset
+)
+
+// Stream is the stream type used by swarm. In general, you won't use this type
+// directly.
+type Stream struct {
+	stream smux.Stream
+	conn   *Conn
+
+	state struct {
+		sync.Mutex
+		v streamState
+	}
+
+	notifyLk sync.Mutex
+
+	protocol atomic.Value
+}
+
+func (s *Stream) String() string {
+	return fmt.Sprintf(
+		"<swarm.Stream[%s] %s (%s) <-> %s (%s)>",
+		s.conn.conn.Transport(),
+		s.conn.LocalMultiaddr(),
+		s.conn.LocalPeer(),
+		s.conn.RemoteMultiaddr(),
+		s.conn.RemotePeer(),
+	)
+}
+
+// Conn returns the Conn associated with this stream, as an inet.Conn
+func (s *Stream) Conn() inet.Conn {
+	return s.conn
+}
+
+// Read reads bytes from a stream.
+func (s *Stream) Read(p []byte) (int, error) {
+	n, err := s.stream.Read(p)
+	// TODO: push this down to a lower level for better accuracy.
+	if s.conn.swarm.bwc != nil {
+		s.conn.swarm.bwc.LogRecvMessage(int64(n))
+		s.conn.swarm.bwc.LogRecvMessageStream(int64(n), s.Protocol(), s.Conn().RemotePeer())
+	}
+	// If we observe an EOF, this stream is now closed for reading.
+	// If we're already closed for writing, this stream is now fully closed.
+	if err == io.EOF {
+		s.state.Lock()
+		switch s.state.v {
+		case streamCloseWrite:
+			s.state.v = streamCloseBoth
+			s.remove()
+		case streamOpen:
+			s.state.v = streamCloseRead
+		}
+		s.state.Unlock()
+	}
+	return n, err
+}
+
+// Write writes bytes to a stream, flushing for each call.
+func (s *Stream) Write(p []byte) (int, error) {
+	n, err := s.stream.Write(p)
+	// TODO: push this down to a lower level for better accuracy.
+	if s.conn.swarm.bwc != nil {
+		s.conn.swarm.bwc.LogSentMessage(int64(n))
+		s.conn.swarm.bwc.LogSentMessageStream(int64(n), s.Protocol(), s.Conn().RemotePeer())
+	}
+	return n, err
+}
+
+// Close closes the stream, indicating this side is finished
+// with the stream.
+func (s *Stream) Close() error {
+	err := s.stream.Close()
+
+	s.state.Lock()
+	switch s.state.v {
+	case streamCloseRead:
+		s.state.v = streamCloseBoth
+		s.remove()
+	case streamOpen:
+		s.state.v = streamCloseWrite
+	}
+	s.state.Unlock()
+	return err
+}
+
+// Reset resets the stream, closing both ends.
+func (s *Stream) Reset() error {
+	err := s.stream.Reset()
+	s.state.Lock()
+	switch s.state.v {
+	case streamOpen, streamCloseRead, streamCloseWrite:
+		s.state.v = streamReset
+		s.remove()
+	}
+	s.state.Unlock()
+	return err
+}
+
+func (s *Stream) remove() {
+	s.conn.removeStream(s)
+
+	// We *must* do this in a goroutine. This can be called during a
+	// an open notification and will block until that notification is done.
+	go func() {
+		s.notifyLk.Lock()
+		defer s.notifyLk.Unlock()
+
+		s.conn.swarm.notifyAll(func(f inet.Notifiee) {
+			f.ClosedStream(s.conn.swarm, s)
+		})
+		s.conn.swarm.refs.Done()
+	}()
+}
+
+// Protocol returns the protocol negotiated on this stream (if set).
+func (s *Stream) Protocol() protocol.ID {
+	// Ignore type error. It means that the protocol is unset.
+	p, _ := s.protocol.Load().(protocol.ID)
+	return p
+}
+
+// SetProtocol sets the protocol for this stream.
+//
+// This doesn't actually *do* anything other than record the fact that we're
+// speaking the given protocol over this stream. It's still up to the user to
+// negotiate the protocol. This is usually done by the Host.
+func (s *Stream) SetProtocol(p protocol.ID) {
+	s.protocol.Store(p)
+}
+
+// SetDeadline sets the read and write deadlines for this stream.
+func (s *Stream) SetDeadline(t time.Time) error {
+	return s.stream.SetDeadline(t)
+}
+
+// SetReadDeadline sets the read deadline for this stream.
+func (s *Stream) SetReadDeadline(t time.Time) error {
+	return s.stream.SetReadDeadline(t)
+}
+
+// SetWriteDeadline sets the write deadline for this stream.
+func (s *Stream) SetWriteDeadline(t time.Time) error {
+	return s.stream.SetWriteDeadline(t)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-swarm/swarm_transport.go b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_transport.go
new file mode 100644
index 000000000..bc60dcf99
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-swarm/swarm_transport.go
@@ -0,0 +1,87 @@
+package swarm
+
+import (
+	"fmt"
+	"strings"
+
+	transport "github.com/libp2p/go-libp2p-transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// TransportForDialing retrieves the appropriate transport for dialing the given
+// multiaddr.
+func (s *Swarm) TransportForDialing(a ma.Multiaddr) transport.Transport {
+	protocols := a.Protocols()
+	if len(protocols) == 0 {
+		return nil
+	}
+
+	s.transports.RLock()
+	defer s.transports.RUnlock()
+	for _, p := range protocols {
+		transport, ok := s.transports.m[p.Code]
+		if !ok {
+			continue
+		}
+		if transport.Proxy() {
+			return transport
+		}
+	}
+
+	return s.transports.m[protocols[len(protocols)-1].Code]
+}
+
+// TransportForListening retrieves the appropriate transport for listening on
+// the given multiaddr.
+func (s *Swarm) TransportForListening(a ma.Multiaddr) transport.Transport {
+	protocols := a.Protocols()
+	if len(protocols) == 0 {
+		return nil
+	}
+
+	s.transports.RLock()
+	defer s.transports.RUnlock()
+	selected := s.transports.m[protocols[len(protocols)-1].Code]
+	for _, p := range protocols {
+		transport, ok := s.transports.m[p.Code]
+		if !ok {
+			continue
+		}
+		if transport.Proxy() {
+			selected = transport
+		}
+	}
+	return selected
+}
+
+// AddTransport adds a transport to this swarm.
+//
+// Satisfies the Network interface from go-libp2p-transport.
+func (s *Swarm) AddTransport(t transport.Transport) error {
+	protocols := t.Protocols()
+
+	s.transports.Lock()
+	defer s.transports.Unlock()
+	var registered []string
+	for _, p := range protocols {
+		if _, ok := s.transports.m[p]; ok {
+			proto := ma.ProtocolWithCode(p)
+			name := proto.Name
+			if name == "" {
+				name = fmt.Sprintf("unknown (%d)", p)
+			}
+			registered = append(registered, name)
+		}
+	}
+	if len(registered) > 0 {
+		return fmt.Errorf(
+			"transports already registered for protocol(s): %s",
+			strings.Join(registered, ", "),
+		)
+	}
+
+	for _, p := range protocols {
+		s.transports.m[p] = t
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-transport-upgrader/LICENSE b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/LICENSE
new file mode 100644
index 000000000..6cccfc2ba
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Protocol Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-transport-upgrader/conn.go b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/conn.go
new file mode 100644
index 000000000..48e481416
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/conn.go
@@ -0,0 +1,35 @@
+package stream
+
+import (
+	"fmt"
+
+	inet "github.com/libp2p/go-libp2p-net"
+	transport "github.com/libp2p/go-libp2p-transport"
+	smux "github.com/libp2p/go-stream-muxer"
+)
+
+type transportConn struct {
+	smux.Conn
+	inet.ConnMultiaddrs
+	inet.ConnSecurity
+	transport transport.Transport
+}
+
+func (t *transportConn) Transport() transport.Transport {
+	return t.transport
+}
+
+func (t *transportConn) String() string {
+	ts := ""
+	if s, ok := t.transport.(fmt.Stringer); ok {
+		ts = "[" + s.String() + "]"
+	}
+	return fmt.Sprintf(
+		"<stream.Conn%s %s (%s) <-> %s (%s)>",
+		ts,
+		t.LocalMultiaddr(),
+		t.LocalPeer(),
+		t.RemoteMultiaddr(),
+		t.RemotePeer(),
+	)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-transport-upgrader/listener.go b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/listener.go
new file mode 100644
index 000000000..fa26825fd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/listener.go
@@ -0,0 +1,159 @@
+package stream
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	logging "github.com/ipfs/go-log"
+	tec "github.com/jbenet/go-temp-err-catcher"
+	transport "github.com/libp2p/go-libp2p-transport"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+var log = logging.Logger("stream-upgrader")
+
+type connErr struct {
+	conn transport.Conn
+	err  error
+}
+
+type listener struct {
+	manet.Listener
+
+	transport transport.Transport
+	upgrader  *Upgrader
+
+	incoming chan transport.Conn
+	err      error
+
+	// Used for backpressure
+	threshold *threshold
+
+	// Canceling this context isn't sufficient to tear down the listener.
+	// Call close.
+	ctx    context.Context
+	cancel func()
+}
+
+// Close closes the listener.
+func (l *listener) Close() error {
+	// Do this first to try to get any relevent errors.
+	err := l.Listener.Close()
+
+	l.cancel()
+	// Drain and wait.
+	for c := range l.incoming {
+		c.Close()
+	}
+	return err
+}
+
+// handles inbound connections.
+//
+// This function does a few interesting things that should be noted:
+//
+// 1. It logs and discards temporary/transient errors (errors with a Temporary()
+//    function that returns true).
+// 2. It stops accepting new connections once AcceptQueueLength connections have
+//    been fully negotiated but not accepted. This gives us a basic backpressure
+//    mechanism while still allowing us to negotiate connections in parallel.
+func (l *listener) handleIncoming() {
+	var wg sync.WaitGroup
+	defer func() {
+		// make sure we're closed
+		l.Listener.Close()
+		if l.err == nil {
+			l.err = fmt.Errorf("listener closed")
+		}
+
+		wg.Wait()
+		close(l.incoming)
+	}()
+
+	var catcher tec.TempErrCatcher
+	for l.ctx.Err() == nil {
+		maconn, err := l.Listener.Accept()
+		if err != nil {
+			// Note: function may pause the accept loop.
+			if catcher.IsTemporary(err) {
+				log.Infof("temporary accept error: %s", err)
+				continue
+			}
+			l.err = err
+			return
+		}
+
+		// The go routine below calls Release when the context is
+		// canceled so there's no need to wait on it here.
+		l.threshold.Wait()
+
+		log.Debugf("listener %s got connection: %s <---> %s",
+			l,
+			maconn.LocalMultiaddr(),
+			maconn.RemoteMultiaddr())
+
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			ctx, cancel := context.WithTimeout(l.ctx, transport.AcceptTimeout)
+			defer cancel()
+
+			conn, err := l.upgrader.UpgradeInbound(ctx, l.transport, maconn)
+			if err != nil {
+				// Don't bother bubbling this up. We just failed
+				// to completely negotiate the connection.
+				log.Debugf("accept upgrade error: %s (%s <--> %s)",
+					err,
+					maconn.LocalMultiaddr(),
+					maconn.RemoteMultiaddr())
+				return
+			}
+
+			log.Debugf("listener %s accepted connection: %s", l, conn)
+
+			// This records the fact that the connection has been
+			// setup and is waiting to be accepted. This call
+			// *never* blocks, even if we go over the threshold. It
+			// simply ensures that calls to Wait block while we're
+			// over the threshold.
+			l.threshold.Acquire()
+			defer l.threshold.Release()
+
+			select {
+			case l.incoming <- conn:
+			case <-ctx.Done():
+				if l.ctx.Err() == nil {
+					// Listener *not* closed but the accept timeout expired.
+					log.Warningf("listener dropped connection due to slow accept")
+				}
+				// Wait on the context with a timeout. This way,
+				// if we stop accepting connections for some reason,
+				// we'll eventually close all the open ones
+				// instead of hanging onto them.
+				conn.Close()
+			}
+		}()
+	}
+}
+
+// Accept accepts a connection.
+func (l *listener) Accept() (transport.Conn, error) {
+	for c := range l.incoming {
+		// Could have been sitting there for a while.
+		if !c.IsClosed() {
+			return c, nil
+		}
+	}
+	return nil, l.err
+}
+
+func (l *listener) String() string {
+	if s, ok := l.transport.(fmt.Stringer); ok {
+		return fmt.Sprintf("<stream.Listener[%s] %s>", s, l.Multiaddr())
+	}
+	return fmt.Sprintf("<stream.Listener %s>", l.Multiaddr())
+}
+
+var _ transport.Listener = (*listener)(nil)
diff --git a/vendor/github.com/libp2p/go-libp2p-transport-upgrader/threshold.go b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/threshold.go
new file mode 100644
index 000000000..2c278bd39
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/threshold.go
@@ -0,0 +1,50 @@
+package stream
+
+import (
+	"sync"
+)
+
+func newThreshold(cutoff int) *threshold {
+	t := &threshold{
+		threshold: cutoff,
+	}
+	t.cond.L = &t.mu
+	return t
+}
+
+type threshold struct {
+	mu   sync.Mutex
+	cond sync.Cond
+
+	count     int
+	threshold int
+}
+
+// Acquire increments the counter. It will not block.
+func (t *threshold) Acquire() {
+	t.mu.Lock()
+	t.count++
+	t.mu.Unlock()
+}
+
+// Release decrements the counter.
+func (t *threshold) Release() {
+	t.mu.Lock()
+	if t.count == 0 {
+		panic("negative count")
+	}
+	if t.threshold == t.count {
+		t.cond.Broadcast()
+	}
+	t.count--
+	t.mu.Unlock()
+}
+
+// Wait waits for the counter to drop below the threshold
+func (t *threshold) Wait() {
+	t.mu.Lock()
+	for t.count >= t.threshold {
+		t.cond.Wait()
+	}
+	t.mu.Unlock()
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-transport-upgrader/upgrader.go b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/upgrader.go
new file mode 100644
index 000000000..bfbfa7d01
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport-upgrader/upgrader.go
@@ -0,0 +1,127 @@
+package stream
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+
+	ss "github.com/libp2p/go-conn-security"
+	pnet "github.com/libp2p/go-libp2p-interface-pnet"
+	peer "github.com/libp2p/go-libp2p-peer"
+	transport "github.com/libp2p/go-libp2p-transport"
+	filter "github.com/libp2p/go-maddr-filter"
+	smux "github.com/libp2p/go-stream-muxer"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+// ErrNilPeer is returned when attempting to upgrade an outbound connection
+// without specifying a peer ID.
+var ErrNilPeer = errors.New("nil peer")
+
+// AcceptQueueLength is the number of connections to fully setup before not accepting any new connections
+var AcceptQueueLength = 16
+
+// Upgrader is a multistream upgrader that can upgrade an underlying connection
+// to a full transport connection (secure and multiplexed).
+type Upgrader struct {
+	Protector pnet.Protector
+	Secure    ss.Transport
+	Muxer     smux.Transport
+	Filters   *filter.Filters
+}
+
+// UpgradeListener upgrades the passed multiaddr-net listener into a full libp2p-transport listener.
+func (u *Upgrader) UpgradeListener(t transport.Transport, list manet.Listener) transport.Listener {
+	ctx, cancel := context.WithCancel(context.Background())
+	l := &listener{
+		Listener:  list,
+		upgrader:  u,
+		transport: t,
+		threshold: newThreshold(AcceptQueueLength),
+		incoming:  make(chan transport.Conn),
+		cancel:    cancel,
+		ctx:       ctx,
+	}
+	go l.handleIncoming()
+	return l
+}
+
+// UpgradeOutbound upgrades the given outbound multiaddr-net connection into a
+// full libp2p-transport connection.
+func (u *Upgrader) UpgradeOutbound(ctx context.Context, t transport.Transport, maconn manet.Conn, p peer.ID) (transport.Conn, error) {
+	if p == "" {
+		return nil, ErrNilPeer
+	}
+	return u.upgrade(ctx, t, maconn, p)
+}
+
+// UpgradeInbound upgrades the given inbound multiaddr-net connection into a
+// full libp2p-transport connection.
+func (u *Upgrader) UpgradeInbound(ctx context.Context, t transport.Transport, maconn manet.Conn) (transport.Conn, error) {
+	return u.upgrade(ctx, t, maconn, "")
+}
+
+func (u *Upgrader) upgrade(ctx context.Context, t transport.Transport, maconn manet.Conn, p peer.ID) (transport.Conn, error) {
+	if u.Filters != nil && u.Filters.AddrBlocked(maconn.RemoteMultiaddr()) {
+		log.Debugf("blocked connection from %s", maconn.RemoteMultiaddr())
+		maconn.Close()
+		return nil, fmt.Errorf("blocked connection from %s", maconn.RemoteMultiaddr())
+	}
+
+	var conn net.Conn = maconn
+	if u.Protector != nil {
+		pconn, err := u.Protector.Protect(conn)
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+		conn = pconn
+	} else if pnet.ForcePrivateNetwork {
+		log.Error("tried to dial with no Private Network Protector but usage" +
+			" of Private Networks is forced by the enviroment")
+		return nil, pnet.ErrNotInPrivateNetwork
+	}
+	sconn, err := u.setupSecurity(ctx, conn, p)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	smconn, err := u.setupMuxer(ctx, sconn, p)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return &transportConn{
+		Conn:           smconn,
+		ConnMultiaddrs: maconn,
+		ConnSecurity:   sconn,
+		transport:      t,
+	}, nil
+}
+
+func (u *Upgrader) setupSecurity(ctx context.Context, conn net.Conn, p peer.ID) (ss.Conn, error) {
+	if p == "" {
+		return u.Secure.SecureInbound(ctx, conn)
+	}
+	return u.Secure.SecureOutbound(ctx, conn, p)
+}
+
+func (u *Upgrader) setupMuxer(ctx context.Context, conn net.Conn, p peer.ID) (smux.Conn, error) {
+	// TODO: The muxer should take a context.
+	done := make(chan struct{})
+
+	var smconn smux.Conn
+	var err error
+	go func() {
+		defer close(done)
+		smconn, err = u.Muxer.NewConn(conn, p == "")
+	}()
+
+	select {
+	case <-done:
+		return smconn, err
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p-transport/LICENSE b/vendor/github.com/libp2p/go-libp2p-transport/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p-transport/transport.go b/vendor/github.com/libp2p/go-libp2p-transport/transport.go
new file mode 100644
index 000000000..e81428e26
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p-transport/transport.go
@@ -0,0 +1,97 @@
+package transport
+
+import (
+	"context"
+	"net"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	smux "github.com/libp2p/go-stream-muxer"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// DialTimeout is the maximum duration a Dial is allowed to take.
+// This includes the time between dialing the raw network connection,
+// protocol selection as well the handshake, if applicable.
+var DialTimeout = 60 * time.Second
+
+// AcceptTimeout is the maximum duration an Accept is allowed to take.
+// This includes the time between accepting the raw network connection,
+// protocol selection as well as the handshake, if applicable.
+var AcceptTimeout = 60 * time.Second
+
+var log = logging.Logger("transport")
+
+// Conn is an extension of the net.Conn interface that provides multiaddr
+// information, and an accessor for the transport used to create the conn
+type Conn interface {
+	smux.Conn
+	inet.ConnSecurity
+	inet.ConnMultiaddrs
+
+	// Transport returns the transport to which this connection belongs.
+	Transport() Transport
+}
+
+// Transport represents any device by which you can connect to and accept
+// connections from other peers. The built-in transports provided are TCP and UTP
+// but many more can be implemented, sctp, audio signals, sneakernet, UDT, a
+// network of drones carrying usb flash drives, and so on.
+type Transport interface {
+	// Dial dials a remote peer. It should try to reuse local listener
+	// addresses if possible but it may choose not to.
+	Dial(ctx context.Context, raddr ma.Multiaddr, p peer.ID) (Conn, error)
+
+	// CanDial returns true if this transport knows how to dial the given
+	// multiaddr.
+	//
+	// Returning true does not guarantee that dialing this multiaddr will
+	// succeed. This function should *only* be used to preemptively filter
+	// out addresses that we can't dial.
+	CanDial(addr ma.Multiaddr) bool
+
+	// Listen listens on the passed multiaddr.
+	Listen(laddr ma.Multiaddr) (Listener, error)
+
+	// Protocol returns the set of protocols handled by this transport.
+	//
+	// See the Network interface for an explanation of how this is used.
+	Protocols() []int
+
+	// Proxy returns true if this is a proxy transport.
+	//
+	// See the Network interface for an explanation of how this is used.
+	// TODO: Make this a part of the go-multiaddr protocol instead?
+	Proxy() bool
+}
+
+// Listener is an interface closely resembling the net.Listener interface.  The
+// only real difference is that Accept() returns Conn's of the type in this
+// package, and also exposes a Multiaddr method as opposed to a regular Addr
+// method
+type Listener interface {
+	Accept() (Conn, error)
+	Close() error
+	Addr() net.Addr
+	Multiaddr() ma.Multiaddr
+}
+
+// Network is an inet.Network with methods for managing transports.
+type Network interface {
+	inet.Network
+
+	// AddTransport adds a transport to this Network.
+	//
+	// When dialing, this Network will iterate over the protocols in the
+	// remote multiaddr and pick the first protocol registered with a proxy
+	// transport, if any. Otherwise, it'll pick the transport registered to
+	// handle the last protocol in the multiaddr.
+	//
+	// When listening, this Network will iterate over the protocols in the
+	// local multiaddr and pick the *last* protocol registered with a proxy
+	// transport, if any. Otherwise, it'll pick the transport registered to
+	// handle the last protocol in the multiaddr.
+	AddTransport(t Transport) error
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/LICENSE b/vendor/github.com/libp2p/go-libp2p/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p/config/config.go b/vendor/github.com/libp2p/go-libp2p/config/config.go
new file mode 100644
index 000000000..b017fea60
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/config.go
@@ -0,0 +1,176 @@
+package config
+
+import (
+	"context"
+	"fmt"
+
+	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+
+	logging "github.com/ipfs/go-log"
+	circuit "github.com/libp2p/go-libp2p-circuit"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	host "github.com/libp2p/go-libp2p-host"
+	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
+	pnet "github.com/libp2p/go-libp2p-interface-pnet"
+	metrics "github.com/libp2p/go-libp2p-metrics"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	swarm "github.com/libp2p/go-libp2p-swarm"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	filter "github.com/libp2p/go-maddr-filter"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var log = logging.Logger("p2p-config")
+
+// AddrsFactory is a function that takes a set of multiaddrs we're listening on and
+// returns the set of multiaddrs we should advertise to the network.
+type AddrsFactory = bhost.AddrsFactory
+
+// NATManagerC is a NATManager constructor.
+type NATManagerC func(inet.Network) bhost.NATManager
+
+// Config describes a set of settings for a libp2p node
+//
+// This is *not* a stable interface. Use the options defined in the root
+// package.
+type Config struct {
+	PeerKey crypto.PrivKey
+
+	Transports         []TptC
+	Muxers             []MsMuxC
+	SecurityTransports []MsSecC
+	Insecure           bool
+	Protector          pnet.Protector
+
+	Relay     bool
+	RelayOpts []circuit.RelayOpt
+
+	ListenAddrs  []ma.Multiaddr
+	AddrsFactory bhost.AddrsFactory
+	Filters      *filter.Filters
+
+	ConnManager ifconnmgr.ConnManager
+	NATManager  NATManagerC
+	Peerstore   pstore.Peerstore
+	Reporter    metrics.Reporter
+}
+
+// NewNode constructs a new libp2p Host from the Config.
+//
+// This function consumes the config. Do not reuse it (really!).
+func (cfg *Config) NewNode(ctx context.Context) (host.Host, error) {
+	// Check this early. Prevents us from even *starting* without verifying this.
+	if pnet.ForcePrivateNetwork && cfg.Protector == nil {
+		log.Error("tried to create a libp2p node with no Private" +
+			" Network Protector but usage of Private Networks" +
+			" is forced by the enviroment")
+		// Note: This is *also* checked the upgrader itself so it'll be
+		// enforced even *if* you don't use the libp2p constructor.
+		return nil, pnet.ErrNotInPrivateNetwork
+	}
+
+	if cfg.PeerKey == nil {
+		return nil, fmt.Errorf("no peer key specified")
+	}
+
+	// Obtain Peer ID from public key
+	pid, err := peer.IDFromPublicKey(cfg.PeerKey.GetPublic())
+	if err != nil {
+		return nil, err
+	}
+
+	if cfg.Peerstore == nil {
+		return nil, fmt.Errorf("no peerstore specified")
+	}
+
+	if !cfg.Insecure {
+		cfg.Peerstore.AddPrivKey(pid, cfg.PeerKey)
+		cfg.Peerstore.AddPubKey(pid, cfg.PeerKey.GetPublic())
+	}
+
+	// TODO: Make the swarm implementation configurable.
+	swrm := swarm.NewSwarm(ctx, pid, cfg.Peerstore, cfg.Reporter)
+	if cfg.Filters != nil {
+		swrm.Filters = cfg.Filters
+	}
+
+	// TODO: make host implementation configurable.
+	h, err := bhost.NewHost(ctx, swrm, &bhost.HostOpts{
+		ConnManager:  cfg.ConnManager,
+		AddrsFactory: cfg.AddrsFactory,
+		NATManager:   cfg.NATManager,
+	})
+	if err != nil {
+		swrm.Close()
+		return nil, err
+	}
+
+	upgrader := new(tptu.Upgrader)
+	upgrader.Protector = cfg.Protector
+	upgrader.Filters = swrm.Filters
+	if cfg.Insecure {
+		upgrader.Secure = makeInsecureTransport(pid)
+	} else {
+		upgrader.Secure, err = makeSecurityTransport(h, cfg.SecurityTransports)
+		if err != nil {
+			h.Close()
+			return nil, err
+		}
+	}
+
+	upgrader.Muxer, err = makeMuxer(h, cfg.Muxers)
+	if err != nil {
+		h.Close()
+		return nil, err
+	}
+
+	tpts, err := makeTransports(h, upgrader, cfg.Transports)
+	if err != nil {
+		h.Close()
+		return nil, err
+	}
+	for _, t := range tpts {
+		err = swrm.AddTransport(t)
+		if err != nil {
+			h.Close()
+			return nil, err
+		}
+	}
+
+	if cfg.Relay {
+		err := circuit.AddRelayTransport(swrm.Context(), h, upgrader, cfg.RelayOpts...)
+		if err != nil {
+			h.Close()
+			return nil, err
+		}
+	}
+
+	// TODO: This method succeeds if listening on one address succeeds. We
+	// should probably fail if listening on *any* addr fails.
+	if err := h.Network().Listen(cfg.ListenAddrs...); err != nil {
+		h.Close()
+		return nil, err
+	}
+
+	// TODO: Configure routing (it's a pain to setup).
+	// TODO: Bootstrapping.
+
+	return h, nil
+}
+
+// Option is a libp2p config option that can be given to the libp2p constructor
+// (`libp2p.New`).
+type Option func(cfg *Config) error
+
+// Apply applies the given options to the config, returning the first error
+// encountered (if any).
+func (cfg *Config) Apply(opts ...Option) error {
+	for _, opt := range opts {
+		if err := opt(cfg); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/config/constructor_types.go b/vendor/github.com/libp2p/go-libp2p/config/constructor_types.go
new file mode 100644
index 000000000..0cf4163fc
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/constructor_types.go
@@ -0,0 +1,62 @@
+package config
+
+import (
+	"fmt"
+	"reflect"
+
+	security "github.com/libp2p/go-conn-security"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	host "github.com/libp2p/go-libp2p-host"
+	pnet "github.com/libp2p/go-libp2p-interface-pnet"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	transport "github.com/libp2p/go-libp2p-transport"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	filter "github.com/libp2p/go-maddr-filter"
+	mux "github.com/libp2p/go-stream-muxer"
+)
+
+var (
+	// interfaces
+	hostType      = reflect.TypeOf((*host.Host)(nil)).Elem()
+	networkType   = reflect.TypeOf((*inet.Network)(nil)).Elem()
+	transportType = reflect.TypeOf((*transport.Transport)(nil)).Elem()
+	muxType       = reflect.TypeOf((*mux.Transport)(nil)).Elem()
+	securityType  = reflect.TypeOf((*security.Transport)(nil)).Elem()
+	protectorType = reflect.TypeOf((*pnet.Protector)(nil)).Elem()
+	privKeyType   = reflect.TypeOf((*crypto.PrivKey)(nil)).Elem()
+	pubKeyType    = reflect.TypeOf((*crypto.PubKey)(nil)).Elem()
+	pstoreType    = reflect.TypeOf((*pstore.Peerstore)(nil)).Elem()
+
+	// concrete types
+	peerIDType   = reflect.TypeOf((peer.ID)(""))
+	filtersType  = reflect.TypeOf((*filter.Filters)(nil))
+	upgraderType = reflect.TypeOf((*tptu.Upgrader)(nil))
+)
+
+var argTypes = map[reflect.Type]constructor{
+	upgraderType:  func(h host.Host, u *tptu.Upgrader) interface{} { return u },
+	hostType:      func(h host.Host, u *tptu.Upgrader) interface{} { return h },
+	networkType:   func(h host.Host, u *tptu.Upgrader) interface{} { return h.Network() },
+	muxType:       func(h host.Host, u *tptu.Upgrader) interface{} { return u.Muxer },
+	securityType:  func(h host.Host, u *tptu.Upgrader) interface{} { return u.Secure },
+	protectorType: func(h host.Host, u *tptu.Upgrader) interface{} { return u.Protector },
+	filtersType:   func(h host.Host, u *tptu.Upgrader) interface{} { return u.Filters },
+	peerIDType:    func(h host.Host, u *tptu.Upgrader) interface{} { return h.ID() },
+	privKeyType:   func(h host.Host, u *tptu.Upgrader) interface{} { return h.Peerstore().PrivKey(h.ID()) },
+	pubKeyType:    func(h host.Host, u *tptu.Upgrader) interface{} { return h.Peerstore().PubKey(h.ID()) },
+	pstoreType:    func(h host.Host, u *tptu.Upgrader) interface{} { return h.Peerstore() },
+}
+
+func newArgTypeSet(types ...reflect.Type) map[reflect.Type]constructor {
+	result := make(map[reflect.Type]constructor, len(types))
+	for _, ty := range types {
+		c, ok := argTypes[ty]
+		if !ok {
+			panic(fmt.Sprintf("missing constructor for type %s", ty))
+		}
+		result[ty] = c
+	}
+	return result
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/config/muxer.go b/vendor/github.com/libp2p/go-libp2p/config/muxer.go
new file mode 100644
index 000000000..6a48cb3bd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/muxer.go
@@ -0,0 +1,62 @@
+package config
+
+import (
+	"fmt"
+
+	host "github.com/libp2p/go-libp2p-host"
+	mux "github.com/libp2p/go-stream-muxer"
+	msmux "github.com/whyrusleeping/go-smux-multistream"
+)
+
+// MuxC is a stream multiplex transport constructor
+type MuxC func(h host.Host) (mux.Transport, error)
+
+// MsMuxC is a tuple containing a multiplex transport constructor and a protocol
+// ID.
+type MsMuxC struct {
+	MuxC
+	ID string
+}
+
+var muxArgTypes = newArgTypeSet(hostType, networkType, peerIDType, pstoreType)
+
+// MuxerConstructor creates a multiplex constructor from the passed parameter
+// using reflection.
+func MuxerConstructor(m interface{}) (MuxC, error) {
+	// Already constructed?
+	if t, ok := m.(mux.Transport); ok {
+		return func(_ host.Host) (mux.Transport, error) {
+			return t, nil
+		}, nil
+	}
+
+	ctor, err := makeConstructor(m, muxType, muxArgTypes)
+	if err != nil {
+		return nil, err
+	}
+	return func(h host.Host) (mux.Transport, error) {
+		t, err := ctor(h, nil)
+		if err != nil {
+			return nil, err
+		}
+		return t.(mux.Transport), nil
+	}, nil
+}
+
+func makeMuxer(h host.Host, tpts []MsMuxC) (mux.Transport, error) {
+	muxMuxer := msmux.NewBlankTransport()
+	transportSet := make(map[string]struct{}, len(tpts))
+	for _, tptC := range tpts {
+		if _, ok := transportSet[tptC.ID]; ok {
+			return nil, fmt.Errorf("duplicate muxer transport: %s", tptC.ID)
+		}
+	}
+	for _, tptC := range tpts {
+		tpt, err := tptC.MuxC(h)
+		if err != nil {
+			return nil, err
+		}
+		muxMuxer.AddTransport(tptC.ID, tpt)
+	}
+	return muxMuxer, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/config/reflection_magic.go b/vendor/github.com/libp2p/go-libp2p/config/reflection_magic.go
new file mode 100644
index 000000000..c23658e9c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/reflection_magic.go
@@ -0,0 +1,126 @@
+package config
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+
+	host "github.com/libp2p/go-libp2p-host"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+)
+
+var errorType = reflect.TypeOf((*error)(nil)).Elem()
+
+// checks if a function returns either the specified type or the specified type
+// and an error.
+func checkReturnType(fnType, tptType reflect.Type) error {
+	switch fnType.NumOut() {
+	case 2:
+		if fnType.Out(1) != errorType {
+			return fmt.Errorf("expected (optional) second return value from transport constructor to be an error")
+		}
+
+		fallthrough
+	case 1:
+		if !fnType.Out(0).Implements(tptType) {
+			return fmt.Errorf("expected first return value from transport constructor to be a transport")
+		}
+	default:
+		return fmt.Errorf("expected transport constructor to return a transport and, optionally, an error")
+	}
+	return nil
+}
+
+// Handles return values with optional errors. That is, return values of the
+// form `(something, error)` or just `something`.
+//
+// Panics if the return value isn't of the correct form.
+func handleReturnValue(out []reflect.Value) (interface{}, error) {
+	switch len(out) {
+	case 2:
+		err := out[1]
+		if err != (reflect.Value{}) && !err.IsNil() {
+			return nil, err.Interface().(error)
+		}
+		fallthrough
+	case 1:
+		tpt := out[0]
+
+		// Check for nil value and nil error.
+		if tpt == (reflect.Value{}) {
+			return nil, fmt.Errorf("unspecified error")
+		}
+		switch tpt.Kind() {
+		case reflect.Ptr, reflect.Interface, reflect.Func:
+			if tpt.IsNil() {
+				return nil, fmt.Errorf("unspecified error")
+			}
+		}
+
+		return tpt.Interface(), nil
+	default:
+		panic("expected 1 or 2 return values from transport constructor")
+	}
+}
+
+// calls the transport constructor and annotates the error with the name of the constructor.
+func callConstructor(c reflect.Value, args []reflect.Value) (interface{}, error) {
+	val, err := handleReturnValue(c.Call(args))
+	if err != nil {
+		name := runtime.FuncForPC(c.Pointer()).Name()
+		if name != "" {
+			// makes debugging easier
+			return nil, fmt.Errorf("transport constructor %s failed: %s", name, err)
+		}
+	}
+	return val, err
+}
+
+type constructor func(h host.Host, u *tptu.Upgrader) interface{}
+
+func makeArgumentConstructors(fnType reflect.Type, argTypes map[reflect.Type]constructor) ([]constructor, error) {
+	out := make([]constructor, fnType.NumIn())
+	for i := range out {
+		argType := fnType.In(i)
+		c, ok := argTypes[argType]
+		if !ok {
+			return nil, fmt.Errorf("argument %d has an unexpected type %s", i, argType.Name())
+		}
+		out[i] = c
+	}
+	return out, nil
+}
+
+// makes a transport constructor.
+func makeConstructor(
+	tpt interface{},
+	tptType reflect.Type,
+	argTypes map[reflect.Type]constructor,
+) (func(host.Host, *tptu.Upgrader) (interface{}, error), error) {
+	v := reflect.ValueOf(tpt)
+	// avoid panicing on nil/zero value.
+	if v == (reflect.Value{}) {
+		return nil, fmt.Errorf("expected a transport or transport constructor, got a %T", tpt)
+	}
+	t := v.Type()
+	if t.Kind() != reflect.Func {
+		return nil, fmt.Errorf("expected a transport or transport constructor, got a %T", tpt)
+	}
+
+	if err := checkReturnType(t, tptType); err != nil {
+		return nil, err
+	}
+
+	argConstructors, err := makeArgumentConstructors(t, argTypes)
+	if err != nil {
+		return nil, err
+	}
+
+	return func(h host.Host, u *tptu.Upgrader) (interface{}, error) {
+		arguments := make([]reflect.Value, len(argConstructors))
+		for i, makeArg := range argConstructors {
+			arguments[i] = reflect.ValueOf(makeArg(h, u))
+		}
+		return callConstructor(v, arguments)
+	}, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/config/security.go b/vendor/github.com/libp2p/go-libp2p/config/security.go
new file mode 100644
index 000000000..c3639728f
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/security.go
@@ -0,0 +1,76 @@
+package config
+
+import (
+	"fmt"
+
+	security "github.com/libp2p/go-conn-security"
+	csms "github.com/libp2p/go-conn-security-multistream"
+	insecure "github.com/libp2p/go-conn-security/insecure"
+	host "github.com/libp2p/go-libp2p-host"
+	peer "github.com/libp2p/go-libp2p-peer"
+)
+
+// SecC is a security transport constructor
+type SecC func(h host.Host) (security.Transport, error)
+
+// MsSecC is a tuple containing a security transport constructor and a protocol
+// ID.
+type MsSecC struct {
+	SecC
+	ID string
+}
+
+var securityArgTypes = newArgTypeSet(
+	hostType, networkType, peerIDType,
+	privKeyType, pubKeyType, pstoreType,
+)
+
+// SecurityConstructor creates a security constructor from the passed parameter
+// using reflection.
+func SecurityConstructor(sec interface{}) (SecC, error) {
+	// Already constructed?
+	if t, ok := sec.(security.Transport); ok {
+		return func(_ host.Host) (security.Transport, error) {
+			return t, nil
+		}, nil
+	}
+
+	ctor, err := makeConstructor(sec, securityType, securityArgTypes)
+	if err != nil {
+		return nil, err
+	}
+	return func(h host.Host) (security.Transport, error) {
+		t, err := ctor(h, nil)
+		if err != nil {
+			return nil, err
+		}
+		return t.(security.Transport), nil
+	}, nil
+}
+
+func makeInsecureTransport(id peer.ID) security.Transport {
+	secMuxer := new(csms.SSMuxer)
+	secMuxer.AddTransport(insecure.ID, insecure.New(id))
+	return secMuxer
+}
+
+func makeSecurityTransport(h host.Host, tpts []MsSecC) (security.Transport, error) {
+	secMuxer := new(csms.SSMuxer)
+	transportSet := make(map[string]struct{}, len(tpts))
+	for _, tptC := range tpts {
+		if _, ok := transportSet[tptC.ID]; ok {
+			return nil, fmt.Errorf("duplicate security transport: %s", tptC.ID)
+		}
+	}
+	for _, tptC := range tpts {
+		tpt, err := tptC.SecC(h)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := tpt.(*insecure.Transport); ok {
+			return nil, fmt.Errorf("cannot construct libp2p with an insecure transport, set the Insecure config option instead")
+		}
+		secMuxer.AddTransport(tptC.ID, tpt)
+	}
+	return secMuxer, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/config/transport.go b/vendor/github.com/libp2p/go-libp2p/config/transport.go
new file mode 100644
index 000000000..d9b4414d3
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/config/transport.go
@@ -0,0 +1,66 @@
+package config
+
+import (
+	host "github.com/libp2p/go-libp2p-host"
+	transport "github.com/libp2p/go-libp2p-transport"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+)
+
+// TptC is the type for libp2p transport constructors. You probably won't ever
+// implement this function interface directly. Instead, pass your transport
+// constructor to TransportConstructor.
+type TptC func(h host.Host, u *tptu.Upgrader) (transport.Transport, error)
+
+var transportArgTypes = argTypes
+
+// TransportConstructor uses reflection to turn a function that constructs a
+// transport into a TptC.
+//
+// You can pass either a constructed transport (something that implements
+// `transport.Transport`) or a function that takes any of:
+//
+// * The local peer ID.
+// * A transport connection upgrader.
+// * A private key.
+// * A public key.
+// * A Host.
+// * A Network.
+// * A Peerstore.
+// * An address filter.
+// * A security transport.
+// * A stream multiplexer transport.
+// * A private network protector.
+//
+// And returns a type implementing transport.Transport and, optionally, an error
+// (as the second argument).
+func TransportConstructor(tpt interface{}) (TptC, error) {
+	// Already constructed?
+	if t, ok := tpt.(transport.Transport); ok {
+		return func(_ host.Host, _ *tptu.Upgrader) (transport.Transport, error) {
+			return t, nil
+		}, nil
+	}
+	ctor, err := makeConstructor(tpt, transportType, transportArgTypes)
+	if err != nil {
+		return nil, err
+	}
+	return func(h host.Host, u *tptu.Upgrader) (transport.Transport, error) {
+		t, err := ctor(h, u)
+		if err != nil {
+			return nil, err
+		}
+		return t.(transport.Transport), nil
+	}, nil
+}
+
+func makeTransports(h host.Host, u *tptu.Upgrader, tpts []TptC) ([]transport.Transport, error) {
+	transports := make([]transport.Transport, len(tpts))
+	for i, tC := range tpts {
+		t, err := tC(h, u)
+		if err != nil {
+			return nil, err
+		}
+		transports[i] = t
+	}
+	return transports, nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/defaults.go b/vendor/github.com/libp2p/go-libp2p/defaults.go
new file mode 100644
index 000000000..d3fa618d6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/defaults.go
@@ -0,0 +1,109 @@
+package libp2p
+
+// This file contains all the default configuration options.
+
+import (
+	"crypto/rand"
+
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	secio "github.com/libp2p/go-libp2p-secio"
+	tcp "github.com/libp2p/go-tcp-transport"
+	ws "github.com/libp2p/go-ws-transport"
+	mplex "github.com/whyrusleeping/go-smux-multiplex"
+	yamux "github.com/whyrusleeping/go-smux-yamux"
+)
+
+// DefaultSecurity is the default security option.
+//
+// Useful when you want to extend, but not replace, the supported transport
+// security protocols.
+var DefaultSecurity = Security(secio.ID, secio.New)
+
+// DefaultMuxer configures libp2p to use the stream connection multiplexers.
+//
+// Use this option when you want to *extend* the set of multiplexers used by
+// libp2p instead of replacing them.
+var DefaultMuxers = ChainOptions(
+	Muxer("/yamux/1.0.0", yamux.DefaultTransport),
+	Muxer("/mplex/6.3.0", mplex.DefaultTransport),
+)
+
+// DefaultTransports are the default libp2p transports.
+//
+// Use this option when you want to *extend* the set of multiplexers used by
+// libp2p instead of replacing them.
+var DefaultTransports = ChainOptions(
+	Transport(tcp.NewTCPTransport),
+	Transport(ws.New),
+)
+
+// DefaultPeerstore configures libp2p to use the default peerstore.
+var DefaultPeerstore Option = func(cfg *Config) error {
+	return cfg.Apply(Peerstore(pstore.NewPeerstore()))
+}
+
+// RandomIdentity generates a random identity (default behaviour)
+var RandomIdentity = func(cfg *Config) error {
+	priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, rand.Reader)
+	if err != nil {
+		return err
+	}
+	return cfg.Apply(Identity(priv))
+}
+
+// Complete list of default options and when to fallback on them.
+//
+// Please *DON'T* specify default options any other way. Putting this all here
+// makes tracking defaults *much* easier.
+var defaults = []struct {
+	fallback func(cfg *Config) bool
+	opt      Option
+}{
+	{
+		fallback: func(cfg *Config) bool { return cfg.Transports == nil },
+		opt:      DefaultTransports,
+	},
+	{
+		fallback: func(cfg *Config) bool { return cfg.Muxers == nil },
+		opt:      DefaultMuxers,
+	},
+	{
+		fallback: func(cfg *Config) bool { return !cfg.Insecure && cfg.SecurityTransports == nil },
+		opt:      DefaultSecurity,
+	},
+	{
+		fallback: func(cfg *Config) bool { return cfg.PeerKey == nil },
+		opt:      RandomIdentity,
+	},
+	{
+		fallback: func(cfg *Config) bool { return cfg.Peerstore == nil },
+		opt:      DefaultPeerstore,
+	},
+}
+
+// Defaults configures libp2p to use the default options. Can be combined with
+// other options to *extend* the default options.
+var Defaults Option = func(cfg *Config) error {
+	for _, def := range defaults {
+		if err := cfg.Apply(def.opt); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// FallbackDefaults applies default options to the libp2p node if and only if no
+// other relevent options have been applied. will be appended to the options
+// passed into New.
+var FallbackDefaults Option = func(cfg *Config) error {
+	for _, def := range defaults {
+		if !def.fallback(cfg) {
+			continue
+		}
+		if err := cfg.Apply(def.opt); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/error_util.go b/vendor/github.com/libp2p/go-libp2p/error_util.go
new file mode 100644
index 000000000..86827f4ea
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/error_util.go
@@ -0,0 +1,17 @@
+package libp2p
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func traceError(err error, skip int) error {
+	if err == nil {
+		return nil
+	}
+	_, file, line, ok := runtime.Caller(skip + 1)
+	if !ok {
+		return err
+	}
+	return fmt.Errorf("%s:%d: %s", file, line, err)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/examples/multipro/AUTHORS b/vendor/github.com/libp2p/go-libp2p/examples/multipro/AUTHORS
new file mode 100644
index 000000000..70a81f0a5
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/examples/multipro/AUTHORS
@@ -0,0 +1,3 @@
+# This is the official list of authors for copyright purposes.
+
+Aviv Eyal <aviveyal07@gmail.com>
diff --git a/vendor/github.com/libp2p/go-libp2p/examples/multipro/LICENSE b/vendor/github.com/libp2p/go-libp2p/examples/multipro/LICENSE
new file mode 100644
index 000000000..df71bca6a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/examples/multipro/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Aviv Eyal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-libp2p/libp2p.go b/vendor/github.com/libp2p/go-libp2p/libp2p.go
new file mode 100644
index 000000000..936b2220d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/libp2p.go
@@ -0,0 +1,50 @@
+package libp2p
+
+import (
+	"context"
+
+	config "github.com/libp2p/go-libp2p/config"
+
+	host "github.com/libp2p/go-libp2p-host"
+)
+
+// Config describes a set of settings for a libp2p node
+type Config = config.Config
+
+// Option is a libp2p config option that can be given to the libp2p constructor
+// (`libp2p.New`).
+type Option = config.Option
+
+// ChainOptions chains multiple options into a single option.
+func ChainOptions(opts ...Option) Option {
+	return func(cfg *Config) error {
+		for _, opt := range opts {
+			if err := opt(cfg); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+}
+
+// New constructs a new libp2p node with the given options (falling back on
+// reasonable defaults).
+//
+// Canceling the passed context will stop the returned libp2p node.
+func New(ctx context.Context, opts ...Option) (host.Host, error) {
+	return NewWithoutDefaults(ctx, append(opts, FallbackDefaults)...)
+}
+
+// NewWithoutDefaults constructs a new libp2p node with the given options but
+// *without* falling back on reasonable defaults.
+//
+// Warning: This function should not be considered a stable interface. We may
+// choose to add required services at any time and, by using this function, you
+// opt-out of any defaults we may provide.
+func NewWithoutDefaults(ctx context.Context, opts ...Option) (host.Host, error) {
+	var cfg Config
+	if err := cfg.Apply(opts...); err != nil {
+		return nil, err
+	}
+	return cfg.NewNode(ctx)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/options.go b/vendor/github.com/libp2p/go-libp2p/options.go
new file mode 100644
index 000000000..a17fc02e8
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/options.go
@@ -0,0 +1,243 @@
+package libp2p
+
+// This file contains all libp2p configuration options (except the defaults,
+// those are in defaults.go)
+
+import (
+	"fmt"
+	"net"
+
+	config "github.com/libp2p/go-libp2p/config"
+	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+
+	circuit "github.com/libp2p/go-libp2p-circuit"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
+	pnet "github.com/libp2p/go-libp2p-interface-pnet"
+	metrics "github.com/libp2p/go-libp2p-metrics"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	filter "github.com/libp2p/go-maddr-filter"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// ListenAddrStrings configures libp2p to listen on the given (unparsed)
+// addresses.
+func ListenAddrStrings(s ...string) Option {
+	return func(cfg *Config) error {
+		for _, addrstr := range s {
+			a, err := ma.NewMultiaddr(addrstr)
+			if err != nil {
+				return err
+			}
+			cfg.ListenAddrs = append(cfg.ListenAddrs, a)
+		}
+		return nil
+	}
+}
+
+// ListenAddrs configures libp2p to listen on the given addresses.
+func ListenAddrs(addrs ...ma.Multiaddr) Option {
+	return func(cfg *Config) error {
+		cfg.ListenAddrs = append(cfg.ListenAddrs, addrs...)
+		return nil
+	}
+}
+
+// Security configures libp2p to use the given security transport (or transport
+// constructor).
+//
+// Name is the protocol name.
+//
+// The transport can be a constructed security.Transport or a function taking
+// any subset of this libp2p node's:
+// * Public key
+// * Private key
+// * Peer ID
+// * Host
+// * Network
+// * Peerstore
+func Security(name string, tpt interface{}) Option {
+	stpt, err := config.SecurityConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		if cfg.Insecure {
+			return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
+		}
+		cfg.SecurityTransports = append(cfg.SecurityTransports, config.MsSecC{SecC: stpt, ID: name})
+		return nil
+	}
+}
+
+// NoSecurity is an option that completely disables all transport security.
+// It's incompatible with all other transport security protocols.
+var NoSecurity Option = func(cfg *Config) error {
+	if len(cfg.SecurityTransports) > 0 {
+		return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
+	}
+	cfg.Insecure = true
+	return nil
+}
+
+// Muxer configures libp2p to use the given stream multiplexer (or stream
+// multiplexer constructor).
+//
+// Name is the protocol name.
+//
+// The transport can be a constructed mux.Transport or a function taking any
+// subset of this libp2p node's:
+// * Peer ID
+// * Host
+// * Network
+// * Peerstore
+func Muxer(name string, tpt interface{}) Option {
+	mtpt, err := config.MuxerConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		cfg.Muxers = append(cfg.Muxers, config.MsMuxC{MuxC: mtpt, ID: name})
+		return nil
+	}
+}
+
+// Transport configures libp2p to use the given transport (or transport
+// constructor).
+//
+// The transport can be a constructed transport.Transport or a function taking
+// any subset of this libp2p node's:
+// * Transport Upgrader (*tptu.Upgrader)
+// * Host
+// * Stream muxer (muxer.Transport)
+// * Security transport (security.Transport)
+// * Private network protector (pnet.Protector)
+// * Peer ID
+// * Private Key
+// * Public Key
+// * Address filter (filter.Filter)
+// * Peerstore
+func Transport(tpt interface{}) Option {
+	tptc, err := config.TransportConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		cfg.Transports = append(cfg.Transports, tptc)
+		return nil
+	}
+}
+
+// Peerstore configures libp2p to use the given peerstore.
+func Peerstore(ps pstore.Peerstore) Option {
+	return func(cfg *Config) error {
+		if cfg.Peerstore != nil {
+			return fmt.Errorf("cannot specify multiple peerstore options")
+		}
+
+		cfg.Peerstore = ps
+		return nil
+	}
+}
+
+// PrivateNetwork configures libp2p to use the given private network protector.
+func PrivateNetwork(prot pnet.Protector) Option {
+	return func(cfg *Config) error {
+		if cfg.Protector != nil {
+			return fmt.Errorf("cannot specify multiple private network options")
+		}
+
+		cfg.Protector = prot
+		return nil
+	}
+}
+
+// BandwidthReporter configures libp2p to use the given bandwidth reporter.
+func BandwidthReporter(rep metrics.Reporter) Option {
+	return func(cfg *Config) error {
+		if cfg.Reporter != nil {
+			return fmt.Errorf("cannot specify multiple bandwidth reporter options")
+		}
+
+		cfg.Reporter = rep
+		return nil
+	}
+}
+
+// Identity configures libp2p to use the given private key to identify itself.
+func Identity(sk crypto.PrivKey) Option {
+	return func(cfg *Config) error {
+		if cfg.PeerKey != nil {
+			return fmt.Errorf("cannot specify multiple identities")
+		}
+
+		cfg.PeerKey = sk
+		return nil
+	}
+}
+
+// ConnectionManager configures libp2p to use the given connection manager.
+func ConnectionManager(connman ifconnmgr.ConnManager) Option {
+	return func(cfg *Config) error {
+		if cfg.ConnManager != nil {
+			return fmt.Errorf("cannot specify multiple connection managers")
+		}
+		cfg.ConnManager = connman
+		return nil
+	}
+}
+
+// AddrsFactory configures libp2p to use the given address factory.
+func AddrsFactory(factory config.AddrsFactory) Option {
+	return func(cfg *Config) error {
+		if cfg.AddrsFactory != nil {
+			return fmt.Errorf("cannot specify multiple address factories")
+		}
+		cfg.AddrsFactory = factory
+		return nil
+	}
+}
+
+// EnableRelay configures libp2p to enable the relay transport.
+func EnableRelay(options ...circuit.RelayOpt) Option {
+	return func(cfg *Config) error {
+		cfg.Relay = true
+		cfg.RelayOpts = options
+		return nil
+	}
+}
+
+// FilterAddresses configures libp2p to never dial nor accept connections from
+// the given addresses.
+func FilterAddresses(addrs ...*net.IPNet) Option {
+	return func(cfg *Config) error {
+		if cfg.Filters == nil {
+			cfg.Filters = filter.NewFilters()
+		}
+		for _, addr := range addrs {
+			cfg.Filters.AddDialFilter(addr)
+		}
+		return nil
+	}
+}
+
+// NATPortMap configures libp2p to use the default NATManager. The default
+// NATManager will attempt to open a port in your network's firewall using UPnP.
+func NATPortMap() Option {
+	return NATManager(bhost.NewNATManager)
+}
+
+// NATManager will configure libp2p to use the requested NATManager. This
+// function should be passed a NATManager *constructor* that takes a libp2p Network.
+func NATManager(nm config.NATManagerC) Option {
+	return func(cfg *Config) error {
+		if cfg.NATManager != nil {
+			return fmt.Errorf("cannot specify multiple NATManagers")
+		}
+		cfg.NATManager = nm
+		return nil
+	}
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/basic_host.go b/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/basic_host.go
new file mode 100644
index 000000000..018f2691d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/basic_host.go
@@ -0,0 +1,511 @@
+package basichost
+
+import (
+	"context"
+	"io"
+	"time"
+
+	identify "github.com/libp2p/go-libp2p/p2p/protocol/identify"
+
+	logging "github.com/ipfs/go-log"
+	goprocess "github.com/jbenet/goprocess"
+	goprocessctx "github.com/jbenet/goprocess/context"
+	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	protocol "github.com/libp2p/go-libp2p-protocol"
+	ma "github.com/multiformats/go-multiaddr"
+	madns "github.com/multiformats/go-multiaddr-dns"
+	msmux "github.com/multiformats/go-multistream"
+)
+
+var log = logging.Logger("basichost")
+
+var (
+	// DefaultNegotiationTimeout is the default value for HostOpts.NegotiationTimeout.
+	DefaultNegotiationTimeout = time.Second * 60
+
+	// DefaultAddrsFactory is the default value for HostOpts.AddrsFactory.
+	DefaultAddrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr { return addrs }
+)
+
+// AddrsFactory functions can be passed to New in order to override
+// addresses returned by Addrs.
+type AddrsFactory func([]ma.Multiaddr) []ma.Multiaddr
+
+// Option is a type used to pass in options to the host.
+//
+// Deprecated in favor of HostOpts and NewHost.
+type Option int
+
+// NATPortMap makes the host attempt to open port-mapping in NAT devices
+// for all its listeners. Pass in this option in the constructor to
+// asynchronously a) find a gateway, b) open port mappings, c) republish
+// port mappings periodically. The NATed addresses are included in the
+// Host's Addrs() list.
+//
+// This option is deprecated in favor of HostOpts and NewHost.
+const NATPortMap Option = iota
+
+// BasicHost is the basic implementation of the host.Host interface. This
+// particular host implementation:
+//  * uses a protocol muxer to mux per-protocol streams
+//  * uses an identity service to send + receive node information
+//  * uses a nat service to establish NAT port mappings
+type BasicHost struct {
+	network    inet.Network
+	mux        *msmux.MultistreamMuxer
+	ids        *identify.IDService
+	natmgr     NATManager
+	addrs      AddrsFactory
+	maResolver *madns.Resolver
+	cmgr       ifconnmgr.ConnManager
+
+	negtimeout time.Duration
+
+	proc goprocess.Process
+}
+
+// HostOpts holds options that can be passed to NewHost in order to
+// customize construction of the *BasicHost.
+type HostOpts struct {
+
+	// MultistreamMuxer is essential for the *BasicHost and will use a sensible default value if omitted.
+	MultistreamMuxer *msmux.MultistreamMuxer
+
+	// NegotiationTimeout determines the read and write timeouts on streams.
+	// If 0 or omitted, it will use DefaultNegotiationTimeout.
+	// If below 0, timeouts on streams will be deactivated.
+	NegotiationTimeout time.Duration
+
+	// IdentifyService holds an implementation of the /ipfs/id/ protocol.
+	// If omitted, a new *identify.IDService will be used.
+	IdentifyService *identify.IDService
+
+	// AddrsFactory holds a function which can be used to override or filter the result of Addrs.
+	// If omitted, there's no override or filtering, and the results of Addrs and AllAddrs are the same.
+	AddrsFactory AddrsFactory
+
+	// MultiaddrResolves holds the go-multiaddr-dns.Resolver used for resolving
+	// /dns4, /dns6, and /dnsaddr addresses before trying to connect to a peer.
+	MultiaddrResolver *madns.Resolver
+
+	// NATManager takes care of setting NAT port mappings, and discovering external addresses.
+	// If omitted, this will simply be disabled.
+	NATManager func(inet.Network) NATManager
+
+	// ConnManager is a libp2p connection manager
+	ConnManager ifconnmgr.ConnManager
+}
+
+// NewHost constructs a new *BasicHost and activates it by attaching its stream and connection handlers to the given inet.Network.
+func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost, error) {
+	h := &BasicHost{
+		network:    net,
+		mux:        msmux.NewMultistreamMuxer(),
+		negtimeout: DefaultNegotiationTimeout,
+		addrs:      DefaultAddrsFactory,
+		maResolver: madns.DefaultResolver,
+	}
+
+	h.proc = goprocessctx.WithContextAndTeardown(ctx, func() error {
+		if h.natmgr != nil {
+			h.natmgr.Close()
+		}
+		return h.Network().Close()
+	})
+
+	if opts.MultistreamMuxer != nil {
+		h.mux = opts.MultistreamMuxer
+	}
+
+	if opts.IdentifyService != nil {
+		h.ids = opts.IdentifyService
+	} else {
+		// we can't set this as a default above because it depends on the *BasicHost.
+		h.ids = identify.NewIDService(h)
+	}
+
+	if uint64(opts.NegotiationTimeout) != 0 {
+		h.negtimeout = opts.NegotiationTimeout
+	}
+
+	if opts.AddrsFactory != nil {
+		h.addrs = opts.AddrsFactory
+	}
+
+	if opts.NATManager != nil {
+		h.natmgr = opts.NATManager(net)
+	}
+
+	if opts.MultiaddrResolver != nil {
+		h.maResolver = opts.MultiaddrResolver
+	}
+
+	if opts.ConnManager == nil {
+		h.cmgr = &ifconnmgr.NullConnMgr{}
+	} else {
+		h.cmgr = opts.ConnManager
+		net.Notify(h.cmgr.Notifee())
+	}
+
+	net.SetConnHandler(h.newConnHandler)
+	net.SetStreamHandler(h.newStreamHandler)
+	return h, nil
+}
+
+// New constructs and sets up a new *BasicHost with given Network and options.
+// The following options can be passed:
+// * NATPortMap
+// * AddrsFactory
+// * ifconnmgr.ConnManager
+// * madns.Resolver
+//
+// This function is deprecated in favor of NewHost and HostOpts.
+func New(net inet.Network, opts ...interface{}) *BasicHost {
+	hostopts := &HostOpts{}
+
+	for _, o := range opts {
+		switch o := o.(type) {
+		case Option:
+			switch o {
+			case NATPortMap:
+				hostopts.NATManager = NewNATManager
+			}
+		case AddrsFactory:
+			hostopts.AddrsFactory = AddrsFactory(o)
+		case ifconnmgr.ConnManager:
+			hostopts.ConnManager = o
+		case *madns.Resolver:
+			hostopts.MultiaddrResolver = o
+		}
+	}
+
+	h, err := NewHost(context.Background(), net, hostopts)
+	if err != nil {
+		// this cannot happen with legacy options
+		// plus we want to keep the (deprecated) legacy interface unchanged
+		panic(err)
+	}
+
+	return h
+}
+
+// newConnHandler is the remote-opened conn handler for inet.Network
+func (h *BasicHost) newConnHandler(c inet.Conn) {
+	// Clear protocols on connecting to new peer to avoid issues caused
+	// by misremembering protocols between reconnects
+	h.Peerstore().SetProtocols(c.RemotePeer())
+	h.ids.IdentifyConn(c)
+}
+
+// newStreamHandler is the remote-opened stream handler for inet.Network
+// TODO: this feels a bit wonky
+func (h *BasicHost) newStreamHandler(s inet.Stream) {
+	before := time.Now()
+
+	if h.negtimeout > 0 {
+		if err := s.SetDeadline(time.Now().Add(h.negtimeout)); err != nil {
+			log.Error("setting stream deadline: ", err)
+			s.Reset()
+			return
+		}
+	}
+
+	lzc, protoID, handle, err := h.Mux().NegotiateLazy(s)
+	took := time.Now().Sub(before)
+	if err != nil {
+		if err == io.EOF {
+			logf := log.Debugf
+			if took > time.Second*10 {
+				logf = log.Warningf
+			}
+			logf("protocol EOF: %s (took %s)", s.Conn().RemotePeer(), took)
+		} else {
+			log.Infof("protocol mux failed: %s (took %s)", err, took)
+		}
+		s.Reset()
+		return
+	}
+
+	s = &streamWrapper{
+		Stream: s,
+		rw:     lzc,
+	}
+
+	if h.negtimeout > 0 {
+		if err := s.SetDeadline(time.Time{}); err != nil {
+			log.Error("resetting stream deadline: ", err)
+			s.Reset()
+			return
+		}
+	}
+
+	s.SetProtocol(protocol.ID(protoID))
+	log.Debugf("protocol negotiation took %s", took)
+
+	go handle(protoID, s)
+}
+
+// ID returns the (local) peer.ID associated with this Host
+func (h *BasicHost) ID() peer.ID {
+	return h.Network().LocalPeer()
+}
+
+// Peerstore returns the Host's repository of Peer Addresses and Keys.
+func (h *BasicHost) Peerstore() pstore.Peerstore {
+	return h.Network().Peerstore()
+}
+
+// Network returns the Network interface of the Host
+func (h *BasicHost) Network() inet.Network {
+	return h.network
+}
+
+// Mux returns the Mux multiplexing incoming streams to protocol handlers
+func (h *BasicHost) Mux() *msmux.MultistreamMuxer {
+	return h.mux
+}
+
+// IDService returns
+func (h *BasicHost) IDService() *identify.IDService {
+	return h.ids
+}
+
+// SetStreamHandler sets the protocol handler on the Host's Mux.
+// This is equivalent to:
+//   host.Mux().SetHandler(proto, handler)
+// (Threadsafe)
+func (h *BasicHost) SetStreamHandler(pid protocol.ID, handler inet.StreamHandler) {
+	h.Mux().AddHandler(string(pid), func(p string, rwc io.ReadWriteCloser) error {
+		is := rwc.(inet.Stream)
+		is.SetProtocol(protocol.ID(p))
+		handler(is)
+		return nil
+	})
+}
+
+// SetStreamHandlerMatch sets the protocol handler on the Host's Mux
+// using a matching function to do protocol comparisons
+func (h *BasicHost) SetStreamHandlerMatch(pid protocol.ID, m func(string) bool, handler inet.StreamHandler) {
+	h.Mux().AddHandlerWithFunc(string(pid), m, func(p string, rwc io.ReadWriteCloser) error {
+		is := rwc.(inet.Stream)
+		is.SetProtocol(protocol.ID(p))
+		handler(is)
+		return nil
+	})
+}
+
+// RemoveStreamHandler returns ..
+func (h *BasicHost) RemoveStreamHandler(pid protocol.ID) {
+	h.Mux().RemoveHandler(string(pid))
+}
+
+// NewStream opens a new stream to given peer p, and writes a p2p/protocol
+// header with given protocol.ID. If there is no connection to p, attempts
+// to create one. If ProtocolID is "", writes no header.
+// (Threadsafe)
+func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.ID) (inet.Stream, error) {
+	pref, err := h.preferredProtocol(p, pids)
+	if err != nil {
+		return nil, err
+	}
+
+	if pref != "" {
+		return h.newStream(ctx, p, pref)
+	}
+
+	var protoStrs []string
+	for _, pid := range pids {
+		protoStrs = append(protoStrs, string(pid))
+	}
+
+	s, err := h.Network().NewStream(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	selected, err := msmux.SelectOneOf(protoStrs, s)
+	if err != nil {
+		s.Reset()
+		return nil, err
+	}
+	selpid := protocol.ID(selected)
+	s.SetProtocol(selpid)
+	h.Peerstore().AddProtocols(p, selected)
+
+	return s, nil
+}
+
+func pidsToStrings(pids []protocol.ID) []string {
+	out := make([]string, len(pids))
+	for i, p := range pids {
+		out[i] = string(p)
+	}
+	return out
+}
+
+func (h *BasicHost) preferredProtocol(p peer.ID, pids []protocol.ID) (protocol.ID, error) {
+	pidstrs := pidsToStrings(pids)
+	supported, err := h.Peerstore().SupportsProtocols(p, pidstrs...)
+	if err != nil {
+		return "", err
+	}
+
+	var out protocol.ID
+	if len(supported) > 0 {
+		out = protocol.ID(supported[0])
+	}
+	return out, nil
+}
+
+func (h *BasicHost) newStream(ctx context.Context, p peer.ID, pid protocol.ID) (inet.Stream, error) {
+	s, err := h.Network().NewStream(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	s.SetProtocol(pid)
+
+	lzcon := msmux.NewMSSelect(s, string(pid))
+	return &streamWrapper{
+		Stream: s,
+		rw:     lzcon,
+	}, nil
+}
+
+// Connect ensures there is a connection between this host and the peer with
+// given peer.ID. If there is not an active connection, Connect will issue a
+// h.Network.Dial, and block until a connection is open, or an error is returned.
+// Connect will absorb the addresses in pi into its internal peerstore.
+// It will also resolve any /dns4, /dns6, and /dnsaddr addresses.
+func (h *BasicHost) Connect(ctx context.Context, pi pstore.PeerInfo) error {
+	// absorb addresses into peerstore
+	h.Peerstore().AddAddrs(pi.ID, pi.Addrs, pstore.TempAddrTTL)
+
+	cs := h.Network().ConnsToPeer(pi.ID)
+	if len(cs) > 0 {
+		return nil
+	}
+
+	resolved, err := h.resolveAddrs(ctx, h.Peerstore().PeerInfo(pi.ID))
+	if err != nil {
+		return err
+	}
+	h.Peerstore().AddAddrs(pi.ID, resolved, pstore.TempAddrTTL)
+
+	return h.dialPeer(ctx, pi.ID)
+}
+
+func (h *BasicHost) resolveAddrs(ctx context.Context, pi pstore.PeerInfo) ([]ma.Multiaddr, error) {
+	proto := ma.ProtocolWithCode(ma.P_IPFS).Name
+	p2paddr, err := ma.NewMultiaddr("/" + proto + "/" + pi.ID.Pretty())
+	if err != nil {
+		return nil, err
+	}
+
+	var addrs []ma.Multiaddr
+	for _, addr := range pi.Addrs {
+		addrs = append(addrs, addr)
+		if !madns.Matches(addr) {
+			continue
+		}
+
+		reqaddr := addr.Encapsulate(p2paddr)
+		resaddrs, err := h.maResolver.Resolve(ctx, reqaddr)
+		if err != nil {
+			log.Infof("error resolving %s: %s", reqaddr, err)
+		}
+		for _, res := range resaddrs {
+			pi, err := pstore.InfoFromP2pAddr(res)
+			if err != nil {
+				log.Infof("error parsing %s: %s", res, err)
+			}
+			addrs = append(addrs, pi.Addrs...)
+		}
+	}
+
+	return addrs, nil
+}
+
+// dialPeer opens a connection to peer, and makes sure to identify
+// the connection once it has been opened.
+func (h *BasicHost) dialPeer(ctx context.Context, p peer.ID) error {
+	log.Debugf("host %s dialing %s", h.ID, p)
+	c, err := h.Network().DialPeer(ctx, p)
+	if err != nil {
+		return err
+	}
+
+	// Clear protocols on connecting to new peer to avoid issues caused
+	// by misremembering protocols between reconnects
+	h.Peerstore().SetProtocols(p)
+
+	// identify the connection before returning.
+	done := make(chan struct{})
+	go func() {
+		h.ids.IdentifyConn(c)
+		close(done)
+	}()
+
+	// respect don contexteone
+	select {
+	case <-done:
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+
+	log.Debugf("host %s finished dialing %s", h.ID(), p)
+	return nil
+}
+
+func (h *BasicHost) ConnManager() ifconnmgr.ConnManager {
+	return h.cmgr
+}
+
+// Addrs returns listening addresses that are safe to announce to the network.
+// The output is the same as AllAddrs, but processed by AddrsFactory.
+func (h *BasicHost) Addrs() []ma.Multiaddr {
+	return h.addrs(h.AllAddrs())
+}
+
+// AllAddrs returns all the addresses of BasicHost at this moment in time.
+// It's ok to not include addresses if they're not available to be used now.
+func (h *BasicHost) AllAddrs() []ma.Multiaddr {
+	addrs, err := h.Network().InterfaceListenAddresses()
+	if err != nil {
+		log.Debug("error retrieving network interface addrs")
+	}
+
+	if h.ids != nil { // add external observed addresses
+		addrs = append(addrs, h.ids.OwnObservedAddrs()...)
+	}
+
+	if h.natmgr != nil { // natmgr is nil if we do not use nat option.
+		nat := h.natmgr.NAT()
+		if nat != nil { // nat is nil if not ready, or no nat is available.
+			addrs = append(addrs, nat.ExternalAddrs()...)
+		}
+	}
+
+	return addrs
+}
+
+// Close shuts down the Host's services (network, etc).
+func (h *BasicHost) Close() error {
+	return h.proc.Close()
+}
+
+type streamWrapper struct {
+	inet.Stream
+	rw io.ReadWriter
+}
+
+func (s *streamWrapper) Read(b []byte) (int, error) {
+	return s.rw.Read(b)
+}
+
+func (s *streamWrapper) Write(b []byte) (int, error) {
+	return s.rw.Write(b)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/natmgr.go b/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/natmgr.go
new file mode 100644
index 000000000..349f79e78
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/p2p/host/basic/natmgr.go
@@ -0,0 +1,240 @@
+package basichost
+
+import (
+	"context"
+	"sync"
+
+	goprocess "github.com/jbenet/goprocess"
+	lgbl "github.com/libp2p/go-libp2p-loggables"
+	inat "github.com/libp2p/go-libp2p-nat"
+	inet "github.com/libp2p/go-libp2p-net"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// A simple interface to manage NAT devices.
+type NATManager interface {
+
+	// Get the NAT device managed by the NAT manager.
+	NAT() *inat.NAT
+
+	// Receive a notification when the NAT device is ready for use.
+	Ready() <-chan struct{}
+
+	// Close all resources associated with a NAT manager.
+	Close() error
+}
+
+// Create a NAT manager.
+func NewNATManager(net inet.Network) NATManager {
+	return newNatManager(net)
+}
+
+// natManager takes care of adding + removing port mappings to the nat.
+// Initialized with the host if it has a NATPortMap option enabled.
+// natManager receives signals from the network, and check on nat mappings:
+//  * natManager listens to the network and adds or closes port mappings
+//    as the network signals Listen() or ListenClose().
+//  * closing the natManager closes the nat and its mappings.
+type natManager struct {
+	net   inet.Network
+	natmu sync.RWMutex // guards nat (ready could obviate this mutex, but safety first.)
+	nat   *inat.NAT
+
+	ready chan struct{}     // closed once the nat is ready to process port mappings
+	proc  goprocess.Process // natManager has a process + children. can be closed.
+}
+
+func newNatManager(net inet.Network) *natManager {
+	nmgr := &natManager{
+		net:   net,
+		ready: make(chan struct{}),
+	}
+
+	nmgr.proc = goprocess.WithTeardown(func() error {
+		// on closing, unregister from network notifications.
+		net.StopNotify((*nmgrNetNotifiee)(nmgr))
+		return nil
+	})
+
+	// discover the nat.
+	nmgr.discoverNAT()
+	return nmgr
+}
+
+// Close closes the natManager, closing the underlying nat
+// and unregistering from network events.
+func (nmgr *natManager) Close() error {
+	return nmgr.proc.Close()
+}
+
+// Ready returns a channel which will be closed when the NAT has been found
+// and is ready to be used, or the search process is done.
+func (nmgr *natManager) Ready() <-chan struct{} {
+	return nmgr.ready
+}
+
+func (nmgr *natManager) discoverNAT() {
+
+	nmgr.proc.Go(func(worker goprocess.Process) {
+		// inat.DiscoverNAT blocks until the nat is found or a timeout
+		// is reached. we unfortunately cannot specify timeouts-- the
+		// library we're using just blocks.
+		//
+		// Note: on early shutdown, there may be a case where we're trying
+		// to close before DiscoverNAT() returns. Since we cant cancel it
+		// (library) we can choose to (1) drop the result and return early,
+		// or (2) wait until it times out to exit. For now we choose (2),
+		// to avoid leaking resources in a non-obvious way. the only case
+		// this affects is when the daemon is being started up and _immediately_
+		// asked to close. other services are also starting up, so ok to wait.
+		discoverdone := make(chan struct{})
+		var nat *inat.NAT
+		go func() {
+			defer close(discoverdone)
+			nat = inat.DiscoverNAT()
+		}()
+
+		// by this point -- after finding the NAT -- we may have already
+		// be closing. if so, just exit.
+		select {
+		case <-worker.Closing():
+			return
+		case <-discoverdone:
+			if nat == nil { // no nat, or failed to get it.
+				return
+			}
+		}
+
+		// wire up the nat to close when nmgr closes.
+		// nmgr.proc is our parent, and waiting for us.
+		nmgr.proc.AddChild(nat.Process())
+
+		// set the nat.
+		nmgr.natmu.Lock()
+		nmgr.nat = nat
+		nmgr.natmu.Unlock()
+
+		// signal that we're ready to process nat mappings:
+		close(nmgr.ready)
+
+		// sign natManager up for network notifications
+		// we need to sign up here to avoid missing some notifs
+		// before the NAT has been found.
+		nmgr.net.Notify((*nmgrNetNotifiee)(nmgr))
+
+		// if any interfaces were brought up while we were setting up
+		// the nat, now is the time to setup port mappings for them.
+		// we release ready, then grab them to avoid losing any. adding
+		// a port mapping is idempotent, so its ok to add the same twice.
+		addrs := nmgr.net.ListenAddresses()
+		for _, addr := range addrs {
+			// we do it async because it's slow and we may want to close beforehand
+			go addPortMapping(nmgr, addr)
+		}
+	})
+}
+
+// NAT returns the natManager's nat object. this may be nil, if
+// (a) the search process is still ongoing, or (b) the search process
+// found no nat. Clients must check whether the return value is nil.
+func (nmgr *natManager) NAT() *inat.NAT {
+	nmgr.natmu.Lock()
+	defer nmgr.natmu.Unlock()
+	return nmgr.nat
+}
+
+func addPortMapping(nmgr *natManager, intaddr ma.Multiaddr) {
+	nat := nmgr.NAT()
+	if nat == nil {
+		panic("natManager addPortMapping called without a nat.")
+	}
+
+	// first, check if the port mapping already exists.
+	for _, mapping := range nat.Mappings() {
+		if mapping.InternalAddr().Equal(intaddr) {
+			return // it exists! return.
+		}
+	}
+
+	ctx := context.TODO()
+	lm := make(lgbl.DeferredMap)
+	lm["internalAddr"] = func() interface{} { return intaddr.String() }
+
+	defer log.EventBegin(ctx, "natMgrAddPortMappingWait", lm).Done()
+
+	select {
+	case <-nmgr.proc.Closing():
+		lm["outcome"] = "cancelled"
+		return // no use.
+	case <-nmgr.ready: // wait until it's ready.
+	}
+
+	// actually start the port map (sub-event because waiting may take a while)
+	defer log.EventBegin(ctx, "natMgrAddPortMapping", lm).Done()
+
+	// get the nat
+	m, err := nat.NewMapping(intaddr)
+	if err != nil {
+		lm["outcome"] = "failure"
+		lm["error"] = err
+		return
+	}
+
+	extaddr, err := m.ExternalAddr()
+	if err != nil {
+		lm["outcome"] = "failure"
+		lm["error"] = err
+		return
+	}
+
+	lm["outcome"] = "success"
+	lm["externalAddr"] = func() interface{} { return extaddr.String() }
+	log.Infof("established nat port mapping: %s <--> %s", intaddr, extaddr)
+}
+
+func rmPortMapping(nmgr *natManager, intaddr ma.Multiaddr) {
+	nat := nmgr.NAT()
+	if nat == nil {
+		panic("natManager rmPortMapping called without a nat.")
+	}
+
+	// list the port mappings (it may be gone on it's own, so we need to
+	// check this list, and not store it ourselves behind the scenes)
+
+	// close mappings for this internal address.
+	for _, mapping := range nat.Mappings() {
+		if mapping.InternalAddr().Equal(intaddr) {
+			mapping.Close()
+		}
+	}
+}
+
+// nmgrNetNotifiee implements the network notification listening part
+// of the natManager. this is merely listening to Listen() and ListenClose()
+// events.
+type nmgrNetNotifiee natManager
+
+func (nn *nmgrNetNotifiee) natManager() *natManager {
+	return (*natManager)(nn)
+}
+
+func (nn *nmgrNetNotifiee) Listen(n inet.Network, addr ma.Multiaddr) {
+	if nn.natManager().NAT() == nil {
+		return // not ready or doesnt exist.
+	}
+
+	addPortMapping(nn.natManager(), addr)
+}
+
+func (nn *nmgrNetNotifiee) ListenClose(n inet.Network, addr ma.Multiaddr) {
+	if nn.natManager().NAT() == nil {
+		return // not ready or doesnt exist.
+	}
+
+	rmPortMapping(nn.natManager(), addr)
+}
+
+func (nn *nmgrNetNotifiee) Connected(inet.Network, inet.Conn)      {}
+func (nn *nmgrNetNotifiee) Disconnected(inet.Network, inet.Conn)   {}
+func (nn *nmgrNetNotifiee) OpenedStream(inet.Network, inet.Stream) {}
+func (nn *nmgrNetNotifiee) ClosedStream(inet.Network, inet.Stream) {}
diff --git a/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/id.go b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/id.go
new file mode 100644
index 000000000..8f8394fbd
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/id.go
@@ -0,0 +1,474 @@
+package identify
+
+import (
+	"context"
+	"strings"
+	"sync"
+
+	pb "github.com/libp2p/go-libp2p/p2p/protocol/identify/pb"
+
+	semver "github.com/coreos/go-semver/semver"
+	ggio "github.com/gogo/protobuf/io"
+	logging "github.com/ipfs/go-log"
+	ic "github.com/libp2p/go-libp2p-crypto"
+	host "github.com/libp2p/go-libp2p-host"
+	lgbl "github.com/libp2p/go-libp2p-loggables"
+	inet "github.com/libp2p/go-libp2p-net"
+	peer "github.com/libp2p/go-libp2p-peer"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	ma "github.com/multiformats/go-multiaddr"
+	msmux "github.com/multiformats/go-multistream"
+)
+
+var log = logging.Logger("net/identify")
+
+// ID is the protocol.ID of the Identify Service.
+const ID = "/ipfs/id/1.0.0"
+
+// LibP2PVersion holds the current protocol version for a client running this code
+// TODO(jbenet): fix the versioning mess.
+const LibP2PVersion = "ipfs/0.1.0"
+
+var ClientVersion = "go-libp2p/3.3.4"
+
+// IDService is a structure that implements ProtocolIdentify.
+// It is a trivial service that gives the other peer some
+// useful information about the local peer. A sort of hello.
+//
+// The IDService sends:
+//  * Our IPFS Protocol Version
+//  * Our IPFS Agent Version
+//  * Our public Listen Addresses
+type IDService struct {
+	Host host.Host
+
+	// connections undergoing identification
+	// for wait purposes
+	currid map[inet.Conn]chan struct{}
+	currmu sync.RWMutex
+
+	addrMu sync.Mutex
+
+	// our own observed addresses.
+	// TODO: instead of expiring, remove these when we disconnect
+	observedAddrs ObservedAddrSet
+}
+
+// NewIDService constructs a new *IDService and activates it by
+// attaching its stream handler to the given host.Host.
+func NewIDService(h host.Host) *IDService {
+	s := &IDService{
+		Host:   h,
+		currid: make(map[inet.Conn]chan struct{}),
+	}
+	h.SetStreamHandler(ID, s.requestHandler)
+	h.Network().Notify((*netNotifiee)(s))
+	return s
+}
+
+// OwnObservedAddrs returns the addresses peers have reported we've dialed from
+func (ids *IDService) OwnObservedAddrs() []ma.Multiaddr {
+	return ids.observedAddrs.Addrs()
+}
+
+func (ids *IDService) IdentifyConn(c inet.Conn) {
+	ids.currmu.Lock()
+	if wait, found := ids.currid[c]; found {
+		ids.currmu.Unlock()
+		log.Debugf("IdentifyConn called twice on: %s", c)
+		<-wait // already identifying it. wait for it.
+		return
+	}
+	ch := make(chan struct{})
+	ids.currid[c] = ch
+	ids.currmu.Unlock()
+
+	defer close(ch)
+
+	s, err := c.NewStream()
+	if err != nil {
+		log.Debugf("error opening initial stream for %s: %s", ID, err)
+		log.Event(context.TODO(), "IdentifyOpenFailed", c.RemotePeer())
+		c.Close()
+		return
+	}
+	defer inet.FullClose(s)
+
+	s.SetProtocol(ID)
+
+	// ok give the response to our handler.
+	if err := msmux.SelectProtoOrFail(ID, s); err != nil {
+		log.Event(context.TODO(), "IdentifyOpenFailed", c.RemotePeer(), logging.Metadata{"error": err})
+		return
+	}
+
+	ids.responseHandler(s)
+
+	ids.currmu.Lock()
+	_, found := ids.currid[c]
+	delete(ids.currid, c)
+	ids.currmu.Unlock()
+
+	if !found {
+		log.Errorf("IdentifyConn failed to find channel (programmer error) for %s", c)
+		return
+	}
+}
+
+func (ids *IDService) requestHandler(s inet.Stream) {
+	defer inet.FullClose(s)
+	c := s.Conn()
+
+	w := ggio.NewDelimitedWriter(s)
+	mes := pb.Identify{}
+	ids.populateMessage(&mes, s.Conn())
+	w.WriteMsg(&mes)
+
+	log.Debugf("%s sent message to %s %s", ID,
+		c.RemotePeer(), c.RemoteMultiaddr())
+}
+
+func (ids *IDService) responseHandler(s inet.Stream) {
+	c := s.Conn()
+
+	r := ggio.NewDelimitedReader(s, 2048)
+	mes := pb.Identify{}
+	if err := r.ReadMsg(&mes); err != nil {
+		log.Warning("error reading identify message: ", err)
+		return
+	}
+	ids.consumeMessage(&mes, c)
+
+	log.Debugf("%s received message from %s %s", ID,
+		c.RemotePeer(), c.RemoteMultiaddr())
+}
+
+func (ids *IDService) populateMessage(mes *pb.Identify, c inet.Conn) {
+
+	// set protocols this node is currently handling
+	protos := ids.Host.Mux().Protocols()
+	mes.Protocols = make([]string, len(protos))
+	for i, p := range protos {
+		mes.Protocols[i] = string(p)
+	}
+
+	// observed address so other side is informed of their
+	// "public" address, at least in relation to us.
+	mes.ObservedAddr = c.RemoteMultiaddr().Bytes()
+
+	// set listen addrs, get our latest addrs from Host.
+	laddrs := ids.Host.Addrs()
+	mes.ListenAddrs = make([][]byte, len(laddrs))
+	for i, addr := range laddrs {
+		mes.ListenAddrs[i] = addr.Bytes()
+	}
+	log.Debugf("%s sent listen addrs to %s: %s", c.LocalPeer(), c.RemotePeer(), laddrs)
+
+	// set our public key
+	ownKey := ids.Host.Peerstore().PubKey(ids.Host.ID())
+	if ownKey == nil {
+		log.Errorf("did not have own public key in Peerstore")
+	} else {
+		if kb, err := ownKey.Bytes(); err != nil {
+			log.Errorf("failed to convert key to bytes")
+		} else {
+			mes.PublicKey = kb
+		}
+	}
+
+	// set protocol versions
+	pv := LibP2PVersion
+	av := ClientVersion
+	mes.ProtocolVersion = &pv
+	mes.AgentVersion = &av
+}
+
+func (ids *IDService) consumeMessage(mes *pb.Identify, c inet.Conn) {
+	p := c.RemotePeer()
+
+	// mes.Protocols
+	ids.Host.Peerstore().SetProtocols(p, mes.Protocols...)
+
+	// mes.ObservedAddr
+	ids.consumeObservedAddress(mes.GetObservedAddr(), c)
+
+	// mes.ListenAddrs
+	laddrs := mes.GetListenAddrs()
+	lmaddrs := make([]ma.Multiaddr, 0, len(laddrs))
+	for _, addr := range laddrs {
+		maddr, err := ma.NewMultiaddrBytes(addr)
+		if err != nil {
+			log.Debugf("%s failed to parse multiaddr from %s %s", ID,
+				p, c.RemoteMultiaddr())
+			continue
+		}
+		lmaddrs = append(lmaddrs, maddr)
+	}
+
+	// if the address reported by the connection roughly matches their annoucned
+	// listener addresses, its likely to be an external NAT address
+	if HasConsistentTransport(c.RemoteMultiaddr(), lmaddrs) {
+		lmaddrs = append(lmaddrs, c.RemoteMultiaddr())
+	}
+
+	// Extend the TTLs on the known (probably) good addresses.
+	// Taking the lock ensures that we don't concurrently process a disconnect.
+	ids.addrMu.Lock()
+	switch ids.Host.Network().Connectedness(p) {
+	case inet.Connected:
+		ids.Host.Peerstore().AddAddrs(p, lmaddrs, pstore.ConnectedAddrTTL)
+	default:
+		ids.Host.Peerstore().AddAddrs(p, lmaddrs, pstore.RecentlyConnectedAddrTTL)
+	}
+	ids.addrMu.Unlock()
+
+	log.Debugf("%s received listen addrs for %s: %s", c.LocalPeer(), c.RemotePeer(), lmaddrs)
+
+	// get protocol versions
+	pv := mes.GetProtocolVersion()
+	av := mes.GetAgentVersion()
+
+	// version check. if we shouldn't talk, bail.
+	// TODO: at this point, we've already exchanged information.
+	// move this into a first handshake before the connection can open streams.
+	if !protocolVersionsAreCompatible(pv, LibP2PVersion) {
+		logProtocolMismatchDisconnect(c, pv, av)
+		c.Close()
+		return
+	}
+
+	ids.Host.Peerstore().Put(p, "ProtocolVersion", pv)
+	ids.Host.Peerstore().Put(p, "AgentVersion", av)
+
+	// get the key from the other side. we may not have it (no-auth transport)
+	ids.consumeReceivedPubKey(c, mes.PublicKey)
+}
+
+func (ids *IDService) consumeReceivedPubKey(c inet.Conn, kb []byte) {
+	lp := c.LocalPeer()
+	rp := c.RemotePeer()
+
+	if kb == nil {
+		log.Debugf("%s did not receive public key for remote peer: %s", lp, rp)
+		return
+	}
+
+	newKey, err := ic.UnmarshalPublicKey(kb)
+	if err != nil {
+		log.Errorf("%s cannot unmarshal key from remote peer: %s", lp, rp)
+		return
+	}
+
+	// verify key matches peer.ID
+	np, err := peer.IDFromPublicKey(newKey)
+	if err != nil {
+		log.Debugf("%s cannot get peer.ID from key of remote peer: %s, %s", lp, rp, err)
+		return
+	}
+
+	if np != rp {
+		// if the newKey's peer.ID does not match known peer.ID...
+
+		if rp == "" && np != "" {
+			// if local peerid is empty, then use the new, sent key.
+			err := ids.Host.Peerstore().AddPubKey(rp, newKey)
+			if err != nil {
+				log.Debugf("%s could not add key for %s to peerstore: %s", lp, rp, err)
+			}
+
+		} else {
+			// we have a local peer.ID and it does not match the sent key... error.
+			log.Errorf("%s received key for remote peer %s mismatch: %s", lp, rp, np)
+		}
+		return
+	}
+
+	currKey := ids.Host.Peerstore().PubKey(rp)
+	if currKey == nil {
+		// no key? no auth transport. set this one.
+		err := ids.Host.Peerstore().AddPubKey(rp, newKey)
+		if err != nil {
+			log.Debugf("%s could not add key for %s to peerstore: %s", lp, rp, err)
+		}
+		return
+	}
+
+	// ok, we have a local key, we should verify they match.
+	if currKey.Equals(newKey) {
+		return // ok great. we're done.
+	}
+
+	// weird, got a different key... but the different key MATCHES the peer.ID.
+	// this odd. let's log error and investigate. this should basically never happen
+	// and it means we have something funky going on and possibly a bug.
+	log.Errorf("%s identify got a different key for: %s", lp, rp)
+
+	// okay... does ours NOT match the remote peer.ID?
+	cp, err := peer.IDFromPublicKey(currKey)
+	if err != nil {
+		log.Errorf("%s cannot get peer.ID from local key of remote peer: %s, %s", lp, rp, err)
+		return
+	}
+	if cp != rp {
+		log.Errorf("%s local key for remote peer %s yields different peer.ID: %s", lp, rp, cp)
+		return
+	}
+
+	// okay... curr key DOES NOT match new key. both match peer.ID. wat?
+	log.Errorf("%s local key and received key for %s do not match, but match peer.ID", lp, rp)
+}
+
+// HasConsistentTransport returns true if the address 'a' shares a
+// protocol set with any address in the green set. This is used
+// to check if a given address might be one of the addresses a peer is
+// listening on.
+func HasConsistentTransport(a ma.Multiaddr, green []ma.Multiaddr) bool {
+	protosMatch := func(a, b []ma.Protocol) bool {
+		if len(a) != len(b) {
+			return false
+		}
+
+		for i, p := range a {
+			if b[i].Code != p.Code {
+				return false
+			}
+		}
+		return true
+	}
+
+	protos := a.Protocols()
+
+	for _, ga := range green {
+		if protosMatch(protos, ga.Protocols()) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// IdentifyWait returns a channel which will be closed once
+// "ProtocolIdentify" (handshake3) finishes on given conn.
+// This happens async so the connection can start to be used
+// even if handshake3 knowledge is not necesary.
+// Users **MUST** call IdentifyWait _after_ IdentifyConn
+func (ids *IDService) IdentifyWait(c inet.Conn) <-chan struct{} {
+	ids.currmu.Lock()
+	ch, found := ids.currid[c]
+	ids.currmu.Unlock()
+	if found {
+		return ch
+	}
+
+	// if not found, it means we are already done identifying it, or
+	// haven't even started. either way, return a new channel closed.
+	ch = make(chan struct{})
+	close(ch)
+	return ch
+}
+
+func (ids *IDService) consumeObservedAddress(observed []byte, c inet.Conn) {
+	if observed == nil {
+		return
+	}
+
+	maddr, err := ma.NewMultiaddrBytes(observed)
+	if err != nil {
+		log.Debugf("error parsing received observed addr for %s: %s", c, err)
+		return
+	}
+
+	// we should only use ObservedAddr when our connection's LocalAddr is one
+	// of our ListenAddrs. If we Dial out using an ephemeral addr, knowing that
+	// address's external mapping is not very useful because the port will not be
+	// the same as the listen addr.
+	ifaceaddrs, err := ids.Host.Network().InterfaceListenAddresses()
+	if err != nil {
+		log.Infof("failed to get interface listen addrs", err)
+		return
+	}
+
+	log.Debugf("identify identifying observed multiaddr: %s %s", c.LocalMultiaddr(), ifaceaddrs)
+	if !addrInAddrs(c.LocalMultiaddr(), ifaceaddrs) {
+		// not in our list
+		return
+	}
+
+	// ok! we have the observed version of one of our ListenAddresses!
+	log.Debugf("added own observed listen addr: %s --> %s", c.LocalMultiaddr(), maddr)
+	ids.observedAddrs.Add(maddr, c.RemoteMultiaddr())
+}
+
+func addrInAddrs(a ma.Multiaddr, as []ma.Multiaddr) bool {
+	for _, b := range as {
+		if a.Equal(b) {
+			return true
+		}
+	}
+	return false
+}
+
+// protocolVersionsAreCompatible checks that the two implementations
+// can talk to each other. It will use semver, but for now while
+// we're in tight development, we will return false for minor version
+// changes too.
+func protocolVersionsAreCompatible(v1, v2 string) bool {
+	if strings.HasPrefix(v1, "ipfs/") {
+		v1 = v1[5:]
+	}
+	if strings.HasPrefix(v2, "ipfs/") {
+		v2 = v2[5:]
+	}
+
+	v1s, err := semver.NewVersion(v1)
+	if err != nil {
+		return false
+	}
+
+	v2s, err := semver.NewVersion(v2)
+	if err != nil {
+		return false
+	}
+
+	return v1s.Major == v2s.Major && v1s.Minor == v2s.Minor
+}
+
+// netNotifiee defines methods to be used with the IpfsDHT
+type netNotifiee IDService
+
+func (nn *netNotifiee) IDService() *IDService {
+	return (*IDService)(nn)
+}
+
+func (nn *netNotifiee) Connected(n inet.Network, v inet.Conn) {
+	// TODO: deprecate the setConnHandler hook, and kick off
+	// identification here.
+}
+
+func (nn *netNotifiee) Disconnected(n inet.Network, v inet.Conn) {
+	// undo the setting of addresses to peer.ConnectedAddrTTL we did
+	ids := nn.IDService()
+	ids.addrMu.Lock()
+	defer ids.addrMu.Unlock()
+
+	if ids.Host.Network().Connectedness(v.RemotePeer()) != inet.Connected {
+		// Last disconnect.
+		ps := ids.Host.Peerstore()
+		ps.UpdateAddrs(v.RemotePeer(), pstore.ConnectedAddrTTL, pstore.RecentlyConnectedAddrTTL)
+	}
+}
+
+func (nn *netNotifiee) OpenedStream(n inet.Network, v inet.Stream) {}
+func (nn *netNotifiee) ClosedStream(n inet.Network, v inet.Stream) {}
+func (nn *netNotifiee) Listen(n inet.Network, a ma.Multiaddr)      {}
+func (nn *netNotifiee) ListenClose(n inet.Network, a ma.Multiaddr) {}
+
+func logProtocolMismatchDisconnect(c inet.Conn, protocol, agent string) {
+	lm := make(lgbl.DeferredMap)
+	lm["remotePeer"] = func() interface{} { return c.RemotePeer().Pretty() }
+	lm["remoteAddr"] = func() interface{} { return c.RemoteMultiaddr().String() }
+	lm["protocolVersion"] = protocol
+	lm["agentVersion"] = agent
+	log.Event(context.TODO(), "IdentifyProtocolMismatch", lm)
+	log.Debugf("IdentifyProtocolMismatch %s %s %s (disconnected)", c.RemotePeer(), protocol, agent)
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/obsaddr.go b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/obsaddr.go
new file mode 100644
index 000000000..0e72ab343
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/obsaddr.go
@@ -0,0 +1,129 @@
+package identify
+
+import (
+	"sync"
+	"time"
+
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+const ActivationThresh = 4
+
+// ObservedAddr is an entry for an address reported by our peers.
+// We only use addresses that:
+// - have been observed at least 4 times in last 1h. (counter symmetric nats)
+// - have been observed at least once recently (1h), because our position in the
+//   network, or network port mapppings, may have changed.
+type ObservedAddr struct {
+	Addr      ma.Multiaddr
+	SeenBy    map[string]time.Time
+	LastSeen  time.Time
+	Activated bool
+}
+
+func (oa *ObservedAddr) TryActivate(ttl time.Duration) bool {
+	// cleanup SeenBy set
+	now := time.Now()
+	for k, t := range oa.SeenBy {
+		if now.Sub(t) > ttl*ActivationThresh {
+			delete(oa.SeenBy, k)
+		}
+	}
+
+	// We only activate if in the TTL other peers observed the same address
+	// of ours at least 4 times.
+	return len(oa.SeenBy) >= ActivationThresh
+}
+
+// ObservedAddrSet keeps track of a set of ObservedAddrs
+// the zero-value is ready to be used.
+type ObservedAddrSet struct {
+	sync.Mutex // guards whole datastruct.
+
+	addrs map[string]*ObservedAddr
+	ttl   time.Duration
+}
+
+func (oas *ObservedAddrSet) Addrs() []ma.Multiaddr {
+	oas.Lock()
+	defer oas.Unlock()
+
+	// for zero-value.
+	if oas.addrs == nil {
+		return nil
+	}
+
+	now := time.Now()
+	addrs := make([]ma.Multiaddr, 0, len(oas.addrs))
+	for s, a := range oas.addrs {
+		// remove timed out addresses.
+		if now.Sub(a.LastSeen) > oas.ttl {
+			delete(oas.addrs, s)
+			continue
+		}
+
+		if a.Activated || a.TryActivate(oas.ttl) {
+			addrs = append(addrs, a.Addr)
+		}
+	}
+	return addrs
+}
+
+func (oas *ObservedAddrSet) Add(addr ma.Multiaddr, observer ma.Multiaddr) {
+	oas.Lock()
+	defer oas.Unlock()
+
+	// for zero-value.
+	if oas.addrs == nil {
+		oas.addrs = make(map[string]*ObservedAddr)
+		oas.ttl = pstore.OwnObservedAddrTTL
+	}
+
+	s := addr.String()
+	oa, found := oas.addrs[s]
+
+	// first time seeing address.
+	if !found {
+		oa = &ObservedAddr{
+			Addr:   addr,
+			SeenBy: make(map[string]time.Time),
+		}
+		oas.addrs[s] = oa
+	}
+
+	// mark the observer
+	oa.SeenBy[observerGroup(observer)] = time.Now()
+	oa.LastSeen = time.Now()
+}
+
+// observerGroup is a function that determines what part of
+// a multiaddr counts as a different observer. for example,
+// two ipfs nodes at the same IP/TCP transport would get
+// the exact same NAT mapping; they would count as the
+// same observer. This may protect against NATs who assign
+// different ports to addresses at different IP hosts, but
+// not TCP ports.
+//
+// Here, we use the root multiaddr address. This is mostly
+// IP addresses. In practice, this is what we want.
+func observerGroup(m ma.Multiaddr) string {
+	//TODO: If IPv6 rolls out we should mark /64 routing zones as one group
+	return ma.Split(m)[0].String()
+}
+
+func (oas *ObservedAddrSet) SetTTL(ttl time.Duration) {
+	oas.Lock()
+	defer oas.Unlock()
+	oas.ttl = ttl
+}
+
+func (oas *ObservedAddrSet) TTL() time.Duration {
+	oas.Lock()
+	defer oas.Unlock()
+	// for zero-value.
+	if oas.addrs == nil {
+		oas.ttl = pstore.OwnObservedAddrTTL
+	}
+	return oas.ttl
+}
diff --git a/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/pb/identify.pb.go b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/pb/identify.pb.go
new file mode 100644
index 000000000..cc4cba497
--- /dev/null
+++ b/vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/pb/identify.pb.go
@@ -0,0 +1,91 @@
+// Code generated by protoc-gen-gogo.
+// source: identify.proto
+// DO NOT EDIT!
+
+/*
+Package identify_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	identify.proto
+
+It has these top-level messages:
+	Identify
+*/
+package identify_pb
+
+import proto "github.com/gogo/protobuf/proto"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = math.Inf
+
+type Identify struct {
+	// protocolVersion determines compatibility between peers
+	ProtocolVersion *string `protobuf:"bytes,5,opt,name=protocolVersion" json:"protocolVersion,omitempty"`
+	// agentVersion is like a UserAgent string in browsers, or client version in bittorrent
+	// includes the client name and client.
+	AgentVersion *string `protobuf:"bytes,6,opt,name=agentVersion" json:"agentVersion,omitempty"`
+	// publicKey is this node's public key (which also gives its node.ID)
+	// - may not need to be sent, as secure channel implies it has been sent.
+	// - then again, if we change / disable secure channel, may still want it.
+	PublicKey []byte `protobuf:"bytes,1,opt,name=publicKey" json:"publicKey,omitempty"`
+	// listenAddrs are the multiaddrs the sender node listens for open connections on
+	ListenAddrs [][]byte `protobuf:"bytes,2,rep,name=listenAddrs" json:"listenAddrs,omitempty"`
+	// oservedAddr is the multiaddr of the remote endpoint that the sender node perceives
+	// this is useful information to convey to the other side, as it helps the remote endpoint
+	// determine whether its connection to the local peer goes through NAT.
+	ObservedAddr []byte `protobuf:"bytes,4,opt,name=observedAddr" json:"observedAddr,omitempty"`
+	// protocols are the services this node is running
+	Protocols        []string `protobuf:"bytes,3,rep,name=protocols" json:"protocols,omitempty"`
+	XXX_unrecognized []byte   `json:"-"`
+}
+
+func (m *Identify) Reset()         { *m = Identify{} }
+func (m *Identify) String() string { return proto.CompactTextString(m) }
+func (*Identify) ProtoMessage()    {}
+
+func (m *Identify) GetProtocolVersion() string {
+	if m != nil && m.ProtocolVersion != nil {
+		return *m.ProtocolVersion
+	}
+	return ""
+}
+
+func (m *Identify) GetAgentVersion() string {
+	if m != nil && m.AgentVersion != nil {
+		return *m.AgentVersion
+	}
+	return ""
+}
+
+func (m *Identify) GetPublicKey() []byte {
+	if m != nil {
+		return m.PublicKey
+	}
+	return nil
+}
+
+func (m *Identify) GetListenAddrs() [][]byte {
+	if m != nil {
+		return m.ListenAddrs
+	}
+	return nil
+}
+
+func (m *Identify) GetObservedAddr() []byte {
+	if m != nil {
+		return m.ObservedAddr
+	}
+	return nil
+}
+
+func (m *Identify) GetProtocols() []string {
+	if m != nil {
+		return m.Protocols
+	}
+	return nil
+}
+
+func init() {
+}
diff --git a/vendor/github.com/libp2p/go-maddr-filter/LICENSE b/vendor/github.com/libp2p/go-maddr-filter/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-maddr-filter/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-maddr-filter/filter.go b/vendor/github.com/libp2p/go-maddr-filter/filter.go
new file mode 100644
index 000000000..9379474d5
--- /dev/null
+++ b/vendor/github.com/libp2p/go-maddr-filter/filter.go
@@ -0,0 +1,67 @@
+package filter
+
+import (
+	"net"
+	"sync"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+type Filters struct {
+	mu      sync.RWMutex
+	filters map[string]*net.IPNet
+}
+
+func NewFilters() *Filters {
+	return &Filters{
+		filters: make(map[string]*net.IPNet),
+	}
+}
+
+func (fs *Filters) AddDialFilter(f *net.IPNet) {
+	fs.mu.Lock()
+	defer fs.mu.Unlock()
+	fs.filters[f.String()] = f
+}
+
+func (f *Filters) AddrBlocked(a ma.Multiaddr) bool {
+	maddr := ma.Split(a)
+	if len(maddr) == 0 {
+		return false
+	}
+	netaddr, err := manet.ToNetAddr(maddr[0])
+	if err != nil {
+		// if we cant parse it, its probably not blocked
+		return false
+	}
+	netip := net.ParseIP(netaddr.String())
+	if netip == nil {
+		return false
+	}
+
+	f.mu.RLock()
+	defer f.mu.RUnlock()
+	for _, ft := range f.filters {
+		if ft.Contains(netip) {
+			return true
+		}
+	}
+	return false
+}
+
+func (f *Filters) Filters() []*net.IPNet {
+	var out []*net.IPNet
+	f.mu.RLock()
+	defer f.mu.RUnlock()
+	for _, ff := range f.filters {
+		out = append(out, ff)
+	}
+	return out
+}
+
+func (f *Filters) Remove(ff *net.IPNet) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	delete(f.filters, ff.String())
+}
diff --git a/vendor/github.com/libp2p/go-msgio/LICENSE b/vendor/github.com/libp2p/go-msgio/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-msgio/chan.go b/vendor/github.com/libp2p/go-msgio/chan.go
new file mode 100644
index 000000000..f7ce3b24a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/chan.go
@@ -0,0 +1,114 @@
+package msgio
+
+import (
+	"io"
+
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+// Chan is a msgio duplex channel. It is used to have a channel interface
+// around a msgio.Reader or Writer.
+type Chan struct {
+	MsgChan   chan []byte
+	ErrChan   chan error
+	CloseChan chan bool
+}
+
+// NewChan constructs a Chan with a given buffer size.
+func NewChan(chanSize int) *Chan {
+	return &Chan{
+		MsgChan:   make(chan []byte, chanSize),
+		ErrChan:   make(chan error, 1),
+		CloseChan: make(chan bool, 2),
+	}
+}
+
+// ReadFrom wraps the given io.Reader with a msgio.Reader, reads all
+// messages, ands sends them down the channel.
+func (s *Chan) ReadFrom(r io.Reader) {
+	s.readFrom(NewReader(r))
+}
+
+// ReadFromWithPool wraps the given io.Reader with a msgio.Reader, reads all
+// messages, ands sends them down the channel. Uses given Pool
+func (s *Chan) ReadFromWithPool(r io.Reader, p *mpool.Pool) {
+	s.readFrom(NewReaderWithPool(r, p))
+}
+
+// ReadFrom wraps the given io.Reader with a msgio.Reader, reads all
+// messages, ands sends them down the channel.
+func (s *Chan) readFrom(mr Reader) {
+	// single reader, no need for Mutex
+	mr.(*reader).lock = new(nullLocker)
+
+Loop:
+	for {
+		buf, err := mr.ReadMsg()
+		if err != nil {
+			if err == io.EOF {
+				break Loop // done
+			}
+
+			// unexpected error. tell the client.
+			s.ErrChan <- err
+			break Loop
+		}
+
+		select {
+		case <-s.CloseChan:
+			break Loop // told we're done
+		case s.MsgChan <- buf:
+			// ok seems fine. send it away
+		}
+	}
+
+	close(s.MsgChan)
+	// signal we're done
+	s.CloseChan <- true
+}
+
+// WriteTo wraps the given io.Writer with a msgio.Writer, listens on the
+// channel and writes all messages to the writer.
+func (s *Chan) WriteTo(w io.Writer) {
+	// new buffer per message
+	// if bottleneck, cycle around a set of buffers
+	mw := NewWriter(w)
+
+	// single writer, no need for Mutex
+	mw.(*writer).lock = new(nullLocker)
+Loop:
+	for {
+		select {
+		case <-s.CloseChan:
+			break Loop // told we're done
+
+		case msg, ok := <-s.MsgChan:
+			if !ok { // chan closed
+				break Loop
+			}
+
+			if err := mw.WriteMsg(msg); err != nil {
+				if err != io.EOF {
+					// unexpected error. tell the client.
+					s.ErrChan <- err
+				}
+
+				break Loop
+			}
+		}
+	}
+
+	// signal we're done
+	s.CloseChan <- true
+}
+
+// Close the Chan
+func (s *Chan) Close() {
+	s.CloseChan <- true
+}
+
+// nullLocker conforms to the sync.Locker interface but does nothing.
+type nullLocker struct{}
+
+func (l *nullLocker) Lock()   {}
+func (l *nullLocker) Unlock() {}
diff --git a/vendor/github.com/libp2p/go-msgio/fuzz.go b/vendor/github.com/libp2p/go-msgio/fuzz.go
new file mode 100644
index 000000000..055abdbb0
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/fuzz.go
@@ -0,0 +1,23 @@
+// +build gofuzz
+
+package msgio
+
+import "bytes"
+
+// get the go-fuzz tools and build a fuzzer
+// $ go get -u github.com/dvyukov/go-fuzz/...
+// $ go-fuzz-build github.com/libp2p/go-msgio
+
+// put a corpus of random (even better if actual, structured) data in a corpus directry
+// $ go-fuzz -bin ./msgio-fuzz -corpus corpus -workdir=wdir -timeout=15
+
+func Fuzz(data []byte) int {
+	rc := NewReader(bytes.NewReader(data))
+	// rc := NewVarintReader(bytes.NewReader(data))
+
+	if _, err := rc.ReadMsg(); err != nil {
+		return 0
+	}
+
+	return 1
+}
diff --git a/vendor/github.com/libp2p/go-msgio/limit.go b/vendor/github.com/libp2p/go-msgio/limit.go
new file mode 100644
index 000000000..bce33cff1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/limit.go
@@ -0,0 +1,45 @@
+package msgio
+
+import (
+	"bytes"
+	"io"
+	"sync"
+)
+
+// LimitedReader wraps an io.Reader with a msgio framed reader. The LimitedReader
+// will return a reader which will io.EOF when the msg length is done.
+func LimitedReader(r io.Reader) (io.Reader, error) {
+	l, err := ReadLen(r, nil)
+	return io.LimitReader(r, int64(l)), err
+}
+
+// LimitedWriter wraps an io.Writer with a msgio framed writer. It is the inverse
+// of LimitedReader: it will buffer all writes until "Flush" is called. When Flush
+// is called, it will write the size of the buffer first, flush the buffer, reset
+// the buffer, and begin accept more incoming writes.
+func NewLimitedWriter(w io.Writer) *LimitedWriter {
+	return &LimitedWriter{W: w}
+}
+
+type LimitedWriter struct {
+	W io.Writer
+	B bytes.Buffer
+	M sync.Mutex
+}
+
+func (w *LimitedWriter) Write(buf []byte) (n int, err error) {
+	w.M.Lock()
+	n, err = w.B.Write(buf)
+	w.M.Unlock()
+	return n, err
+}
+
+func (w *LimitedWriter) Flush() error {
+	w.M.Lock()
+	defer w.M.Unlock()
+	if err := WriteLen(w.W, w.B.Len()); err != nil {
+		return err
+	}
+	_, err := w.B.WriteTo(w.W)
+	return err
+}
diff --git a/vendor/github.com/libp2p/go-msgio/mpool/pool.go b/vendor/github.com/libp2p/go-msgio/mpool/pool.go
new file mode 100644
index 000000000..2c8681e4d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/mpool/pool.go
@@ -0,0 +1,114 @@
+// Package mpool provides a sync.Pool equivalent that buckets incoming
+// requests to one of 32 sub-pools, one for each power of 2, 0-32.
+//
+//	import "github.com/libp2p/go-msgio/mpool"
+//	var p mpool.Pool
+//
+//	small := make([]byte, 1024)
+//	large := make([]byte, 4194304)
+//	p.Put(1024, small)
+//	p.Put(4194304, large)
+//
+//	small2 := p.Get(1024).([]byte)
+//	large2 := p.Get(4194304).([]byte)
+//	fmt.Println("small2 len:", len(small2))
+//	fmt.Println("large2 len:", len(large2))
+//
+//	// Output:
+//	// small2 len: 1024
+//	// large2 len: 4194304
+//
+package mpool
+
+import (
+	"fmt"
+	"sync"
+)
+
+// ByteSlicePool is a static Pool for reusing byteslices of various sizes.
+var ByteSlicePool Pool
+
+func init() {
+	ByteSlicePool.New = func(length int) interface{} {
+		return make([]byte, length)
+	}
+}
+
+// MaxLength is the maximum length of an element that can be added to the Pool.
+const MaxLength = 1 << 32
+
+// Pool is a pool to handle cases of reusing elements of varying sizes.
+// It maintains up to  32 internal pools, for each power of 2 in 0-32.
+type Pool struct {
+	pools [32]sync.Pool // a list of singlePools
+
+	// New is a function that constructs a new element in the pool, with given len
+	New func(len int) interface{}
+}
+
+func (p *Pool) getPool(idx uint32) *sync.Pool {
+	if idx > uint32(len(p.pools)) {
+		panic(fmt.Errorf("index too large: %d", idx))
+	}
+	return &p.pools[idx]
+}
+
+// Get selects an arbitrary item from the Pool, removes it from the Pool,
+// and returns it to the caller. Get may choose to ignore the pool and
+// treat it as empty. Callers should not assume any relation between values
+// passed to Put and the values returned by Get.
+//
+// If Get would otherwise return nil and p.New is non-nil, Get returns the
+// result of calling p.New.
+func (p *Pool) Get(length uint32) interface{} {
+	idx := nextPowerOfTwo(length)
+	sp := p.getPool(idx)
+	// fmt.Printf("Get(%d) idx(%d)\n", length, idx)
+	val := sp.Get()
+	if val == nil && p.New != nil {
+		val = p.New(0x1 << idx)
+	}
+	return val
+}
+
+// Put adds x to the pool.
+func (p *Pool) Put(length uint32, val interface{}) {
+	idx := prevPowerOfTwo(length)
+	// fmt.Printf("Put(%d, -) idx(%d)\n", length, idx)
+	sp := p.getPool(idx)
+	sp.Put(val)
+}
+
+func nextPowerOfTwo(v uint32) uint32 {
+	// fmt.Printf("nextPowerOfTwo(%d) ", v)
+	v--
+	v |= v >> 1
+	v |= v >> 2
+	v |= v >> 4
+	v |= v >> 8
+	v |= v >> 16
+	v++
+
+	// fmt.Printf("-> %d", v)
+
+	i := uint32(0)
+	for ; v > 1; i++ {
+		v = v >> 1
+	}
+
+	// fmt.Printf("-> %d\n", i)
+	return i
+}
+
+func prevPowerOfTwo(num uint32) uint32 {
+	next := nextPowerOfTwo(num)
+	// fmt.Printf("prevPowerOfTwo(%d) next: %d", num, next)
+	switch {
+	case num == (1 << next): // num is a power of 2
+	case next == 0:
+	default:
+		next = next - 1 // smaller
+	}
+	// fmt.Printf(" = %d\n", next)
+	return next
+}
diff --git a/vendor/github.com/libp2p/go-msgio/msgio.go b/vendor/github.com/libp2p/go-msgio/msgio.go
new file mode 100644
index 000000000..4e494b68e
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/msgio.go
@@ -0,0 +1,284 @@
+package msgio
+
+import (
+	"errors"
+	"io"
+	"sync"
+
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+//  ErrMsgTooLarge is returned when the message length is exessive
+var ErrMsgTooLarge = errors.New("message too large")
+
+const (
+	lengthSize     = 4
+	defaultMaxSize = 8 * 1024 * 1024 // 8mb
+)
+
+// Writer is the msgio Writer interface. It writes len-framed messages.
+type Writer interface {
+
+	// Write writes passed in buffer as a single message.
+	Write([]byte) (int, error)
+
+	// WriteMsg writes the msg in the passed in buffer.
+	WriteMsg([]byte) error
+}
+
+// WriteCloser is a Writer + Closer interface. Like in `golang/pkg/io`
+type WriteCloser interface {
+	Writer
+	io.Closer
+}
+
+// Reader is the msgio Reader interface. It reads len-framed messages.
+type Reader interface {
+
+	// Read reads the next message from the Reader.
+	// The client must pass a buffer large enough, or io.ErrShortBuffer will be
+	// returned.
+	Read([]byte) (int, error)
+
+	// ReadMsg reads the next message from the Reader.
+	// Uses a mpool.Pool internally to reuse buffers. io.ErrShortBuffer will
+	// be returned if the Pool.Get(...) returns nil.
+	// User may call ReleaseMsg(msg) to signal a buffer can be reused.
+	ReadMsg() ([]byte, error)
+
+	// ReleaseMsg signals a buffer can be reused.
+	ReleaseMsg([]byte)
+
+	// NextMsgLen returns the length of the next (peeked) message. Does
+	// not destroy the message or have other adverse effects
+	NextMsgLen() (int, error)
+}
+
+// ReadCloser combines a Reader and Closer.
+type ReadCloser interface {
+	Reader
+	io.Closer
+}
+
+// ReadWriter combines a Reader and Writer.
+type ReadWriter interface {
+	Reader
+	Writer
+}
+
+// ReadWriteCloser combines a Reader, a Writer, and Closer.
+type ReadWriteCloser interface {
+	Reader
+	Writer
+	io.Closer
+}
+
+// writer is the underlying type that implements the Writer interface.
+type writer struct {
+	W io.Writer
+
+	lock sync.Locker
+}
+
+// NewWriter wraps an io.Writer with a msgio framed writer. The msgio.Writer
+// will write the length prefix of every message written.
+func NewWriter(w io.Writer) WriteCloser {
+	return &writer{W: w, lock: new(sync.Mutex)}
+}
+
+func (s *writer) Write(msg []byte) (int, error) {
+	err := s.WriteMsg(msg)
+	if err != nil {
+		return 0, err
+	}
+	return len(msg), nil
+}
+
+func (s *writer) WriteMsg(msg []byte) (err error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	if err := WriteLen(s.W, len(msg)); err != nil {
+		return err
+	}
+	_, err = s.W.Write(msg)
+	return err
+}
+
+func (s *writer) Close() error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if c, ok := s.W.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+// reader is the underlying type that implements the Reader interface.
+type reader struct {
+	R io.Reader
+
+	lbuf []byte
+	next int
+	pool *mpool.Pool
+	lock sync.Locker
+	max  int // the maximal message size (in bytes) this reader handles
+}
+
+// NewReader wraps an io.Reader with a msgio framed reader. The msgio.Reader
+// will read whole messages at a time (using the length). Assumes an equivalent
+// writer on the other side.
+func NewReader(r io.Reader) ReadCloser {
+	return NewReaderWithPool(r, &mpool.ByteSlicePool)
+}
+
+// NewReaderWithPool wraps an io.Reader with a msgio framed reader. The msgio.Reader
+// will read whole messages at a time (using the length). Assumes an equivalent
+// writer on the other side.  It uses a given mpool.Pool
+func NewReaderWithPool(r io.Reader, p *mpool.Pool) ReadCloser {
+	if p == nil {
+		panic("nil pool")
+	}
+	return &reader{
+		R:    r,
+		lbuf: make([]byte, lengthSize),
+		next: -1,
+		pool: p,
+		lock: new(sync.Mutex),
+		max:  defaultMaxSize,
+	}
+}
+
+// NextMsgLen reads the length of the next msg into s.lbuf, and returns it.
+// WARNING: like Read, NextMsgLen is destructive. It reads from the internal
+// reader.
+func (s *reader) NextMsgLen() (int, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return s.nextMsgLen()
+}
+
+func (s *reader) nextMsgLen() (int, error) {
+	if s.next == -1 {
+		n, err := ReadLen(s.R, s.lbuf)
+		if err != nil {
+			return 0, err
+		}
+
+		s.next = n
+	}
+	return s.next, nil
+}
+
+func (s *reader) Read(msg []byte) (int, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	length, err := s.nextMsgLen()
+	if err != nil {
+		return 0, err
+	}
+
+	if length > len(msg) {
+		return 0, io.ErrShortBuffer
+	}
+
+	_, err = io.ReadFull(s.R, msg[:length])
+	s.next = -1 // signal we've consumed this msg
+	return length, err
+}
+
+func (s *reader) ReadMsg() ([]byte, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	length, err := s.nextMsgLen()
+	if err != nil {
+		return nil, err
+	}
+
+	if length > s.max || length < 0 {
+		return nil, ErrMsgTooLarge
+	}
+
+	msgb := s.pool.Get(uint32(length))
+	if msgb == nil {
+		return nil, io.ErrShortBuffer
+	}
+	msg := msgb.([]byte)[:length]
+	_, err = io.ReadFull(s.R, msg)
+	s.next = -1 // signal we've consumed this msg
+	return msg, err
+}
+
+func (s *reader) ReleaseMsg(msg []byte) {
+	s.pool.Put(uint32(cap(msg)), msg)
+}
+
+func (s *reader) Close() error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if c, ok := s.R.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+// readWriter is the underlying type that implements a ReadWriter.
+type readWriter struct {
+	Reader
+	Writer
+}
+
+// NewReadWriter wraps an io.ReadWriter with a msgio.ReadWriter. Writing
+// and Reading will be appropriately framed.
+func NewReadWriter(rw io.ReadWriter) ReadWriteCloser {
+	return &readWriter{
+		Reader: NewReader(rw),
+		Writer: NewWriter(rw),
+	}
+}
+
+// Combine wraps a pair of msgio.Writer and msgio.Reader with a msgio.ReadWriter.
+func Combine(w Writer, r Reader) ReadWriteCloser {
+	return &readWriter{Reader: r, Writer: w}
+}
+
+func (rw *readWriter) Close() error {
+	var errs []error
+
+	if w, ok := rw.Writer.(WriteCloser); ok {
+		if err := w.Close(); err != nil {
+			errs = append(errs, err)
+		}
+	}
+	if r, ok := rw.Reader.(ReadCloser); ok {
+		if err := r.Close(); err != nil {
+			errs = append(errs, err)
+		}
+	}
+
+	if len(errs) > 0 {
+		return multiErr(errs)
+	}
+	return nil
+}
+
+// multiErr is a util to return multiple errors
+type multiErr []error
+
+func (m multiErr) Error() string {
+	if len(m) == 0 {
+		return "no errors"
+	}
+
+	s := "Multiple errors: "
+	for i, e := range m {
+		if i != 0 {
+			s += ", "
+		}
+		s += e.Error()
+	}
+	return s
+}
diff --git a/vendor/github.com/libp2p/go-msgio/num.go b/vendor/github.com/libp2p/go-msgio/num.go
new file mode 100644
index 000000000..513c1994f
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/num.go
@@ -0,0 +1,33 @@
+package msgio
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+// NBO is NetworkByteOrder
+var NBO = binary.BigEndian
+
+// WriteLen writes a length to the given writer.
+func WriteLen(w io.Writer, l int) error {
+	ul := uint32(l)
+	return binary.Write(w, NBO, &ul)
+}
+
+// ReadLen reads a length from the given reader.
+// if buf is non-nil, it reuses the buffer. Ex:
+//    l, err := ReadLen(r, nil)
+//    _, err := ReadLen(r, buf)
+func ReadLen(r io.Reader, buf []byte) (int, error) {
+	if len(buf) < 4 {
+		buf = make([]byte, 4)
+	}
+	buf = buf[:4]
+
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return 0, err
+	}
+
+	n := int(NBO.Uint32(buf))
+	return n, nil
+}
diff --git a/vendor/github.com/libp2p/go-msgio/varint.go b/vendor/github.com/libp2p/go-msgio/varint.go
new file mode 100644
index 000000000..719f89025
--- /dev/null
+++ b/vendor/github.com/libp2p/go-msgio/varint.go
@@ -0,0 +1,188 @@
+package msgio
+
+import (
+	"encoding/binary"
+	"io"
+	"sync"
+
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+// varintWriter is the underlying type that implements the Writer interface.
+type varintWriter struct {
+	W io.Writer
+
+	lbuf []byte      // for encoding varints
+	lock sync.Locker // for threadsafe writes
+}
+
+// NewVarintWriter wraps an io.Writer with a varint msgio framed writer.
+// The msgio.Writer will write the length prefix of every message written
+// as a varint, using https://golang.org/pkg/encoding/binary/#PutUvarint
+func NewVarintWriter(w io.Writer) WriteCloser {
+	return &varintWriter{
+		W:    w,
+		lbuf: make([]byte, binary.MaxVarintLen64),
+		lock: new(sync.Mutex),
+	}
+}
+
+func (s *varintWriter) Write(msg []byte) (int, error) {
+	err := s.WriteMsg(msg)
+	if err != nil {
+		return 0, err
+	}
+	return len(msg), nil
+}
+
+func (s *varintWriter) WriteMsg(msg []byte) error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	length := uint64(len(msg))
+	n := binary.PutUvarint(s.lbuf, length)
+	if _, err := s.W.Write(s.lbuf[:n]); err != nil {
+		return err
+	}
+	_, err := s.W.Write(msg)
+	return err
+}
+
+func (s *varintWriter) Close() error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if c, ok := s.W.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+// varintReader is the underlying type that implements the Reader interface.
+type varintReader struct {
+	R  io.Reader
+	br io.ByteReader // for reading varints.
+
+	lbuf []byte
+	next int
+	pool *mpool.Pool
+	lock sync.Locker
+	max  int // the maximal message size (in bytes) this reader handles
+}
+
+// NewVarintReader wraps an io.Reader with a varint msgio framed reader.
+// The msgio.Reader will read whole messages at a time (using the length).
+// Varints read according to https://golang.org/pkg/encoding/binary/#ReadUvarint
+// Assumes an equivalent writer on the other side.
+func NewVarintReader(r io.Reader) ReadCloser {
+	return NewVarintReaderWithPool(r, &mpool.ByteSlicePool)
+}
+
+// NewVarintReaderWithPool wraps an io.Reader with a varint msgio framed reader.
+// The msgio.Reader will read whole messages at a time (using the length).
+// Varints read according to https://golang.org/pkg/encoding/binary/#ReadUvarint
+// Assumes an equivalent writer on the other side. It uses a given mpool.Pool
+func NewVarintReaderWithPool(r io.Reader, p *mpool.Pool) ReadCloser {
+	if p == nil {
+		panic("nil pool")
+	}
+	return &varintReader{
+		R:    r,
+		br:   &simpleByteReader{R: r},
+		lbuf: make([]byte, binary.MaxVarintLen64),
+		next: -1,
+		pool: p,
+		lock: new(sync.Mutex),
+		max:  defaultMaxSize,
+	}
+}
+
+// NextMsgLen reads the length of the next msg into s.lbuf, and returns it.
+// WARNING: like Read, NextMsgLen is destructive. It reads from the internal
+// reader.
+func (s *varintReader) NextMsgLen() (int, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	return s.nextMsgLen()
+}
+
+func (s *varintReader) nextMsgLen() (int, error) {
+	if s.next == -1 {
+		length, err := binary.ReadUvarint(s.br)
+		if err != nil {
+			return 0, err
+		}
+		s.next = int(length)
+	}
+	return s.next, nil
+}
+
+func (s *varintReader) Read(msg []byte) (int, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	length, err := s.nextMsgLen()
+	if err != nil {
+		return 0, err
+	}
+
+	if length > len(msg) {
+		return 0, io.ErrShortBuffer
+	}
+	_, err = io.ReadFull(s.R, msg[:length])
+	s.next = -1 // signal we've consumed this msg
+	return length, err
+}
+
+func (s *varintReader) ReadMsg() ([]byte, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	length, err := s.nextMsgLen()
+	if err != nil {
+		return nil, err
+	}
+
+	if length > s.max {
+		return nil, ErrMsgTooLarge
+	}
+
+	msgb := s.pool.Get(uint32(length))
+	if msgb == nil {
+		return nil, io.ErrShortBuffer
+	}
+	msg := msgb.([]byte)[:length]
+	_, err = io.ReadFull(s.R, msg)
+	s.next = -1 // signal we've consumed this msg
+	return msg, err
+}
+
+func (s *varintReader) ReleaseMsg(msg []byte) {
+	s.pool.Put(uint32(cap(msg)), msg)
+}
+
+func (s *varintReader) Close() error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if c, ok := s.R.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+type simpleByteReader struct {
+	R   io.Reader
+	buf []byte
+}
+
+func (r *simpleByteReader) ReadByte() (c byte, err error) {
+	if r.buf == nil {
+		r.buf = make([]byte, 1)
+	}
+
+	if _, err := io.ReadFull(r.R, r.buf); err != nil {
+		return 0, err
+	}
+	return r.buf[0], nil
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/LICENSE b/vendor/github.com/libp2p/go-reuseport-transport/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/dial.go b/vendor/github.com/libp2p/go-reuseport-transport/dial.go
new file mode 100644
index 000000000..a16b5b2b7
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/dial.go
@@ -0,0 +1,113 @@
+package tcpreuse
+
+import (
+	"context"
+	"net"
+
+	reuseport "github.com/libp2p/go-reuseport"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+type dialer interface {
+	Dial(network, addr string) (net.Conn, error)
+	DialContext(ctx context.Context, network, addr string) (net.Conn, error)
+}
+
+// Dial dials the given multiaddr, reusing ports we're currently listening on if
+// possible.
+//
+// Dial attempts to be smart about choosing the source port. For example, If
+// we're dialing a loopback address and we're listening on one or more loopback
+// ports, Dial will randomly choose one of the loopback ports and addresses and
+// reuse it.
+func (t *Transport) Dial(raddr ma.Multiaddr) (manet.Conn, error) {
+	return t.DialContext(context.Background(), raddr)
+}
+
+// DialContext is like Dial but takes a context.
+func (t *Transport) DialContext(ctx context.Context, raddr ma.Multiaddr) (manet.Conn, error) {
+	network, addr, err := manet.DialArgs(raddr)
+	if err != nil {
+		return nil, err
+	}
+	var d dialer
+	switch network {
+	case "tcp4":
+		d = t.v4.getDialer(network)
+	case "tcp6":
+		d = t.v6.getDialer(network)
+	default:
+		return nil, ErrWrongProto
+	}
+	conn, err := d.DialContext(ctx, network, addr)
+	if err != nil {
+		return nil, err
+	}
+	maconn, err := manet.WrapNetConn(conn)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return maconn, nil
+}
+
+func (n *network) getDialer(network string) dialer {
+	n.mu.RLock()
+	d := n.dialer
+	n.mu.RUnlock()
+	if d == nil {
+		n.mu.Lock()
+		defer n.mu.Unlock()
+
+		if n.dialer == nil {
+			n.dialer = n.makeDialer(network)
+		}
+		d = n.dialer
+	}
+	return d
+}
+
+func (n *network) makeDialer(network string) dialer {
+	if !reuseport.Available() {
+		log.Debug("reuseport not available")
+		return &net.Dialer{}
+	}
+
+	var unspec net.IP
+	switch network {
+	case "tcp4":
+		unspec = net.IPv4zero
+	case "tcp6":
+		unspec = net.IPv6unspecified
+	default:
+		panic("invalid network: must be either tcp4 or tcp6")
+	}
+
+	// How many ports are we listening on.
+	var port = 0
+	for l := range n.listeners {
+		newPort := l.Addr().(*net.TCPAddr).Port
+		switch {
+		case newPort == 0: // Any port, ignore (really, we shouldn't get this case...).
+		case port == 0: // Haven't selected a port yet, choose this one.
+			port = newPort
+		case newPort == port: // Same as the selected port, continue...
+		default: // Multiple ports, use the multi dialer
+			return newMultiDialer(unspec, n.listeners)
+		}
+	}
+
+	// None.
+	if port == 0 {
+		return &net.Dialer{}
+	}
+
+	// One. Always dial from the single port we're listening on.
+	laddr := &net.TCPAddr{
+		IP:   unspec,
+		Port: port,
+	}
+
+	return (*singleDialer)(laddr)
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/listen.go b/vendor/github.com/libp2p/go-reuseport-transport/listen.go
new file mode 100644
index 000000000..7b2a4c39d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/listen.go
@@ -0,0 +1,80 @@
+package tcpreuse
+
+import (
+	"net"
+
+	reuseport "github.com/libp2p/go-reuseport"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+type listener struct {
+	manet.Listener
+	network *network
+}
+
+func (l *listener) Close() error {
+	l.network.mu.Lock()
+	delete(l.network.listeners, l)
+	l.network.dialer = nil
+	l.network.mu.Unlock()
+	return l.Listener.Close()
+}
+
+// Listen listens on the given multiaddr.
+//
+// If reuseport is supported, it will be enabled for this listener and future
+// dials from this transport may reuse the port.
+//
+// Note: You can listen on the same multiaddr as many times as you want
+// (although only *one* listener will end up handling the inbound connection).
+func (t *Transport) Listen(laddr ma.Multiaddr) (manet.Listener, error) {
+	nw, naddr, err := manet.DialArgs(laddr)
+	if err != nil {
+		return nil, err
+	}
+	var n *network
+	switch nw {
+	case "tcp4":
+		n = &t.v4
+	case "tcp6":
+		n = &t.v6
+	default:
+		return nil, ErrWrongProto
+	}
+
+	if !reuseport.Available() {
+		return manet.Listen(laddr)
+	}
+	nl, err := reuseport.Listen(nw, naddr)
+	if err != nil {
+		return manet.Listen(laddr)
+	}
+
+	if _, ok := nl.Addr().(*net.TCPAddr); !ok {
+		nl.Close()
+		return nil, ErrWrongProto
+	}
+
+	malist, err := manet.WrapNetListener(nl)
+	if err != nil {
+		nl.Close()
+		return nil, err
+	}
+
+	list := &listener{
+		Listener: malist,
+		network:  n,
+	}
+
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	if n.listeners == nil {
+		n.listeners = make(map[*listener]struct{})
+	}
+	n.listeners[list] = struct{}{}
+	n.dialer = nil
+
+	return list, nil
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/multidialer.go b/vendor/github.com/libp2p/go-reuseport-transport/multidialer.go
new file mode 100644
index 000000000..c7d388c14
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/multidialer.go
@@ -0,0 +1,110 @@
+package tcpreuse
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"net"
+)
+
+type multiDialer struct {
+	loopback    []*net.TCPAddr
+	unspecified []*net.TCPAddr
+	global      *net.TCPAddr
+}
+
+func (d *multiDialer) Dial(network, addr string) (net.Conn, error) {
+	return d.DialContext(context.Background(), network, addr)
+}
+
+func randAddr(addrs []*net.TCPAddr) *net.TCPAddr {
+	if len(addrs) > 0 {
+		return addrs[rand.Intn(len(addrs))]
+	}
+	return nil
+}
+
+func (d *multiDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
+	tcpAddr, err := net.ResolveTCPAddr(network, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	// We pick the source *port* based on the following algorithm.
+	//
+	// 1. If we're dialing loopback, choose a source-port in order of
+	//    preference:
+	//   1. A port in-use by an explicit loopback listener.
+	//   2. A port in-use by a listener on an unspecified address (must
+	//      also be listening on localhost).
+	//   3. A port in-use by a listener on a global address. We don't have
+	//      any other better options (other than picking a random port).
+	// 2. If we're dialing a global address, choose a source-port in order
+	//    of preference:
+	//   1. A port in-use by a listener on an unspecified address (the most
+	//      general case).
+	//   2. A port in-use by a listener on the global address.
+	// 3. Fail on link-local dials (go-ipfs currently forbids this and I
+	//    figured we could try lifting this restriction later).
+	//
+	//
+	// Note: We *always* dial from the unspecified address (regardless of
+	// the port we pick). In the future, we could use netlink (on Linux) to
+	// figure out the right source address but we're going to punt on that.
+
+	ip := tcpAddr.IP
+	source := d.global
+	switch {
+	case ip.IsLoopback():
+		switch {
+		case len(d.loopback) > 0:
+			source = randAddr(d.loopback)
+		case len(d.unspecified) > 0:
+			source = randAddr(d.unspecified)
+		}
+	case ip.IsGlobalUnicast():
+		switch {
+		case len(d.unspecified) > 0:
+			source = randAddr(d.unspecified)
+		}
+	default:
+		return nil, fmt.Errorf("undialable IP: %s", tcpAddr.IP)
+	}
+	return reuseDial(ctx, source, network, addr)
+}
+
+func newMultiDialer(unspec net.IP, listeners map[*listener]struct{}) dialer {
+	m := new(multiDialer)
+	for l := range listeners {
+		laddr := l.Addr().(*net.TCPAddr)
+		switch {
+		case laddr.IP.IsLoopback():
+			m.loopback = append(m.loopback, laddr)
+		case laddr.IP.IsGlobalUnicast():
+			// Different global ports? Crap.
+			//
+			// The *proper* way to deal with this is to, e.g., use
+			// netlink to figure out which source address we would
+			// normally use to dial a destination address and then
+			// pick one of the ports we're listening on on that
+			// source address. However, this is a pain in the ass.
+			//
+			// Instead, we're just going to always dial from the
+			// unspecified address with the first global port we
+			// find.
+			//
+			// TODO: Port priority? Addr priority?
+			if m.global == nil {
+				m.global = &net.TCPAddr{
+					IP:   unspec,
+					Port: laddr.Port,
+				}
+			} else {
+				log.Warning("listening on external interfaces on multiple ports, will dial from %d, not %s", m.global, laddr)
+			}
+		case laddr.IP.IsUnspecified():
+			m.unspecified = append(m.unspecified, laddr)
+		}
+	}
+	return m
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/reuseport.go b/vendor/github.com/libp2p/go-reuseport-transport/reuseport.go
new file mode 100644
index 000000000..47ceac227
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/reuseport.go
@@ -0,0 +1,63 @@
+package tcpreuse
+
+import (
+	"context"
+	"net"
+	"syscall"
+
+	reuseport "github.com/libp2p/go-reuseport"
+)
+
+var fallbackDialer net.Dialer
+
+// reuseErrShouldRetry diagnoses whether to retry after a reuse error.
+// if we failed to bind, we should retry. if bind worked and this is a
+// real dial error (remote end didnt answer) then we should not retry.
+func reuseErrShouldRetry(err error) bool {
+	if err == nil {
+		return false // hey, it worked! no need to retry.
+	}
+
+	// if it's a network timeout error, it's a legitimate failure.
+	if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
+		return false
+	}
+
+	errno, ok := err.(syscall.Errno)
+	if !ok { // not an errno? who knows what this is. retry.
+		return true
+	}
+
+	switch errno {
+	case syscall.EADDRINUSE, syscall.EADDRNOTAVAIL:
+		return true // failure to bind. retry.
+	case syscall.ECONNREFUSED:
+		return false // real dial error
+	default:
+		return true // optimistically default to retry.
+	}
+}
+
+// Dials using reusport and then redials normally if that fails.
+func reuseDial(ctx context.Context, laddr *net.TCPAddr, network, raddr string) (net.Conn, error) {
+	if laddr == nil {
+		return fallbackDialer.DialContext(ctx, network, raddr)
+	}
+
+	d := reuseport.Dialer{
+		D: net.Dialer{
+			LocalAddr: laddr,
+		},
+	}
+
+	con, err := d.DialContext(ctx, network, raddr)
+	if err == nil {
+		return con, nil
+	}
+
+	if reuseErrShouldRetry(err) && ctx.Err() == nil {
+		log.Debugf("failed to reuse port, dialing with a random port: %s", err)
+		con, err = fallbackDialer.DialContext(ctx, network, raddr)
+	}
+	return con, err
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/singledialer.go b/vendor/github.com/libp2p/go-reuseport-transport/singledialer.go
new file mode 100644
index 000000000..efb96eb1a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/singledialer.go
@@ -0,0 +1,16 @@
+package tcpreuse
+
+import (
+	"context"
+	"net"
+)
+
+type singleDialer net.TCPAddr
+
+func (d *singleDialer) Dial(network, address string) (net.Conn, error) {
+	return d.DialContext(context.Background(), network, address)
+}
+
+func (d *singleDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	return reuseDial(ctx, (*net.TCPAddr)(d), network, address)
+}
diff --git a/vendor/github.com/libp2p/go-reuseport-transport/transport.go b/vendor/github.com/libp2p/go-reuseport-transport/transport.go
new file mode 100644
index 000000000..5f094d1a1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport-transport/transport.go
@@ -0,0 +1,25 @@
+package tcpreuse
+
+import (
+	"errors"
+	"sync"
+
+	logging "github.com/ipfs/go-log"
+)
+
+var log = logging.Logger("reuseport-transport")
+
+// ErrWrongProto is returned when dialing a protocol other than tcp.
+var ErrWrongProto = errors.New("can only dial TCP over IPv4 or IPv6")
+
+// Transport is a TCP reuse transport that reuses listener ports.
+type Transport struct {
+	v4 network
+	v6 network
+}
+
+type network struct {
+	mu        sync.RWMutex
+	listeners map[*listener]struct{}
+	dialer    dialer
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/LICENSE b/vendor/github.com/libp2p/go-reuseport/LICENSE
new file mode 100644
index 000000000..0d760cbb4
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2013 Conformal Systems LLC.
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file
diff --git a/vendor/github.com/libp2p/go-reuseport/addr.go b/vendor/github.com/libp2p/go-reuseport/addr.go
new file mode 100644
index 000000000..cfffc7c8c
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/addr.go
@@ -0,0 +1,20 @@
+package reuseport
+
+import (
+	"net"
+)
+
+func ResolveAddr(network, address string) (net.Addr, error) {
+	switch network {
+	default:
+		return nil, net.UnknownNetworkError(network)
+	case "ip", "ip4", "ip6":
+		return net.ResolveIPAddr(network, address)
+	case "tcp", "tcp4", "tcp6":
+		return net.ResolveTCPAddr(network, address)
+	case "udp", "udp4", "udp6":
+		return net.ResolveUDPAddr(network, address)
+	case "unix", "unixgram", "unixpacket":
+		return net.ResolveUnixAddr(network, address)
+	}
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/available_unix.go b/vendor/github.com/libp2p/go-reuseport/available_unix.go
new file mode 100644
index 000000000..48c98bd4b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/available_unix.go
@@ -0,0 +1,47 @@
+// +build darwin freebsd dragonfly netbsd openbsd linux
+
+package reuseport
+
+import (
+	"golang.org/x/sys/unix"
+	"sync"
+	"syscall"
+	"time"
+
+	sockaddrnet "github.com/libp2p/go-sockaddr/net"
+)
+
+var (
+	hasReusePort bool
+	didReusePort sync.Once
+)
+
+// Available returns whether or not SO_REUSEPORT is available in the OS.
+// It does so by attepting to open a tcp socket, setting the option, and
+// checking ENOPROTOOPT on error. After checking, the decision is cached
+// for the rest of the process run.
+func available() bool {
+	didReusePort.Do(checkReusePort)
+	return hasReusePort
+}
+
+func checkReusePort() {
+	// there may be fluke reasons to fail to open a socket.
+	// so we give it 5 shots. if not, give up and call it not avail.
+	for i := 0; i < 5; i++ {
+		// try to setup a TCP socket.
+		fd, err := socket(sockaddrnet.AF_INET, sockaddrnet.SOCK_STREAM, sockaddrnet.IPPROTO_TCP)
+		if err == nil {
+			unix.Close(fd)
+			hasReusePort = true
+			return
+		}
+
+		if errno, ok := err.(syscall.Errno); ok && errno == unix.ENOPROTOOPT {
+			return // :( that's all folks.
+		}
+
+		// not an errno? or not ENOPROTOOPT? retry.
+		time.Sleep(20 * time.Millisecond) // wait a bit
+	}
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/impl_unix.go b/vendor/github.com/libp2p/go-reuseport/impl_unix.go
new file mode 100644
index 000000000..de989fa62
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/impl_unix.go
@@ -0,0 +1,399 @@
+// +build darwin freebsd dragonfly netbsd openbsd linux
+
+package reuseport
+
+import (
+	"context"
+	"golang.org/x/sys/unix"
+	"net"
+	"os"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/libp2p/go-reuseport/singlepoll"
+	sockaddrnet "github.com/libp2p/go-sockaddr/net"
+)
+
+const (
+	filePrefix = "port."
+)
+
+// Wrapper around the socket system call that marks the returned file
+// descriptor as nonblocking and close-on-exec.
+func socket(family, socktype, protocol int) (fd int, err error) {
+	syscall.ForkLock.RLock()
+	fd, err = unix.Socket(family, socktype, protocol)
+	if err == nil {
+		unix.CloseOnExec(fd)
+	}
+	syscall.ForkLock.RUnlock()
+
+	if err != nil {
+		return -1, err
+	}
+
+	// cant set it until after connect
+	// if err = unix.SetNonblock(fd, true); err != nil {
+	// 	unix.Close(fd)
+	// 	return -1, err
+	// }
+
+	if err = unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
+		unix.Close(fd)
+		return -1, err
+	}
+
+	if err = unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_REUSEPORT, 1); err != nil {
+		unix.Close(fd)
+		return -1, err
+	}
+
+	// set setLinger to 5 as reusing exact same (srcip:srcport, dstip:dstport)
+	// will otherwise fail on connect.
+	if err = setLinger(fd, 5); err != nil {
+		unix.Close(fd)
+		return -1, err
+	}
+
+	return fd, nil
+}
+
+func dial(ctx context.Context, dialer net.Dialer, netw, addr string) (c net.Conn, err error) {
+	var (
+		fd             int
+		lfamily        int
+		rfamily        int
+		socktype       int
+		lprotocol      int
+		rprotocol      int
+		file           *os.File
+		deadline       time.Time
+		remoteSockaddr unix.Sockaddr
+		localSockaddr  unix.Sockaddr
+	)
+
+	netAddr, err := ResolveAddr(netw, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	switch netAddr.(type) {
+	case *net.TCPAddr, *net.UDPAddr:
+	default:
+		return nil, ErrUnsupportedProtocol
+	}
+
+	switch {
+	case !dialer.Deadline.IsZero():
+		deadline = dialer.Deadline
+	case dialer.Timeout != 0:
+		deadline = time.Now().Add(dialer.Timeout)
+	}
+
+	ctxdeadline, ok := ctx.Deadline()
+	if ok && ctxdeadline.Before(deadline) {
+		deadline = ctxdeadline
+	}
+
+	localSockaddr = sockaddrnet.NetAddrToSockaddr(dialer.LocalAddr)
+	remoteSockaddr = sockaddrnet.NetAddrToSockaddr(netAddr)
+
+	rfamily = sockaddrnet.NetAddrAF(netAddr)
+	rprotocol = sockaddrnet.NetAddrIPPROTO(netAddr)
+	socktype = sockaddrnet.NetAddrSOCK(netAddr)
+
+	if dialer.LocalAddr != nil {
+		switch dialer.LocalAddr.(type) {
+		case *net.TCPAddr, *net.UDPAddr:
+		default:
+			return nil, ErrUnsupportedProtocol
+		}
+
+		// check family and protocols match.
+		lfamily = sockaddrnet.NetAddrAF(dialer.LocalAddr)
+		lprotocol = sockaddrnet.NetAddrIPPROTO(dialer.LocalAddr)
+		if lfamily != rfamily || lprotocol != rprotocol {
+			return nil, &net.AddrError{Err: "unexpected address type", Addr: netAddr.String()}
+		}
+	}
+
+	// look at dialTCP in http://golang.org/src/net/tcpsock_posix.go  .... !
+	// here we just try again 3 times.
+	for i := 0; i < 3; i++ {
+		if !deadline.IsZero() && deadline.Before(time.Now()) {
+			err = errTimeout
+			break
+		}
+
+		if fd, err = socket(rfamily, socktype, rprotocol); err != nil {
+			return nil, err
+		}
+
+		if localSockaddr != nil {
+			if err = unix.Bind(fd, localSockaddr); err != nil {
+				unix.Close(fd)
+				return nil, err
+			}
+		}
+
+		if err = unix.SetNonblock(fd, true); err != nil {
+			unix.Close(fd)
+			return nil, err
+		}
+
+		if err = connect(ctx, fd, remoteSockaddr, deadline); err != nil {
+			unix.Close(fd)
+			if ctx.Err() != nil {
+				return nil, ctx.Err()
+			}
+			continue // try again.
+		}
+
+		break
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if rprotocol == unix.IPPROTO_TCP {
+		sa, err := unix.Getsockname(fd)
+		if err != nil {
+			unix.Close(fd)
+			return nil, err
+		}
+		ra, err := unix.Getpeername(fd)
+		if err != nil {
+			unix.Close(fd)
+			return nil, err
+		}
+
+		// Need to call setLinger 0. Otherwise, the close will block for the linger period. Linux bug?
+		switch s := sa.(type) {
+		case *unix.SockaddrInet4:
+			if r, ok := ra.(*unix.SockaddrInet4); ok && r.Addr == s.Addr && r.Port == s.Port {
+				setLinger(fd, 0)
+				unix.Close(fd)
+				return nil, ErrDialSelf
+			}
+		case *unix.SockaddrInet6:
+			if r, ok := ra.(*unix.SockaddrInet6); ok && r.Addr == s.Addr && r.Port == s.Port && r.ZoneId == s.ZoneId {
+				setLinger(fd, 0)
+				unix.Close(fd)
+				return nil, ErrDialSelf
+			}
+		}
+
+		//  by default golang/net sets TCP no delay to true.
+		if err = setNoDelay(fd, true); err != nil {
+			unix.Close(fd)
+			return nil, err
+		}
+	}
+
+	// NOTE:XXX: never call unix.Close on fd after os.NewFile
+	file = os.NewFile(uintptr(fd), filePrefix+strconv.Itoa(os.Getpid()))
+	fd = -1 // so we don't touch it, we handled the control to Golang with NewFile
+	if c, err = net.FileConn(file); err != nil {
+		_ = file.Close() // shouldn't error either way
+		return nil, err
+	}
+
+	if err = file.Close(); err != nil {
+		c.Close()
+		return nil, err
+	}
+
+	// c = wrapConnWithRemoteAddr(c, netAddr)
+	return c, err
+}
+
+func listen(netw, addr string) (fd int, err error) {
+	var (
+		family   int
+		socktype int
+		protocol int
+		sockaddr unix.Sockaddr
+	)
+
+	netAddr, err := ResolveAddr(netw, addr)
+	if err != nil {
+		return -1, err
+	}
+
+	switch netAddr.(type) {
+	case *net.TCPAddr, *net.UDPAddr:
+	default:
+		return -1, ErrUnsupportedProtocol
+	}
+
+	family = sockaddrnet.NetAddrAF(netAddr)
+	protocol = sockaddrnet.NetAddrIPPROTO(netAddr)
+	sockaddr = sockaddrnet.NetAddrToSockaddr(netAddr)
+	socktype = sockaddrnet.NetAddrSOCK(netAddr)
+
+	if fd, err = socket(family, socktype, protocol); err != nil {
+		return -1, err
+	}
+
+	if err = unix.Bind(fd, sockaddr); err != nil {
+		unix.Close(fd)
+		return -1, err
+	}
+
+	if protocol == unix.IPPROTO_TCP {
+		//  by default golang/net sets TCP no delay to true.
+		if err = setNoDelay(fd, true); err != nil {
+			unix.Close(fd)
+			return -1, err
+		}
+	}
+
+	if err = unix.SetNonblock(fd, true); err != nil {
+		unix.Close(fd)
+		return -1, err
+	}
+
+	return fd, nil
+}
+
+func listenStream(netw, addr string) (l net.Listener, err error) {
+	var (
+		file *os.File
+	)
+
+	fd, err := listen(netw, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set backlog size to the maximum
+	if err = unix.Listen(fd, unix.SOMAXCONN); err != nil {
+		unix.Close(fd)
+		return nil, err
+	}
+
+	file = os.NewFile(uintptr(fd), filePrefix+strconv.Itoa(os.Getpid()))
+	if l, err = net.FileListener(file); err != nil {
+		unix.Close(fd)
+		return nil, err
+	}
+
+	if err = file.Close(); err != nil {
+		unix.Close(fd)
+		l.Close()
+		return nil, err
+	}
+
+	return l, err
+}
+
+func listenPacket(netw, addr string) (p net.PacketConn, err error) {
+	var (
+		file *os.File
+	)
+
+	fd, err := listen(netw, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	file = os.NewFile(uintptr(fd), filePrefix+strconv.Itoa(os.Getpid()))
+	if p, err = net.FilePacketConn(file); err != nil {
+		unix.Close(fd)
+		return nil, err
+	}
+
+	if err = file.Close(); err != nil {
+		unix.Close(fd)
+		p.Close()
+		return nil, err
+	}
+
+	return p, err
+}
+
+func listenUDP(netw, addr string) (c net.Conn, err error) {
+	var (
+		file *os.File
+	)
+
+	fd, err := listen(netw, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	file = os.NewFile(uintptr(fd), filePrefix+strconv.Itoa(os.Getpid()))
+	if c, err = net.FileConn(file); err != nil {
+		unix.Close(fd)
+		return nil, err
+	}
+
+	if err = file.Close(); err != nil {
+		unix.Close(fd)
+		return nil, err
+	}
+
+	return c, err
+}
+
+// this is close to the connect() function inside stdlib/net
+func connect(ctx context.Context, fd int, ra unix.Sockaddr, deadline time.Time) error {
+	if !deadline.IsZero() {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithDeadline(ctx, deadline)
+		defer cancel()
+	}
+
+	switch err := unix.Connect(fd, ra); err {
+	case unix.EINPROGRESS, unix.EALREADY, unix.EINTR:
+	case nil, unix.EISCONN:
+		if !deadline.IsZero() && deadline.Before(time.Now()) {
+			return errTimeout
+		}
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		return nil
+	default:
+		return err
+	}
+
+	for {
+		if err := singlepoll.PollPark(ctx, fd, "w"); err != nil {
+			return err
+		}
+
+		// if err := fd.pd.WaitWrite(); err != nil {
+		// 	return err
+		// }
+		// i'd use the above fd.pd.WaitWrite to poll io correctly, just like net sockets...
+		// but of course, it uses the damn runtime_* functions that _cannot_ be used by
+		// non-go-stdlib source... seriously guys, this is not nice.
+		// we're relegated to using unix.Select (what nightmare that is) or using
+		// a simple but totally bogus time-based wait. such garbage.
+		nerr, err := unix.GetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_ERROR)
+		if err != nil {
+			return err
+		}
+		switch err = syscall.Errno(nerr); err {
+		case unix.EINPROGRESS, unix.EALREADY, unix.EINTR:
+			continue
+		case syscall.Errno(0), unix.EISCONN:
+			if !deadline.IsZero() && deadline.Before(time.Now()) {
+				return errTimeout
+			}
+			return nil
+		default:
+			return err
+		}
+	}
+}
+
+var errTimeout = &timeoutError{}
+
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
diff --git a/vendor/github.com/libp2p/go-reuseport/impl_windows.go b/vendor/github.com/libp2p/go-reuseport/impl_windows.go
new file mode 100644
index 000000000..cd6fde3a2
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/impl_windows.go
@@ -0,0 +1,31 @@
+package reuseport
+
+import (
+	"context"
+	"net"
+)
+
+// TODO. for now, just pass it over to net.Listen/net.Dial
+
+func listen(network, address string) (net.Listener, error) {
+	return net.Listen(network, address)
+}
+
+func listenPacket(netw, laddr string) (net.PacketConn, error) {
+	return net.ListenPacket(netw, laddr)
+}
+
+func listenStream(netw, addr string) (net.Listener, error) {
+	return listen(netw, addr)
+}
+
+func dial(ctx context.Context, dialer net.Dialer, network, address string) (net.Conn, error) {
+	return dialer.DialContext(ctx, network, address)
+}
+
+// on windows, we just use the regular functions. sources
+// vary on this-- some claim port reuse behavior is on by default
+// on some windows systems. So we try. may the force be with you.
+func available() bool {
+	return true
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/interface.go b/vendor/github.com/libp2p/go-reuseport/interface.go
new file mode 100644
index 000000000..9980d6635
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/interface.go
@@ -0,0 +1,118 @@
+// Package reuseport provides Listen and Dial functions that set socket options
+// in order to be able to reuse ports. You should only use this package if you
+// know what SO_REUSEADDR and SO_REUSEPORT are.
+//
+// For example:
+//
+//  // listen on the same port. oh yeah.
+//  l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//  l2, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//
+//  // dial from the same port. oh yeah.
+//  l1, _ := reuse.Listen("tcp", "127.0.0.1:1234")
+//  l2, _ := reuse.Listen("tcp", "127.0.0.1:1235")
+//  c, _ := reuse.Dial("tcp", "127.0.0.1:1234", "127.0.0.1:1235")
+//
+// Note: cant dial self because tcp/ip stacks use 4-tuples to identify connections,
+// and doing so would clash.
+package reuseport
+
+import (
+	"context"
+	"errors"
+	"net"
+	"syscall"
+	"time"
+)
+
+// Available returns whether or not SO_REUSEPORT is available in the OS.
+// It does so by attepting to open a tcp listener, setting the option, and
+// checking ENOPROTOOPT on error. After checking, the decision is cached
+// for the rest of the process run.
+func Available() bool {
+	return available()
+}
+
+// ErrUnsuportedProtocol signals that the protocol is not currently
+// supported by this package. This package currently only supports TCP.
+var ErrUnsupportedProtocol = errors.New("protocol not yet supported")
+
+// ErrReuseFailed is returned if a reuse attempt was unsuccessful.
+var ErrReuseFailed = errors.New("reuse failed")
+
+// ErrDialSelf is returned if we connect to our own source address.
+var ErrDialSelf = errors.New("dialed our own socket")
+
+// Listen listens at the given network and address. see net.Listen
+// Returns a net.Listener created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func Listen(network, address string) (net.Listener, error) {
+	if !available() {
+		return nil, syscall.ENOPROTOOPT
+	}
+
+	return listenStream(network, address)
+}
+
+// ListenPacket listens at the given network and address. see net.ListenPacket
+// Returns a net.Listener created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func ListenPacket(network, address string) (net.PacketConn, error) {
+	if !available() {
+		return nil, syscall.ENOPROTOOPT
+	}
+
+	return listenPacket(network, address)
+}
+
+// Dial dials the given network and address. see net.Dialer.Dial
+// Returns a net.Conn created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func Dial(network, laddr, raddr string) (net.Conn, error) {
+	if !available() {
+		return nil, syscall.ENOPROTOOPT
+	}
+
+	var d Dialer
+	if laddr != "" {
+		netladdr, err := ResolveAddr(network, laddr)
+		if err != nil {
+			return nil, err
+		}
+		d.D.LocalAddr = netladdr
+	}
+
+	return d.Dial(network, raddr)
+}
+
+// Dialer is used to specify the Dial options, much like net.Dialer.
+// We simply wrap a net.Dialer.
+type Dialer struct {
+	D net.Dialer
+}
+
+// Dial dials the given network and address. see net.Dialer.Dial
+// Returns a net.Conn created from a file discriptor for a socket
+// with SO_REUSEPORT and SO_REUSEADDR option set.
+func (d *Dialer) Dial(network, address string) (net.Conn, error) {
+	return d.DialContext(context.Background(), network, address)
+}
+
+func (d *Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	if !available() {
+		return nil, syscall.ENOPROTOOPT
+	}
+
+	return dial(ctx, d.D, network, address)
+}
+
+func (d *Dialer) deadline(def time.Duration) time.Time {
+	switch {
+	case !d.D.Deadline.IsZero():
+		return d.D.Deadline
+	case d.D.Timeout != 0:
+		return time.Now().Add(d.D.Timeout)
+	default:
+		return time.Now().Add(def)
+	}
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/opts_posix.go b/vendor/github.com/libp2p/go-reuseport/opts_posix.go
new file mode 100644
index 000000000..19bc51115
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/opts_posix.go
@@ -0,0 +1,35 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
+
+package reuseport
+
+import (
+	"golang.org/x/sys/unix"
+	"os"
+)
+
+func boolint(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+func setNoDelay(fd int, noDelay bool) error {
+	return os.NewSyscallError("setsockopt", unix.SetsockoptInt(fd, unix.IPPROTO_TCP, unix.TCP_NODELAY, boolint(noDelay)))
+}
+
+func setLinger(fd int, sec int) error {
+	var l unix.Linger
+	if sec >= 0 {
+		l.Onoff = 1
+		l.Linger = int32(sec)
+	} else {
+		l.Onoff = 0
+		l.Linger = 0
+	}
+	return os.NewSyscallError("setsockopt", unix.SetsockoptLinger(fd, unix.SOL_SOCKET, unix.SO_LINGER, &l))
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/error.go b/vendor/github.com/libp2p/go-reuseport/poll/error.go
new file mode 100644
index 000000000..c13fb8132
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/error.go
@@ -0,0 +1,9 @@
+package poll
+
+var errTimeout = &timeoutError{}
+
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/platform_uint32.go b/vendor/github.com/libp2p/go-reuseport/poll/platform_uint32.go
new file mode 100644
index 000000000..cc8021201
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/platform_uint32.go
@@ -0,0 +1,5 @@
+// +build amd64p32 386 arm
+
+package poll
+
+type uintp = uint32
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/platform_uint64.go b/vendor/github.com/libp2p/go-reuseport/poll/platform_uint64.go
new file mode 100644
index 000000000..a444d85c6
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/platform_uint64.go
@@ -0,0 +1,5 @@
+// +build amd64 arm64 ppc64 ppc64le
+
+package poll
+
+type uintp = uint64
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/poll_bsd.go b/vendor/github.com/libp2p/go-reuseport/poll/poll_bsd.go
new file mode 100644
index 000000000..d1793f875
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/poll_bsd.go
@@ -0,0 +1,58 @@
+// +build darwin freebsd dragonfly netbsd openbsd
+
+package poll
+
+import (
+	"context"
+	"golang.org/x/sys/unix"
+	"time"
+)
+
+type Poller struct {
+	kqfd  int
+	event unix.Kevent_t
+}
+
+func New(fd int) (p *Poller, err error) {
+	p = &Poller{}
+
+	p.kqfd, err = unix.Kqueue()
+	if p.kqfd == -1 || err != nil {
+		return nil, err
+	}
+
+	p.event = unix.Kevent_t{
+		Ident:  uintp(fd),
+		Filter: unix.EVFILT_WRITE,
+		Flags:  unix.EV_ADD | unix.EV_ENABLE | unix.EV_ONESHOT,
+	}
+	return p, nil
+}
+
+func (p *Poller) Close() error {
+	return unix.Close(p.kqfd)
+}
+
+func (p *Poller) WaitWriteCtx(ctx context.Context) error {
+	deadline, _ := ctx.Deadline()
+
+	// setup timeout
+	var timeout *unix.Timespec
+	if !deadline.IsZero() {
+		d := deadline.Sub(time.Now())
+		t := unix.NsecToTimespec(d.Nanoseconds())
+		timeout = &t
+	}
+
+	// wait on kevent
+	events := make([]unix.Kevent_t, 1)
+	n, err := unix.Kevent(p.kqfd, []unix.Kevent_t{p.event}, events, timeout)
+	if err != nil {
+		return err
+	}
+
+	if n < 1 {
+		return errTimeout
+	}
+	return nil
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/poll_linux.go b/vendor/github.com/libp2p/go-reuseport/poll/poll_linux.go
new file mode 100644
index 000000000..72347fd74
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/poll_linux.go
@@ -0,0 +1,131 @@
+// +build linux
+
+package poll
+
+import (
+	"context"
+	"golang.org/x/sys/unix"
+	"sync"
+
+	"github.com/gxed/eventfd"
+)
+
+type Poller struct {
+	epfd int
+
+	eventMain unix.EpollEvent
+	eventWait unix.EpollEvent
+	events    []unix.EpollEvent
+
+	wake      *eventfd.EventFD // Use eventfd to wakeup epoll
+	wakeMutex sync.Mutex
+}
+
+func New(fd int) (p *Poller, err error) {
+	p = &Poller{
+		events: make([]unix.EpollEvent, 32),
+	}
+	if p.epfd, err = unix.EpollCreate1(0); err != nil {
+		return nil, err
+	}
+	wake, err := eventfd.New()
+	if err != nil {
+		unix.Close(p.epfd)
+		return nil, err
+	}
+	p.wake = wake
+
+	p.eventMain.Events = unix.EPOLLOUT
+	p.eventMain.Fd = int32(fd)
+	if err = unix.EpollCtl(p.epfd, unix.EPOLL_CTL_ADD, fd, &p.eventMain); err != nil {
+		p.Close()
+		return nil, err
+	}
+
+	// poll that eventfd can be read
+	p.eventWait.Events = unix.EPOLLIN
+	p.eventWait.Fd = int32(wake.Fd())
+	if err = unix.EpollCtl(p.epfd, unix.EPOLL_CTL_ADD, wake.Fd(), &p.eventWait); err != nil {
+		p.wake.Close()
+		p.Close()
+		return nil, err
+	}
+
+	return p, nil
+}
+
+func (p *Poller) Close() error {
+	p.wakeMutex.Lock()
+	err1 := p.wake.Close()
+	// set wake to nil to be sure that we won't call write on closed wake
+	// it should never happen but if someone changes something this might show a bug
+	p.wake = nil
+	p.wakeMutex.Unlock()
+
+	err2 := unix.Close(p.epfd)
+	if err1 != nil {
+		return err1
+	} else {
+		return err2
+	}
+}
+
+func (p *Poller) WaitWriteCtx(ctx context.Context) error {
+	doneChan := make(chan struct{})
+	defer close(doneChan)
+
+	go func() {
+		select {
+		case <-doneChan:
+			return
+		case <-ctx.Done():
+			select {
+			case <-doneChan:
+				// if we re done with this function do not write to p.wake
+				// it might be already closed and the fd could be reopened for
+				// different purpose
+				return
+			default:
+			}
+			p.wakeMutex.Lock()
+			if p.wake != nil {
+				p.wake.WriteEvents(1) // send event to wake up epoll
+			}
+			// if it is nil then we already closed
+			p.wakeMutex.Unlock()
+			return
+		}
+
+	}()
+
+	n, err := unix.EpollWait(p.epfd, p.events, -1)
+	if err != nil {
+		return err
+	}
+	good := false
+	for i := 0; i < n; i++ {
+		ev := p.events[i]
+		switch ev.Fd {
+		case p.eventMain.Fd:
+			good = true
+		case p.eventWait.Fd:
+			p.wakeMutex.Lock()
+			p.wake.ReadEvents() // clear eventfd
+			p.wakeMutex.Unlock()
+		default:
+			// shouldn't happen as epoll should onlt return events we registered
+		}
+	}
+	if good {
+		// in case both eventMain and eventWait are lit, we got with eventMain
+		// as it is the success condition here and if both of them are returned
+		// at the same time it means that socket connected right as context timed out
+		return nil
+	}
+	if ctx.Err() == nil {
+		// notification is sent by other goroutine when context deadline was reached
+		// if we are here it means that we got notification buy the deadline wasn't reached
+		panic("notification but no deadline, this should be impossible")
+	}
+	return ctx.Err()
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/poll/poll_unsupported.go b/vendor/github.com/libp2p/go-reuseport/poll/poll_unsupported.go
new file mode 100644
index 000000000..bc0e5ed83
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/poll/poll_unsupported.go
@@ -0,0 +1,11 @@
+// +build windows plan9
+
+package poll
+
+import (
+	"errors"
+)
+
+func WaitWrite(fd int) error {
+	return errors.New("platform not supported")
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/singlepoll/ctx.go b/vendor/github.com/libp2p/go-reuseport/singlepoll/ctx.go
new file mode 100644
index 000000000..58e854526
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/singlepoll/ctx.go
@@ -0,0 +1,9 @@
+package singlepoll
+
+import "context"
+
+var backgroundctx, backgroundcancel = context.WithCancel(context.Background())
+
+func CloseBackgroundProcesses() {
+	backgroundcancel()
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/singlepoll/default.go b/vendor/github.com/libp2p/go-reuseport/singlepoll/default.go
new file mode 100644
index 000000000..9963d7a8a
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/singlepoll/default.go
@@ -0,0 +1,28 @@
+// +build !linux
+
+package singlepoll
+
+import (
+	"context"
+	"errors"
+
+	"github.com/libp2p/go-reuseport/poll"
+)
+
+var (
+	ErrUnsupportedMode error = errors.New("only 'w' mode is supported on this arch")
+)
+
+func PollPark(ctx context.Context, fd int, mode string) error {
+	if mode != "w" {
+		return ErrUnsupportedMode
+	}
+
+	p, err := poll.New(fd)
+	if err != nil {
+		return err
+	}
+	defer p.Close()
+
+	return p.WaitWriteCtx(ctx)
+}
diff --git a/vendor/github.com/libp2p/go-reuseport/singlepoll/linux.go b/vendor/github.com/libp2p/go-reuseport/singlepoll/linux.go
new file mode 100644
index 000000000..f4833ee79
--- /dev/null
+++ b/vendor/github.com/libp2p/go-reuseport/singlepoll/linux.go
@@ -0,0 +1,202 @@
+// +build linux
+
+package singlepoll
+
+import (
+	"context"
+	"errors"
+	"golang.org/x/sys/unix"
+	"sync"
+
+	"github.com/gxed/eventfd"
+	logging "github.com/ipfs/go-log"
+)
+
+var (
+	ErrUnsupportedMode error = errors.New("only 'w' and 'r' modes are supported on this arch")
+)
+
+var (
+	initOnce sync.Once
+	workChan chan interface{}
+	log      logging.EventLogger = logging.Logger("reuseport-poll")
+)
+
+type addPoll struct {
+	fd     int
+	events uint32
+	ctx    context.Context
+	wakeUp chan<- error
+}
+
+type ctxDone struct {
+	fd int
+}
+
+func PollPark(reqctx context.Context, fd int, mode string) error {
+	initOnce.Do(func() {
+		workChan = make(chan interface{}, 128)
+		go worker()
+	})
+
+	events := uint32(0)
+	for _, c := range mode {
+		switch c {
+		case 'w':
+			events |= unix.EPOLLOUT
+		case 'r':
+			events |= unix.EPOLLIN
+		default:
+			return ErrUnsupportedMode
+		}
+	}
+
+	wakeUp := make(chan error)
+	workChan <- addPoll{
+		fd:     fd,
+		events: events,
+		ctx:    reqctx,
+		wakeUp: wakeUp,
+	}
+
+	return <-wakeUp
+}
+
+func criticalError(msg string, err error) {
+	log.Errorf("%s: %s.", msg, err.Error())
+	log.Errorf("This is critical error, please report it at https://github.com/libp2p/go-reuseport/issues/new")
+	log.Errorf("Bailing out. You are on your own. Good luck.")
+
+	for {
+		select {
+		case <-backgroundctx.Done():
+			return
+		case unit := <-workChan:
+			switch u := unit.(type) {
+			case addPoll:
+				u.wakeUp <- err
+			default:
+			}
+		}
+	}
+}
+
+func worker() {
+	epfd, err := unix.EpollCreate1(0)
+	if err != nil {
+		criticalError("EpollCreate1(0) failed", err)
+	}
+	evfd, err := eventfd.New()
+	if err != nil {
+		criticalError("eventfd.New() failed", err)
+	}
+
+	pool := make(map[int]addPoll)
+
+	{
+		event := unix.EpollEvent{
+			Events: unix.EPOLLIN,
+			Fd:     int32(evfd.Fd()),
+		}
+		unix.EpollCtl(epfd, unix.EPOLL_CTL_ADD, evfd.Fd(), &event)
+	}
+	go poller(epfd, evfd)
+
+	remove := func(fd int) *addPoll {
+		unit, ok := pool[fd]
+		if ok {
+			unix.EpollCtl(epfd, unix.EPOLL_CTL_DEL, unit.fd, nil)
+			delete(pool, fd)
+			close(unit.wakeUp)
+		}
+		return &unit
+	}
+	for {
+		select {
+		case <-backgroundctx.Done():
+			evfd.WriteEvents(1)
+			return
+		case unit := <-workChan:
+			switch u := unit.(type) {
+			case addPoll:
+				event := unix.EpollEvent{
+					Events: u.events | unix.EPOLLONESHOT,
+					Fd:     int32(u.fd),
+				}
+
+				// Make copies for *I* before we add it to Epoll group
+				wrapWakeUp := make(chan error)
+				wakeUp := u.wakeUp
+				u.wakeUp = wrapWakeUp
+
+				if _, ok := pool[u.fd]; ok {
+					panic("duplicate fd") // safe guard against bad close calls
+				}
+				pool[u.fd] = u
+
+				err := unix.EpollCtl(epfd, unix.EPOLL_CTL_ADD, u.fd, &event)
+				if err != nil {
+					delete(pool, u.fd)
+					u.wakeUp <- err
+				}
+
+				// *I*
+				reqCtx := u.ctx
+				fd := u.fd
+
+				go func() {
+					select {
+					case err := <-wrapWakeUp:
+						wakeUp <- err
+					case <-reqCtx.Done():
+						workChan <- ctxDone{
+							fd: fd,
+						}
+						<-wrapWakeUp
+						wakeUp <- reqCtx.Err()
+					}
+				}()
+
+			case []unix.EpollEvent:
+				for _, event := range u {
+					remove(int(event.Fd))
+				}
+			case ctxDone:
+				remove(u.fd)
+			}
+		}
+	}
+
+}
+
+func poller(epfd int, evfd *eventfd.EventFD) {
+	for {
+		// do not reuse the array as we will be passing it over channel
+		// 128 is quite arbitrary
+		// to small and number of EpollWait calls would increase
+		// to big and GC overhead increases
+		events := make([]unix.EpollEvent, 128)
+		n, err := unix.EpollWait(epfd, events, -1)
+
+		switch err {
+		case nil:
+			// everything is great
+		case unix.EINTR:
+			// ignore
+			continue
+		default:
+			// log
+			log.Errorf("EpollWait returned error: %s. Continuing.", err.Error())
+			continue
+		}
+
+		for i := 0; i < n; i++ {
+			if int(events[i].Fd) == evfd.Fd() {
+				unix.Close(epfd)
+				evfd.Close()
+				return
+			}
+		}
+		workChan <- events[:n]
+	}
+}
diff --git a/vendor/github.com/libp2p/go-sockaddr/LICENSE b/vendor/github.com/libp2p/go-sockaddr/LICENSE
new file mode 100644
index 000000000..744875676
--- /dev/null
+++ b/vendor/github.com/libp2p/go-sockaddr/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/libp2p/go-sockaddr/net/net.go b/vendor/github.com/libp2p/go-sockaddr/net/net.go
new file mode 100644
index 000000000..8e2c3c03d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-sockaddr/net/net.go
@@ -0,0 +1,350 @@
+// package sockaddrnet provides conversions between net.Addr and Sockaddr
+package sockaddrnet
+
+import (
+	"net"
+)
+
+// NetAddrAF returns the unix AF_* type for a given net.Addr
+// returns AF_UNSPEC if unknown
+func NetAddrAF(addr net.Addr) int {
+	switch addr := addr.(type) {
+	case *net.IPAddr:
+		return IPAF(addr.IP)
+
+	case *net.TCPAddr:
+		return IPAF(addr.IP)
+
+	case *net.UDPAddr:
+		return IPAF(addr.IP)
+
+	case *net.UnixAddr:
+		return AF_UNIX
+
+	default:
+		return AF_UNSPEC
+	}
+}
+
+// IPAF returns the unix AF_* type for a given IP address
+// returns AF_UNSPEC if unknown
+func IPAF(ip net.IP) int {
+	switch {
+	case ip.To4() != nil:
+		return AF_INET
+
+	case ip.To16() != nil:
+		return AF_INET6
+
+	default:
+		return AF_UNSPEC
+	}
+}
+
+// NetAddrIPPROTO returns the unix IPPROTO_* type for a given net.Addr
+// returns -1 if protocol unknown
+func NetAddrIPPROTO(addr net.Addr) int {
+	switch addr := addr.(type) {
+	case *net.IPAddr:
+		switch {
+		default:
+			return IPPROTO_IP
+
+		case addr.IP.To4() != nil:
+			return IPPROTO_IPV4
+
+		case addr.IP.To16() != nil:
+			return IPPROTO_IPV6
+		}
+
+	case *net.TCPAddr:
+		return IPPROTO_TCP
+
+	case *net.UDPAddr:
+		return IPPROTO_UDP
+
+	default:
+		return -1
+	}
+}
+
+// NetAddrSOCK returns the unix SOCK_* type for a given net.Addr
+// returns 0 if type unknown
+func NetAddrSOCK(addr net.Addr) int {
+	switch addr := addr.(type) {
+	case *net.IPAddr:
+		return SOCK_DGRAM
+	case *net.TCPAddr:
+		return SOCK_STREAM
+	case *net.UDPAddr:
+		return SOCK_DGRAM
+	case *net.UnixAddr:
+		switch addr.Net {
+		default:
+			return 0
+		case "unix":
+			return SOCK_STREAM
+		case "unixgram":
+			return SOCK_DGRAM
+		case "unixpacket":
+			return SOCK_SEQPACKET
+		}
+	default:
+		return 0
+	}
+}
+
+// NetAddrToSockaddr converts a net.Addr to a Sockaddr.
+// Returns nil if the input is invalid or conversion is not possible.
+func NetAddrToSockaddr(addr net.Addr) Sockaddr {
+	switch addr := addr.(type) {
+	case *net.IPAddr:
+		return IPAddrToSockaddr(addr)
+	case *net.TCPAddr:
+		return TCPAddrToSockaddr(addr)
+	case *net.UDPAddr:
+		return UDPAddrToSockaddr(addr)
+	case *net.UnixAddr:
+		sa, _ := UnixAddrToSockaddr(addr)
+		return sa
+	default:
+		return nil
+	}
+}
+
+// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a Sockaddr
+// Returns nil if conversion fails.
+func IPAndZoneToSockaddr(ip net.IP, zone string) Sockaddr {
+	// Unspecified?
+	if ip == nil {
+		if zone != "" {
+			return &SockaddrInet6{ZoneId: uint32(IP6ZoneToInt(zone))}
+		}
+		return new(SockaddrInet4)
+	}
+
+	// Valid IPv4?
+	if ip4 := ip.To4(); ip4 != nil && zone == "" {
+		var buf [4]byte
+		copy(buf[:], ip4) // last 4 bytes
+		return &SockaddrInet4{Addr: buf}
+	}
+
+	// Valid IPv6 address?
+	if ip6 := ip.To16(); ip6 != nil {
+		var buf [16]byte
+		copy(buf[:], ip6)
+		return &SockaddrInet6{Addr: buf, ZoneId: uint32(IP6ZoneToInt(zone))}
+	}
+
+	return nil
+}
+
+// IPAddrToSockaddr converts a net.IPAddr to a Sockaddr.
+// Returns nil if conversion fails.
+func IPAddrToSockaddr(addr *net.IPAddr) Sockaddr {
+	return IPAndZoneToSockaddr(addr.IP, addr.Zone)
+}
+
+// TCPAddrToSockaddr converts a net.TCPAddr to a Sockaddr.
+// Returns nil if conversion fails.
+func TCPAddrToSockaddr(addr *net.TCPAddr) Sockaddr {
+	sa := IPAndZoneToSockaddr(addr.IP, addr.Zone)
+	switch sa := sa.(type) {
+	case *SockaddrInet4:
+		sa.Port = addr.Port
+		return sa
+	case *SockaddrInet6:
+		sa.Port = addr.Port
+		return sa
+	default:
+		return nil
+	}
+}
+
+// UDPAddrToSockaddr converts a net.UDPAddr to a Sockaddr.
+// Returns nil if conversion fails.
+func UDPAddrToSockaddr(addr *net.UDPAddr) Sockaddr {
+	sa := IPAndZoneToSockaddr(addr.IP, addr.Zone)
+	switch sa := sa.(type) {
+	case *SockaddrInet4:
+		sa.Port = addr.Port
+		return sa
+	case *SockaddrInet6:
+		sa.Port = addr.Port
+		return sa
+	default:
+		return nil
+	}
+}
+
+// UnixAddrToSockaddr converts a net.UnixAddr to a Sockaddr, and returns
+// the type (unix.SOCK_STREAM, unix.SOCK_DGRAM, unix.SOCK_SEQPACKET)
+// Returns (nil, 0) if conversion fails.
+func UnixAddrToSockaddr(addr *net.UnixAddr) (Sockaddr, int) {
+	t := 0
+	switch addr.Net {
+	case "unix":
+		t = SOCK_STREAM
+	case "unixgram":
+		t = SOCK_DGRAM
+	case "unixpacket":
+		t = SOCK_SEQPACKET
+	default:
+		return nil, 0
+	}
+	return &SockaddrUnix{Name: addr.Name}, t
+}
+
+// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a Sockaddr
+// Returns nil if conversion fails.
+func SockaddrToIPAndZone(sa Sockaddr) (net.IP, string) {
+	switch sa := sa.(type) {
+	case *SockaddrInet4:
+		ip := make([]byte, 16)
+		// V4InV6Prefix
+		ip[10] = 0xff
+		ip[11] = 0xff
+		copy(ip[12:16], sa.Addr[:])
+		return ip, ""
+
+	case *SockaddrInet6:
+		ip := make([]byte, 16)
+		copy(ip, sa.Addr[:])
+		return ip, IP6ZoneToString(int(sa.ZoneId))
+	}
+	return nil, ""
+}
+
+// SockaddrToIPAddr converts a Sockaddr to a net.IPAddr
+// Returns nil if conversion fails.
+func SockaddrToIPAddr(sa Sockaddr) *net.IPAddr {
+	ip, zone := SockaddrToIPAndZone(sa)
+	switch sa.(type) {
+	case *SockaddrInet4:
+		return &net.IPAddr{IP: ip}
+	case *SockaddrInet6:
+		return &net.IPAddr{IP: ip, Zone: zone}
+	}
+	return nil
+}
+
+// SockaddrToTCPAddr converts a Sockaddr to a net.TCPAddr
+// Returns nil if conversion fails.
+func SockaddrToTCPAddr(sa Sockaddr) *net.TCPAddr {
+	ip, zone := SockaddrToIPAndZone(sa)
+	switch sa := sa.(type) {
+	case *SockaddrInet4:
+		return &net.TCPAddr{IP: ip, Port: sa.Port}
+	case *SockaddrInet6:
+		return &net.TCPAddr{IP: ip, Port: sa.Port, Zone: zone}
+	}
+	return nil
+}
+
+// SockaddrToUDPAddr converts a Sockaddr to a net.UDPAddr
+// Returns nil if conversion fails.
+func SockaddrToUDPAddr(sa Sockaddr) *net.UDPAddr {
+	ip, zone := SockaddrToIPAndZone(sa)
+	switch sa := sa.(type) {
+	case *SockaddrInet4:
+		return &net.UDPAddr{IP: ip, Port: sa.Port}
+	case *SockaddrInet6:
+		return &net.UDPAddr{IP: ip, Port: sa.Port, Zone: zone}
+	}
+	return nil
+}
+
+// from: go/src/pkg/net/unixsock_posix.go
+
+// SockaddrToUnixAddr converts a Sockaddr to a net.UnixAddr
+// Returns nil if conversion fails.
+func SockaddrToUnixAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
+		return &net.UnixAddr{Name: s.Name, Net: "unix"}
+	}
+	return nil
+}
+
+// SockaddrToUnixgramAddr converts a Sockaddr to a net.UnixAddr
+// Returns nil if conversion fails.
+func SockaddrToUnixgramAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
+		return &net.UnixAddr{Name: s.Name, Net: "unixgram"}
+	}
+	return nil
+}
+
+// SockaddrToUnixpacketAddr converts a Sockaddr to a net.UnixAddr
+// Returns nil if conversion fails.
+func SockaddrToUnixpacketAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
+		return &net.UnixAddr{Name: s.Name, Net: "unixpacket"}
+	}
+	return nil
+}
+
+// from: go/src/pkg/net/ipsock.go
+
+// IP6ZoneToString converts an IP6 Zone unix int to a net string
+// returns "" if zone is 0
+func IP6ZoneToString(zone int) string {
+	if zone == 0 {
+		return ""
+	}
+	if ifi, err := net.InterfaceByIndex(zone); err == nil {
+		return ifi.Name
+	}
+	return itod(uint(zone))
+}
+
+// IP6ZoneToInt converts an IP6 Zone net string to a unix int
+// returns 0 if zone is ""
+func IP6ZoneToInt(zone string) int {
+	if zone == "" {
+		return 0
+	}
+	if ifi, err := net.InterfaceByName(zone); err == nil {
+		return ifi.Index
+	}
+	n, _, _ := dtoi(zone, 0)
+	return n
+}
+
+// from: go/src/pkg/net/parse.go
+
+// Convert i to decimal string.
+func itod(i uint) string {
+	if i == 0 {
+		return "0"
+	}
+
+	// Assemble decimal in reverse order.
+	var b [32]byte
+	bp := len(b)
+	for ; i > 0; i /= 10 {
+		bp--
+		b[bp] = byte(i%10) + '0'
+	}
+
+	return string(b[bp:])
+}
+
+// Bigger than we need, not too big to worry about overflow
+const big = 0xFFFFFF
+
+// Decimal to integer starting at &s[i0].
+// Returns number, new offset, success.
+func dtoi(s string, i0 int) (n int, i int, ok bool) {
+	n = 0
+	for i = i0; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
+		n = n*10 + int(s[i]-'0')
+		if n >= big {
+			return 0, i, false
+		}
+	}
+	if i == i0 {
+		return 0, i, false
+	}
+	return n, i, true
+}
diff --git a/vendor/github.com/libp2p/go-sockaddr/net/net_bsd.go b/vendor/github.com/libp2p/go-sockaddr/net/net_bsd.go
new file mode 100644
index 000000000..1b31bf6c9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-sockaddr/net/net_bsd.go
@@ -0,0 +1,30 @@
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package sockaddrnet
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+const (
+	AF_INET   = unix.AF_INET
+	AF_INET6  = unix.AF_INET6
+	AF_UNIX   = unix.AF_UNIX
+	AF_UNSPEC = unix.AF_UNSPEC
+
+	IPPROTO_IP   = unix.IPPROTO_IP
+	IPPROTO_IPV4 = unix.IPPROTO_IPV4
+	IPPROTO_IPV6 = unix.IPPROTO_IPV6
+	IPPROTO_TCP  = unix.IPPROTO_TCP
+	IPPROTO_UDP  = unix.IPPROTO_UDP
+
+	SOCK_DGRAM     = unix.SOCK_DGRAM
+	SOCK_STREAM    = unix.SOCK_STREAM
+	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
+)
+
+type Sockaddr = unix.Sockaddr
+type SockaddrInet4 = unix.SockaddrInet4
+type SockaddrInet6 = unix.SockaddrInet6
+type SockaddrUnix = unix.SockaddrUnix
+type RawSockaddrAny = unix.RawSockaddrAny
diff --git a/vendor/github.com/libp2p/go-sockaddr/net/net_linux.go b/vendor/github.com/libp2p/go-sockaddr/net/net_linux.go
new file mode 100644
index 000000000..f6e552971
--- /dev/null
+++ b/vendor/github.com/libp2p/go-sockaddr/net/net_linux.go
@@ -0,0 +1,28 @@
+package sockaddrnet
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+const (
+	AF_INET   = unix.AF_INET
+	AF_INET6  = unix.AF_INET6
+	AF_UNIX   = unix.AF_UNIX
+	AF_UNSPEC = unix.AF_UNSPEC
+
+	IPPROTO_IP   = unix.IPPROTO_IP
+	IPPROTO_IPV4 = unix.IPPROTO_IPIP
+	IPPROTO_IPV6 = unix.IPPROTO_IPV6
+	IPPROTO_TCP  = unix.IPPROTO_TCP
+	IPPROTO_UDP  = unix.IPPROTO_UDP
+
+	SOCK_DGRAM     = unix.SOCK_DGRAM
+	SOCK_STREAM    = unix.SOCK_STREAM
+	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
+)
+
+type Sockaddr = unix.Sockaddr
+type SockaddrInet4 = unix.SockaddrInet4
+type SockaddrInet6 = unix.SockaddrInet6
+type SockaddrUnix = unix.SockaddrUnix
+type RawSockaddrAny = unix.RawSockaddrAny
diff --git a/vendor/github.com/libp2p/go-sockaddr/net/net_windows.go b/vendor/github.com/libp2p/go-sockaddr/net/net_windows.go
new file mode 100644
index 000000000..9a65cf931
--- /dev/null
+++ b/vendor/github.com/libp2p/go-sockaddr/net/net_windows.go
@@ -0,0 +1,28 @@
+package sockaddrnet
+
+import (
+	"golang.org/x/sys/windows"
+)
+
+const (
+	AF_INET   = windows.AF_INET
+	AF_INET6  = windows.AF_INET6
+	AF_UNIX   = windows.AF_UNIX
+	AF_UNSPEC = windows.AF_UNSPEC
+
+	IPPROTO_IP   = windows.IPPROTO_IP
+	IPPROTO_IPV4 = 0x4 // windows.IPPROTO_IPV4 (missing)
+	IPPROTO_IPV6 = windows.IPPROTO_IPV6
+	IPPROTO_TCP  = windows.IPPROTO_TCP
+	IPPROTO_UDP  = windows.IPPROTO_UDP
+
+	SOCK_DGRAM     = windows.SOCK_DGRAM
+	SOCK_STREAM    = windows.SOCK_STREAM
+	SOCK_SEQPACKET = windows.SOCK_SEQPACKET
+)
+
+type Sockaddr = windows.Sockaddr
+type SockaddrInet4 = windows.SockaddrInet4
+type SockaddrInet6 = windows.SockaddrInet6
+type SockaddrUnix = windows.SockaddrUnix
+type RawSockaddrAny = windows.RawSockaddrAny
diff --git a/vendor/github.com/libp2p/go-stream-muxer/LICENSE b/vendor/github.com/libp2p/go-stream-muxer/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-stream-muxer/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-stream-muxer/muxer.go b/vendor/github.com/libp2p/go-stream-muxer/muxer.go
new file mode 100644
index 000000000..c534af5e1
--- /dev/null
+++ b/vendor/github.com/libp2p/go-stream-muxer/muxer.go
@@ -0,0 +1,55 @@
+package streammux
+
+import (
+	"errors"
+	"io"
+	"net"
+	"time"
+)
+
+// ErrReset is returned when reading or writing on a reset stream.
+var ErrReset = errors.New("stream reset")
+
+// Stream is a bidirectional io pipe within a connection.
+type Stream interface {
+	io.Reader
+	io.Writer
+
+	// Close closes the stream for writing. Reading will still work (that
+	// is, the remote side can still write).
+	io.Closer
+
+	// Reset closes both ends of the stream. Use this to tell the remote
+	// side to hang up and go away.
+	Reset() error
+
+	SetDeadline(time.Time) error
+	SetReadDeadline(time.Time) error
+	SetWriteDeadline(time.Time) error
+}
+
+// NoOpHandler do nothing. Resets streams as soon as they are opened.
+var NoOpHandler = func(s Stream) { s.Reset() }
+
+// Conn is a stream-multiplexing connection to a remote peer.
+type Conn interface {
+	// Close closes the stream muxer and the the underlying net.Conn.
+	io.Closer
+
+	// IsClosed returns whether a connection is fully closed, so it can
+	// be garbage collected.
+	IsClosed() bool
+
+	// OpenStream creates a new stream.
+	OpenStream() (Stream, error)
+
+	// AcceptStream accepts a stream opened by the other side.
+	AcceptStream() (Stream, error)
+}
+
+// Transport constructs go-stream-muxer compatible connections.
+type Transport interface {
+
+	// NewConn constructs a new connection
+	NewConn(c net.Conn, isServer bool) (Conn, error)
+}
diff --git a/vendor/github.com/libp2p/go-tcp-transport/LICENSE b/vendor/github.com/libp2p/go-tcp-transport/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/libp2p/go-tcp-transport/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/libp2p/go-tcp-transport/reuseport.go b/vendor/github.com/libp2p/go-tcp-transport/reuseport.go
new file mode 100644
index 000000000..58105ce53
--- /dev/null
+++ b/vendor/github.com/libp2p/go-tcp-transport/reuseport.go
@@ -0,0 +1,35 @@
+package tcp
+
+import (
+	"os"
+	"strings"
+
+	reuseport "github.com/libp2p/go-reuseport"
+)
+
+// envReuseport is the env variable name used to turn off reuse port.
+// It default to true.
+const envReuseport = "IPFS_REUSEPORT"
+
+// envReuseportVal stores the value of envReuseport. defaults to true.
+var envReuseportVal = true
+
+func init() {
+	v := strings.ToLower(os.Getenv(envReuseport))
+	if v == "false" || v == "f" || v == "0" {
+		envReuseportVal = false
+		log.Infof("REUSEPORT disabled (IPFS_REUSEPORT=%s)", v)
+	}
+}
+
+// reuseportIsAvailable returns whether reuseport is available to be used. This
+// is here because we want to be able to turn reuseport on and off selectively.
+// For now we use an ENV variable, as this handles our pressing need:
+//
+//   IPFS_REUSEPORT=false ipfs daemon
+//
+// If this becomes a sought after feature, we could add this to the config.
+// In the end, reuseport is a stop-gap.
+func ReuseportIsAvailable() bool {
+	return envReuseportVal && reuseport.Available()
+}
diff --git a/vendor/github.com/libp2p/go-tcp-transport/tcp.go b/vendor/github.com/libp2p/go-tcp-transport/tcp.go
new file mode 100644
index 000000000..18e119ec7
--- /dev/null
+++ b/vendor/github.com/libp2p/go-tcp-transport/tcp.go
@@ -0,0 +1,112 @@
+package tcp
+
+import (
+	"context"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	peer "github.com/libp2p/go-libp2p-peer"
+	tpt "github.com/libp2p/go-libp2p-transport"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	rtpt "github.com/libp2p/go-reuseport-transport"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+	mafmt "github.com/whyrusleeping/mafmt"
+)
+
+// DefaultConnectTimeout is the (default) maximum amount of time the TCP
+// transport will spend on the initial TCP connect before giving up.
+var DefaultConnectTimeout = 5 * time.Second
+
+var log = logging.Logger("tcp-tpt")
+
+// TcpTransport is the TCP transport.
+type TcpTransport struct {
+	// Connection upgrader for upgrading insecure stream connections to
+	// secure multiplex connections.
+	Upgrader *tptu.Upgrader
+
+	// Explicitly disable reuseport.
+	DisableReuseport bool
+
+	// TCP connect timeout
+	ConnectTimeout time.Duration
+
+	reuse rtpt.Transport
+}
+
+var _ tpt.Transport = &TcpTransport{}
+
+// NewTCPTransport creates a tcp transport object that tracks dialers and listeners
+// created. It represents an entire tcp stack (though it might not necessarily be)
+func NewTCPTransport(upgrader *tptu.Upgrader) *TcpTransport {
+	return &TcpTransport{Upgrader: upgrader, ConnectTimeout: DefaultConnectTimeout}
+}
+
+// CanDial returns true if this transport believes it can dial the given
+// multiaddr.
+func (t *TcpTransport) CanDial(addr ma.Multiaddr) bool {
+	return mafmt.TCP.Matches(addr)
+}
+
+func (t *TcpTransport) maDial(ctx context.Context, raddr ma.Multiaddr) (manet.Conn, error) {
+	// Apply the deadline iff applicable
+	if t.ConnectTimeout > 0 {
+		deadline := time.Now().Add(t.ConnectTimeout)
+		if d, ok := ctx.Deadline(); !ok || deadline.Before(d) {
+			var cancel func()
+			ctx, cancel = context.WithDeadline(ctx, deadline)
+			defer cancel()
+		}
+	}
+
+	if t.UseReuseport() {
+		return t.reuse.DialContext(ctx, raddr)
+	}
+	var d manet.Dialer
+	return d.DialContext(ctx, raddr)
+}
+
+// Dial dials the peer at the remote address.
+func (t *TcpTransport) Dial(ctx context.Context, raddr ma.Multiaddr, p peer.ID) (tpt.Conn, error) {
+	conn, err := t.maDial(ctx, raddr)
+	if err != nil {
+		return nil, err
+	}
+	return t.Upgrader.UpgradeOutbound(ctx, t, conn, p)
+}
+
+// UseReuseport returns true if reuseport is enabled and available.
+func (t *TcpTransport) UseReuseport() bool {
+	return !t.DisableReuseport && ReuseportIsAvailable()
+}
+
+func (t *TcpTransport) maListen(laddr ma.Multiaddr) (manet.Listener, error) {
+	if t.UseReuseport() {
+		return t.reuse.Listen(laddr)
+	}
+	return manet.Listen(laddr)
+}
+
+// Listen listens on the given multiaddr.
+func (t *TcpTransport) Listen(laddr ma.Multiaddr) (tpt.Listener, error) {
+	list, err := t.maListen(laddr)
+	if err != nil {
+		return nil, err
+	}
+	return t.Upgrader.UpgradeListener(t, list), nil
+}
+
+// Protocols returns the list of terminal protocols this transport can dial.
+func (t *TcpTransport) Protocols() []int {
+	return []int{ma.P_TCP}
+}
+
+// Proxy always returns false for the TCP transport.
+func (t *TcpTransport) Proxy() bool {
+	return false
+}
+
+func (t *TcpTransport) String() string {
+	return "TCP"
+}
diff --git a/vendor/github.com/libp2p/go-ws-transport/addrs.go b/vendor/github.com/libp2p/go-ws-transport/addrs.go
new file mode 100644
index 000000000..e5dbc46e4
--- /dev/null
+++ b/vendor/github.com/libp2p/go-ws-transport/addrs.go
@@ -0,0 +1,73 @@
+package websocket
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+// Addr is an implementation of net.Addr for WebSocket.
+type Addr struct {
+	*url.URL
+}
+
+var _ net.Addr = (*Addr)(nil)
+
+// Network returns the network type for a WebSocket, "websocket".
+func (addr *Addr) Network() string {
+	return "websocket"
+}
+
+// NewAddr creates a new Addr using the given host string
+func NewAddr(host string) *Addr {
+	return &Addr{
+		URL: &url.URL{
+			Host: host,
+		},
+	}
+}
+
+func ConvertWebsocketMultiaddrToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+	_, host, err := manet.DialArgs(maddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewAddr(host), nil
+}
+
+func ParseWebsocketNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	wsa, ok := a.(*Addr)
+	if !ok {
+		return nil, fmt.Errorf("not a websocket address")
+	}
+
+	tcpaddr, err := net.ResolveTCPAddr("tcp", wsa.Host)
+	if err != nil {
+		return nil, err
+	}
+
+	tcpma, err := manet.FromNetAddr(tcpaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	wsma, err := ma.NewMultiaddr("/ws")
+	if err != nil {
+		return nil, err
+	}
+
+	return tcpma.Encapsulate(wsma), nil
+}
+
+func parseMultiaddr(a ma.Multiaddr) (string, error) {
+	_, host, err := manet.DialArgs(a)
+	if err != nil {
+		return "", err
+	}
+
+	return "ws://" + host, nil
+}
diff --git a/vendor/github.com/libp2p/go-ws-transport/conn.go b/vendor/github.com/libp2p/go-ws-transport/conn.go
new file mode 100644
index 000000000..168497bf3
--- /dev/null
+++ b/vendor/github.com/libp2p/go-ws-transport/conn.go
@@ -0,0 +1,131 @@
+package websocket
+
+import (
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	ws "github.com/gorilla/websocket"
+)
+
+// GracefulCloseTimeout is the time to wait trying to gracefully close a
+// connection before simply cutting it.
+var GracefulCloseTimeout = 100 * time.Millisecond
+
+var _ net.Conn = (*Conn)(nil)
+
+// Conn implements net.Conn interface for gorilla/websocket.
+type Conn struct {
+	*ws.Conn
+	DefaultMessageType int
+	done               func()
+	reader             io.Reader
+	closeOnce          sync.Once
+}
+
+func (c *Conn) Read(b []byte) (int, error) {
+	if c.reader == nil {
+		if err := c.prepNextReader(); err != nil {
+			return 0, err
+		}
+	}
+
+	for {
+		n, err := c.reader.Read(b)
+		switch err {
+		case io.EOF:
+			c.reader = nil
+
+			if n > 0 {
+				return n, nil
+			}
+
+			if err := c.prepNextReader(); err != nil {
+				return 0, err
+			}
+
+			// explicitly looping
+		default:
+			return n, err
+		}
+	}
+}
+
+func (c *Conn) prepNextReader() error {
+	t, r, err := c.Conn.NextReader()
+	if err != nil {
+		if wserr, ok := err.(*ws.CloseError); ok {
+			if wserr.Code == 1000 || wserr.Code == 1005 {
+				return io.EOF
+			}
+		}
+		return err
+	}
+
+	if t == ws.CloseMessage {
+		return io.EOF
+	}
+
+	c.reader = r
+	return nil
+}
+
+func (c *Conn) Write(b []byte) (n int, err error) {
+	if err := c.Conn.WriteMessage(c.DefaultMessageType, b); err != nil {
+		return 0, err
+	}
+
+	return len(b), nil
+}
+
+// Close closes the connection. Only the first call to Close will receive the
+// close error, subsequent and concurrent calls will return nil.
+// This method is thread-safe.
+func (c *Conn) Close() error {
+	var err error
+	c.closeOnce.Do(func() {
+		if c.done != nil {
+			c.done()
+			// Be nice to GC
+			c.done = nil
+		}
+
+		c.Conn.WriteControl(ws.CloseMessage, nil, time.Now().Add(GracefulCloseTimeout))
+		err = c.Conn.Close()
+	})
+	return err
+}
+
+func (c *Conn) LocalAddr() net.Addr {
+	return NewAddr(c.Conn.LocalAddr().String())
+}
+
+func (c *Conn) RemoteAddr() net.Addr {
+	return NewAddr(c.Conn.RemoteAddr().String())
+}
+
+func (c *Conn) SetDeadline(t time.Time) error {
+	if err := c.SetReadDeadline(t); err != nil {
+		return err
+	}
+
+	return c.SetWriteDeadline(t)
+}
+
+func (c *Conn) SetReadDeadline(t time.Time) error {
+	return c.Conn.SetReadDeadline(t)
+}
+
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+	return c.Conn.SetWriteDeadline(t)
+}
+
+// NewConn creates a Conn given a regular gorilla/websocket Conn.
+func NewConn(raw *ws.Conn, done func()) *Conn {
+	return &Conn{
+		Conn:               raw,
+		DefaultMessageType: ws.BinaryMessage,
+		done:               done,
+	}
+}
diff --git a/vendor/github.com/libp2p/go-ws-transport/listener.go b/vendor/github.com/libp2p/go-ws-transport/listener.go
new file mode 100644
index 000000000..3d774f09d
--- /dev/null
+++ b/vendor/github.com/libp2p/go-ws-transport/listener.go
@@ -0,0 +1,86 @@
+package websocket
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+type listener struct {
+	net.Listener
+
+	laddr ma.Multiaddr
+
+	closed   chan struct{}
+	incoming chan *Conn
+}
+
+func (l *listener) serve() {
+	defer close(l.closed)
+	http.Serve(l.Listener, l)
+}
+
+func (l *listener) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	c, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		http.Error(w, "Failed to upgrade websocket", 400)
+		return
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	var cnCh <-chan bool
+	if cn, ok := w.(http.CloseNotifier); ok {
+		cnCh = cn.CloseNotify()
+	}
+
+	wscon := NewConn(c, cancel)
+	// Just to make sure.
+	defer wscon.Close()
+
+	select {
+	case l.incoming <- wscon:
+	case <-l.closed:
+		c.Close()
+		return
+	case <-cnCh:
+		return
+	}
+
+	// wait until conn gets closed, otherwise the handler closes it early
+	select {
+	case <-ctx.Done():
+	case <-l.closed:
+		c.Close()
+		return
+	case <-cnCh:
+		return
+	}
+}
+
+func (l *listener) Accept() (manet.Conn, error) {
+	select {
+	case c, ok := <-l.incoming:
+		if !ok {
+			return nil, fmt.Errorf("listener is closed")
+		}
+
+		mnc, err := manet.WrapNetConn(c)
+		if err != nil {
+			c.Close()
+			return nil, err
+		}
+
+		return mnc, nil
+	case <-l.closed:
+		return nil, fmt.Errorf("listener is closed")
+	}
+}
+
+func (l *listener) Multiaddr() ma.Multiaddr {
+	return l.laddr
+}
diff --git a/vendor/github.com/libp2p/go-ws-transport/websocket.go b/vendor/github.com/libp2p/go-ws-transport/websocket.go
new file mode 100644
index 000000000..b9ec1d6a9
--- /dev/null
+++ b/vendor/github.com/libp2p/go-ws-transport/websocket.go
@@ -0,0 +1,158 @@
+// Package websocket implements a websocket based transport for go-libp2p.
+package websocket
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+
+	ws "github.com/gorilla/websocket"
+	peer "github.com/libp2p/go-libp2p-peer"
+	tpt "github.com/libp2p/go-libp2p-transport"
+	tptu "github.com/libp2p/go-libp2p-transport-upgrader"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+	mafmt "github.com/whyrusleeping/mafmt"
+)
+
+// WsProtocol is the multiaddr protocol definition for this transport.
+var WsProtocol = ma.Protocol{
+	Code:  477,
+	Name:  "ws",
+	VCode: ma.CodeToVarint(477),
+}
+
+// WsFmt is multiaddr formatter for WsProtocol
+var WsFmt = mafmt.And(mafmt.TCP, mafmt.Base(WsProtocol.Code))
+
+// WsCodec is the multiaddr-net codec definition for the websocket transport
+var WsCodec = &manet.NetCodec{
+	NetAddrNetworks:  []string{"websocket"},
+	ProtocolName:     "ws",
+	ConvertMultiaddr: ConvertWebsocketMultiaddrToNetAddr,
+	ParseNetAddr:     ParseWebsocketNetAddr,
+}
+
+// Default gorilla upgrader
+var upgrader = ws.Upgrader{
+	// Allow requests from *all* origins.
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+func init() {
+	err := ma.AddProtocol(WsProtocol)
+	if err != nil {
+		panic(fmt.Errorf("error registering websocket protocol: %s", err))
+	}
+
+	manet.RegisterNetCodec(WsCodec)
+}
+
+// WebsocketTransport is the actual go-libp2p transport
+type WebsocketTransport struct {
+	Upgrader *tptu.Upgrader
+}
+
+func New(u *tptu.Upgrader) *WebsocketTransport {
+	return &WebsocketTransport{u}
+}
+
+var _ tpt.Transport = (*WebsocketTransport)(nil)
+
+func (t *WebsocketTransport) CanDial(a ma.Multiaddr) bool {
+	return WsFmt.Matches(a)
+}
+
+func (t *WebsocketTransport) Protocols() []int {
+	return []int{WsProtocol.Code}
+}
+
+func (t *WebsocketTransport) Proxy() bool {
+	return false
+}
+
+func (t *WebsocketTransport) maDial(ctx context.Context, raddr ma.Multiaddr) (manet.Conn, error) {
+	wsurl, err := parseMultiaddr(raddr)
+	if err != nil {
+		return nil, err
+	}
+
+	wscon, _, err := ws.DefaultDialer.Dial(wsurl, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	mnc, err := manet.WrapNetConn(NewConn(wscon, nil))
+	if err != nil {
+		wscon.Close()
+		return nil, err
+	}
+	return mnc, nil
+}
+
+func (t *WebsocketTransport) Dial(ctx context.Context, raddr ma.Multiaddr, p peer.ID) (tpt.Conn, error) {
+	macon, err := t.maDial(ctx, raddr)
+	if err != nil {
+		return nil, err
+	}
+	return t.Upgrader.UpgradeOutbound(ctx, t, macon, p)
+}
+
+func (t *WebsocketTransport) maListen(a ma.Multiaddr) (manet.Listener, error) {
+	lnet, lnaddr, err := manet.DialArgs(a)
+	if err != nil {
+		return nil, err
+	}
+
+	nl, err := net.Listen(lnet, lnaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	u, err := url.Parse("http://" + nl.Addr().String())
+	if err != nil {
+		nl.Close()
+		return nil, err
+	}
+
+	malist, err := t.wrapListener(nl, u)
+	if err != nil {
+		nl.Close()
+		return nil, err
+	}
+
+	go malist.serve()
+
+	return malist, nil
+}
+
+func (t *WebsocketTransport) Listen(a ma.Multiaddr) (tpt.Listener, error) {
+	malist, err := t.maListen(a)
+	if err != nil {
+		return nil, err
+	}
+	return t.Upgrader.UpgradeListener(t, malist), nil
+}
+
+func (t *WebsocketTransport) wrapListener(l net.Listener, origin *url.URL) (*listener, error) {
+	laddr, err := manet.FromNetAddr(l.Addr())
+	if err != nil {
+		return nil, err
+	}
+	wsma, err := ma.NewMultiaddr("/ws")
+	if err != nil {
+		return nil, err
+	}
+	laddr = laddr.Encapsulate(wsma)
+
+	return &listener{
+		laddr:    laddr,
+		Listener: l,
+		incoming: make(chan *Conn),
+		closed:   make(chan struct{}),
+	}, nil
+}
diff --git a/vendor/github.com/minio/blake2b-simd/LICENSE b/vendor/github.com/minio/blake2b-simd/LICENSE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/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/github.com/minio/blake2b-simd/blake2b.go b/vendor/github.com/minio/blake2b-simd/blake2b.go
new file mode 100644
index 000000000..538466a1a
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/blake2b.go
@@ -0,0 +1,301 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// Package blake2b implements BLAKE2b cryptographic hash function.
+package blake2b
+
+import (
+	"encoding/binary"
+	"errors"
+	"hash"
+)
+
+const (
+	BlockSize  = 128 // block size of algorithm
+	Size       = 64  // maximum digest size
+	SaltSize   = 16  // maximum salt size
+	PersonSize = 16  // maximum personalization string size
+	KeySize    = 64  // maximum size of key
+)
+
+type digest struct {
+	h  [8]uint64       // current chain value
+	t  [2]uint64       // message bytes counter
+	f  [2]uint64       // finalization flags
+	x  [BlockSize]byte // buffer for data not yet compressed
+	nx int             // number of bytes in buffer
+
+	ih         [8]uint64       // initial chain value (after config)
+	paddedKey  [BlockSize]byte // copy of key, padded with zeros
+	isKeyed    bool            // indicates whether hash was keyed
+	size       uint8           // digest size in bytes
+	isLastNode bool            // indicates processing of the last node in tree hashing
+}
+
+// Initialization values.
+var iv = [8]uint64{
+	0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
+	0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
+	0x510e527fade682d1, 0x9b05688c2b3e6c1f,
+	0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
+}
+
+// Config is used to configure hash function parameters and keying.
+// All parameters are optional.
+type Config struct {
+	Size   uint8  // digest size (if zero, default size of 64 bytes is used)
+	Key    []byte // key for prefix-MAC
+	Salt   []byte // salt (if < 16 bytes, padded with zeros)
+	Person []byte // personalization (if < 16 bytes, padded with zeros)
+	Tree   *Tree  // parameters for tree hashing
+}
+
+// Tree represents parameters for tree hashing.
+type Tree struct {
+	Fanout        uint8  // fanout
+	MaxDepth      uint8  // maximal depth
+	LeafSize      uint32 // leaf maximal byte length (0 for unlimited)
+	NodeOffset    uint64 // node offset (0 for first, leftmost or leaf)
+	NodeDepth     uint8  // node depth (0 for leaves)
+	InnerHashSize uint8  // inner hash byte length
+	IsLastNode    bool   // indicates processing of the last node of layer
+}
+
+var (
+	defaultConfig = &Config{Size: Size}
+	config256     = &Config{Size: 32}
+)
+
+func verifyConfig(c *Config) error {
+	if c.Size > Size {
+		return errors.New("digest size is too large")
+	}
+	if len(c.Key) > KeySize {
+		return errors.New("key is too large")
+	}
+	if len(c.Salt) > SaltSize {
+		// Smaller salt is okay: it will be padded with zeros.
+		return errors.New("salt is too large")
+	}
+	if len(c.Person) > PersonSize {
+		// Smaller personalization is okay: it will be padded with zeros.
+		return errors.New("personalization is too large")
+	}
+	if c.Tree != nil {
+		if c.Tree.Fanout == 1 {
+			return errors.New("fanout of 1 is not allowed in tree mode")
+		}
+		if c.Tree.MaxDepth < 2 {
+			return errors.New("incorrect tree depth")
+		}
+		if c.Tree.InnerHashSize < 1 || c.Tree.InnerHashSize > Size {
+			return errors.New("incorrect tree inner hash size")
+		}
+	}
+	return nil
+}
+
+// New returns a new hash.Hash configured with the given Config.
+// Config can be nil, in which case the default one is used, calculating 64-byte digest.
+// Returns non-nil error if Config contains invalid parameters.
+func New(c *Config) (hash.Hash, error) {
+	if c == nil {
+		c = defaultConfig
+	} else {
+		if c.Size == 0 {
+			// Set default size if it's zero.
+			c.Size = Size
+		}
+		if err := verifyConfig(c); err != nil {
+			return nil, err
+		}
+	}
+	d := new(digest)
+	d.initialize(c)
+	return d, nil
+}
+
+// initialize initializes digest with the given
+// config, which must be non-nil and verified.
+func (d *digest) initialize(c *Config) {
+	// Create parameter block.
+	var p [BlockSize]byte
+	p[0] = c.Size
+	p[1] = uint8(len(c.Key))
+	if c.Salt != nil {
+		copy(p[32:], c.Salt)
+	}
+	if c.Person != nil {
+		copy(p[48:], c.Person)
+	}
+	if c.Tree != nil {
+		p[2] = c.Tree.Fanout
+		p[3] = c.Tree.MaxDepth
+		binary.LittleEndian.PutUint32(p[4:], c.Tree.LeafSize)
+		binary.LittleEndian.PutUint64(p[8:], c.Tree.NodeOffset)
+		p[16] = c.Tree.NodeDepth
+		p[17] = c.Tree.InnerHashSize
+	} else {
+		p[2] = 1
+		p[3] = 1
+	}
+
+	// Initialize.
+	d.size = c.Size
+	for i := 0; i < 8; i++ {
+		d.h[i] = iv[i] ^ binary.LittleEndian.Uint64(p[i*8:])
+	}
+	if c.Tree != nil && c.Tree.IsLastNode {
+		d.isLastNode = true
+	}
+
+	// Process key.
+	if c.Key != nil {
+		copy(d.paddedKey[:], c.Key)
+		d.Write(d.paddedKey[:])
+		d.isKeyed = true
+	}
+	// Save a copy of initialized state.
+	copy(d.ih[:], d.h[:])
+}
+
+// New512 returns a new hash.Hash computing the BLAKE2b 64-byte checksum.
+func New512() hash.Hash {
+	d := new(digest)
+	d.initialize(defaultConfig)
+	return d
+}
+
+// New256 returns a new hash.Hash computing the BLAKE2b 32-byte checksum.
+func New256() hash.Hash {
+	d := new(digest)
+	d.initialize(config256)
+	return d
+}
+
+// NewMAC returns a new hash.Hash computing BLAKE2b prefix-
+// Message Authentication Code of the given size in bytes
+// (up to 64) with the given key (up to 64 bytes in length).
+func NewMAC(outBytes uint8, key []byte) hash.Hash {
+	d, err := New(&Config{Size: outBytes, Key: key})
+	if err != nil {
+		panic(err.Error())
+	}
+	return d
+}
+
+// Reset resets the state of digest to the initial state
+// after configuration and keying.
+func (d *digest) Reset() {
+	copy(d.h[:], d.ih[:])
+	d.t[0] = 0
+	d.t[1] = 0
+	d.f[0] = 0
+	d.f[1] = 0
+	d.nx = 0
+	if d.isKeyed {
+		d.Write(d.paddedKey[:])
+	}
+}
+
+// Size returns the digest size in bytes.
+func (d *digest) Size() int { return int(d.size) }
+
+// BlockSize returns the algorithm block size in bytes.
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	left := BlockSize - d.nx
+	if len(p) > left {
+		// Process buffer.
+		copy(d.x[d.nx:], p[:left])
+		p = p[left:]
+		compress(d, d.x[:])
+		d.nx = 0
+	}
+	// Process full blocks except for the last one.
+	if len(p) > BlockSize {
+		n := len(p) &^ (BlockSize - 1)
+		if n == len(p) {
+			n -= BlockSize
+		}
+		compress(d, p[:n])
+		p = p[n:]
+	}
+	// Fill buffer.
+	d.nx += copy(d.x[d.nx:], p)
+	return
+}
+
+// Sum returns the calculated checksum.
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:d0.size]...)
+}
+
+func (d *digest) checkSum() [Size]byte {
+	// Do not create unnecessary copies of the key.
+	if d.isKeyed {
+		for i := 0; i < len(d.paddedKey); i++ {
+			d.paddedKey[i] = 0
+		}
+	}
+
+	dec := BlockSize - uint64(d.nx)
+	if d.t[0] < dec {
+		d.t[1]--
+	}
+	d.t[0] -= dec
+
+	// Pad buffer with zeros.
+	for i := d.nx; i < len(d.x); i++ {
+		d.x[i] = 0
+	}
+	// Set last block flag.
+	d.f[0] = 0xffffffffffffffff
+	if d.isLastNode {
+		d.f[1] = 0xffffffffffffffff
+	}
+	// Compress last block.
+	compress(d, d.x[:])
+
+	var out [Size]byte
+	j := 0
+	for _, s := range d.h[:(d.size-1)/8+1] {
+		out[j+0] = byte(s >> 0)
+		out[j+1] = byte(s >> 8)
+		out[j+2] = byte(s >> 16)
+		out[j+3] = byte(s >> 24)
+		out[j+4] = byte(s >> 32)
+		out[j+5] = byte(s >> 40)
+		out[j+6] = byte(s >> 48)
+		out[j+7] = byte(s >> 56)
+		j += 8
+	}
+	return out
+}
+
+// Sum512 returns a 64-byte BLAKE2b hash of data.
+func Sum512(data []byte) [64]byte {
+	var d digest
+	d.initialize(defaultConfig)
+	d.Write(data)
+	return d.checkSum()
+}
+
+// Sum256 returns a 32-byte BLAKE2b hash of data.
+func Sum256(data []byte) (out [32]byte) {
+	var d digest
+	d.initialize(config256)
+	d.Write(data)
+	sum := d.checkSum()
+	copy(out[:], sum[:32])
+	return
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go
new file mode 100644
index 000000000..ec53599f8
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.go
@@ -0,0 +1,47 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 blake2b
+
+//go:noescape
+func compressAVX2Loop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX2(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [8]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+	shffle[2] = 0x0201000706050403
+	shffle[3] = 0x0a09080f0e0d0c0b
+	shffle[4] = 0x0100070605040302
+	shffle[5] = 0x09080f0e0d0c0b0a
+	shffle[6] = 0x0100070605040302
+	shffle[7] = 0x09080f0e0d0c0b0a
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	compressAVX2Loop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s
new file mode 100644
index 000000000..24df234b5
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx2_amd64.s
@@ -0,0 +1,671 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// Based on AVX2 implementation from https://github.com/sneves/blake2-avx2/blob/master/blake2b-common.h
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+    \ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc4             \ // VPADDQ  YMM0,YMM0,YMM4   /* v0 += m[0], v1 += m[2], v2 += m[4], v3 += m[6] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0x70; BYTE $0xdb; BYTE $0xb1 \ // VPSHUFD YMM3,YMM3,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x75; BYTE $0x00; BYTE $0xce   // VPSHUFB YMM1,YMM1,YMM6   /* v4 = v4<<(64-24) | v4>>24, ..., ..., v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc5             \ // VPADDQ  YMM0,YMM0,YMM5   /* v0 += m[1], v1 += m[3], v2 += m[5], v3 += m[7] */
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xd4; BYTE $0xc1             \ // VPADDQ  YMM0,YMM0,YMM1   /* v0 += v4, v1 += v5, v2 += v6, v3 += v7 */
+    BYTE $0xc5; BYTE $0xe5; BYTE $0xef; BYTE $0xd8             \ // VPXOR   YMM3,YMM3,YMM0   /* v12 ^= v0, v13 ^= v1, v14 ^= v2, v15 ^= v3 */
+    BYTE $0xc4; BYTE $0xe2; BYTE $0x65; BYTE $0x00; BYTE $0xdf \ // VPSHUFB YMM3,YMM3,YMM7   /* v12 = v12<<(64-16) | v12>>16, ..., ..., v15 = v15<<(64-16) | v15>>16 */
+    BYTE $0xc5; BYTE $0xed; BYTE $0xd4; BYTE $0xd3             \ // VPADDQ  YMM2,YMM2,YMM3   /* v8 += v12, v9 += v13, v10 += v14, v11 += v15 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xca             \ // VPXOR   YMM1,YMM1,YMM2   /* v4 ^= v8, v5 ^= v9, v6 ^= v10, v7 ^= v11 */
+    BYTE $0xc5; BYTE $0x75; BYTE $0xd4; BYTE $0xf9             \ // VPADDQ  YMM15,YMM1,YMM1  /* temp reg = reg*2   */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0x73; BYTE $0xd1; BYTE $0x3f \ // VPSRLQ  YMM1,YMM1,0x3f   /*      reg = reg>>63 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcf   // VPXOR   YMM1,YMM1,YMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+
+#define DIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x93
+                BYTE $0x93                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x39
+                BYTE $0x39                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define UNDIAGONALIZE \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xdb \ // VPERMQ YMM3, YMM3, 0x39
+                BYTE $0x39                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xd2 \ // VPERMQ YMM2, YMM2, 0x4e
+                BYTE $0x4e                                     \
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xc9 \ // VPERMQ YMM1, YMM1, 0x93
+                BYTE $0x93                                     \
+    // DO NOT DELETE -- macro delimiter (previous line extended)
+
+#define LOAD_SHUFFLE \
+    MOVQ   shffle+120(FP), SI \ // SI: &shuffle
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x36             \ // VMOVDQU YMM6, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x7e; BYTE $0x20   // VMOVDQU YMM7, 32[rsi]
+
+// func compressAVX2Loop(compressSSE(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·compressAVX2Loop(SB), 7, $0
+
+    // REGISTER USE
+    //  Y0 - Y3: v0 - v15
+    //  Y4 - Y5: m[0] - m[7]
+    //  Y6 - Y7: shuffle value
+    //  Y8 - Y9: temp registers
+    // Y10 -Y13: copy of full message
+    //      Y15: temp register
+
+    // Load digest
+    MOVQ   in+24(FP),  SI     // SI: &in
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x06               // VMOVDQU YMM0, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x4e; BYTE $0x20   // VMOVDQU YMM1, 32[rsi]
+
+    // Already store digest into &out (so we can reload it later generically)
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Initialize message pointer and loop counter
+    MOVQ   message+0(FP), DX  // DX: &p (message)
+    MOVQ   message_len+8(FP), R8 // R8: len(message)
+    SHRQ   $7, R8             // len(message) / 128
+    CMPQ   R8, $0
+    JEQ    complete
+
+loop:
+    // Increment counter
+    MOVQ t+72(FP), SI         // SI: &t
+    MOVQ   0(SI), R9          //
+    ADDQ   $128, R9           //                       /* d.t[0] += BlockSize */
+    MOVQ   R9, 0(SI)          //
+    CMPQ   R9, $128           //                       /* if d.t[0] < BlockSize { */
+    JGE    noincr             //
+    MOVQ   8(SI), R9          //
+    ADDQ   $1, R9             //                       /*     d.t[1]++ */
+    MOVQ   R9, 8(SI)          //
+noincr:                       //                       /* } */
+
+    // Load initialization vector
+    MOVQ iv+48(FP), SI        // SI: &iv
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x16               // VMOVDQU YMM2, [rsi]
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x6f; BYTE $0x5e; BYTE $0x20   // VMOVDQU YMM3, 32[rsi]
+    MOVQ t+72(FP), SI         // SI: &t
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 0  /* Y8 = t[0]+t[1] */
+                BYTE $0x00
+    MOVQ t+96(FP), SI         // SI: &f
+    BYTE $0xc4; BYTE $0x63; BYTE $0x3d; BYTE $0x38; BYTE $0x06   // VINSERTI128 YMM8, YMM8, [rsi], 1  /* Y8 = t[0]+t[1]+f[0]+f[1] */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x65; BYTE $0xef; BYTE $0xd8   // VPXOR   YMM3,YMM3,YMM8            /* Y3 = Y3 ^ Y8 */
+
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x12               // VMOVDQU YMM10, [rdx]              /* Y10 =  m[0]+ m[1]+ m[2]+ m[3] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x5a; BYTE $0x20   // VMOVDQU YMM11, 32[rdx]            /* Y11 =  m[4]+ m[5]+ m[6]+ m[7] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x62; BYTE $0x40   // VMOVDQU YMM12, 64[rdx]            /* Y12 =  m[8]+ m[9]+m[10]+m[11] */
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6a; BYTE $0x60   // VMOVDQU YMM13, 96[rdx]            /* Y13 = m[12]+m[13]+m[14]+m[15] */
+
+    LOAD_SHUFFLE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   3
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc2   // VPUNPCKLQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   4
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x08
+                BYTE $0x08
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM11, YMM12
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   5
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM12, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM11, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9, YMM13, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   6
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc4   // VPUNPCKLQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   7
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x55
+                BYTE $0x55
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM13, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x01
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc2   // VPUNPCKHQDQ  YMM8, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   8
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc3   // VPUNPCKHQDQ  YMM8, YMM13, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xc9   // VPUNPCKLQDQ  YMM9, YMM13, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM10, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xc5   // VPUNPCKHQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM12, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x0c
+                BYTE $0x0c
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xcc   // VPUNPCKLQDQ  YMM9, YMM11, YMM12
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x30
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   9
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xca   // VPERMQ       YMM9, YMM10, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM12, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0x00
+                BYTE $0x00
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcc   // VPERMQ       YMM9, YMM12, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xc9   // VPUNPCKHQDQ  YMM9, YMM10, YMM9
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x15; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM13, YMM9, 0x20
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc3   // VPERMQ       YMM8, YMM11, 0xff
+                BYTE $0xff
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc0   // VPUNPCKLQDQ  YMM8, YMM10, YMM8
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x04
+                BYTE $0x04
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   10
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8, YMM12, 0x20
+                BYTE $0x20
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc3   // VPUNPCKLQDQ  YMM8, YMM10, YMM11
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcb   // VPERMQ       YMM9, YMM11, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6d; BYTE $0xc4   // VPUNPCKHQDQ  YMM8, YMM13, YMM12
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8, YMM8, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM10, YMM13
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9, YMM9, 0x60
+                BYTE $0x60
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4, YMM8, YMM9, 0x31
+                BYTE $0x31
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc5   // VPERMQ       YMM8, YMM13, 0xaa
+                BYTE $0xaa
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xc0   // VPUNPCKHQDQ  YMM8, YMM12, YMM8
+    BYTE $0xc4; BYTE $0x41; BYTE $0x15; BYTE $0x6c; BYTE $0xca   // VPUNPCKLQDQ  YMM9, YMM13, YMM10
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5, YMM8, YMM9, 0x21
+                BYTE $0x21
+                                                                 
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 1
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6c; BYTE $0xe3   // VPUNPCKLQDQ  YMM4, YMM10, YMM11 /* m[0], m[4], m[2], m[6] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x2d; BYTE $0x6d; BYTE $0xeb   // VPUNPCKHQDQ  YMM5, YMM10, YMM11 /* m[1], m[5], m[3], m[7] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6c; BYTE $0xe5   // VPUNPCKLQDQ  YMM4, YMM12, YMM13 /* m[8], m[12], m[10], m[14] */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x1d; BYTE $0x6d; BYTE $0xed   // VPUNPCKHQDQ  YMM5, YMM12, YMM13 /* m[9], m[13], m[11], m[15] */
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xe4   // VPERMQ       YMM4, YMM4, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+    BYTE $0xc4; BYTE $0xe3; BYTE $0xfd; BYTE $0x00; BYTE $0xed   // VPERMQ       YMM5, YMM5, 0xd8   /* 0x1101 1000 = 0xd8 */
+                BYTE $0xd8
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    ///////////////////////////////////////////////////////////////////////////
+    // R O U N D   1 2
+    ///////////////////////////////////////////////////////////////////////////
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM11, YMM13        /*  m[4],  ____,  ____, m[14] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x03         /* m[14],  m[4],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0x41; BYTE $0x1d; BYTE $0x6d; BYTE $0xcd   // VPUNPCKHQDQ  YMM9, YMM12, YMM13        /*  m[9], m[13],  ____,  ____ */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8,  YMM9, 0x20  /*  m[9], m[13],  ____,  ____ */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc4   // VPERMQ       YMM8,  YMM12, 0x02        /* m[10],  m[8],  ____,  ____ */ /* xxxx 0010 = 0x02 */
+                BYTE $0x02
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xcd   // VPERMQ       YMM9,  YMM13, 0x30        /*  ____,  ____, m[15],  ____ */ /* xx11 xxxx = 0x30 */
+                BYTE $0x30
+    BYTE $0xc4; BYTE $0x41; BYTE $0x35; BYTE $0x6c; BYTE $0xcb   // VPUNPCKLQDQ  YMM9,   YMM9, YMM11       /*  ____,  ____, m[15],  m[6] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,   YMM8, YMM9, 0x30  /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    DIAGONALIZE
+
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc2   // VPERMQ       YMM8, YMM10, 0x01         /*  m[1],  m[0],  ____,  ____ */ /* xxxx 0001 = 0x01 */
+                BYTE $0x01
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xcc   // VPUNPCKHQDQ  YMM9, YMM11, YMM12        /*  m[5],  ____,  ____, m[11] */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc9   // VPERMQ       YMM9,  YMM9, 0x03         /* m[11],  m[5],  ____,  ____ */ /* xxxx 0011 = 0x03 */
+                BYTE $0x03
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe1   // VPERM2I128   YMM4,  YMM8, YMM9, 0x20   /*  m[1],  m[0], m[11],  m[5] */ /* 0010 0000 = 0x20 */
+                BYTE $0x20
+
+    BYTE $0xc4; BYTE $0x41; BYTE $0x2d; BYTE $0x6c; BYTE $0xc5   // VPUNPCKLQDQ  YMM8, YMM10, YMM13        /*  ___,  m[12],  m[2],  ____ */
+    BYTE $0xc4; BYTE $0x43; BYTE $0xfd; BYTE $0x00; BYTE $0xc0   // VPERMQ       YMM8,  YMM8, 0x09         /* m[12],  m[2],  ____,  ____ */ /* xxxx 1001 = 0x09 */
+                BYTE $0x09
+    BYTE $0xc4; BYTE $0x41; BYTE $0x25; BYTE $0x6d; BYTE $0xca   // VPUNPCKHQDQ  YMM9, YMM11, YMM10        /*  ____,  ____,  m[7],  m[3] */
+    BYTE $0xc4; BYTE $0xc3; BYTE $0x3d; BYTE $0x46; BYTE $0xe9   // VPERM2I128   YMM5,  YMM8, YMM9, 0x30   /*  m[9], m[13], m[15],  m[6] */ /* 0011 0000 = 0x30 */
+                BYTE $0x30
+
+    G1
+    G2
+
+    UNDIAGONALIZE
+
+    // Reload digest (most current value store in &out)
+    MOVQ  out+144(FP),  SI    // SI: &in
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x26               // VMOVDQU YMM12, [rsi]
+    BYTE $0xc5; BYTE $0x7e; BYTE $0x6f; BYTE $0x6e; BYTE $0x20   // VMOVDQU YMM13, 32[rsi]
+
+    BYTE $0xc5; BYTE $0xfd; BYTE $0xef; BYTE $0xc2               // VPXOR   YMM0,YMM0,YMM2   /* X0 = X0 ^ X4,  X1 = X1 ^ X5 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x7d; BYTE $0xef; BYTE $0xc4   // VPXOR   YMM0,YMM0,YMM12  /* X0 = X0 ^ X12, X1 = X1 ^ X13 */
+    BYTE $0xc5; BYTE $0xf5; BYTE $0xef; BYTE $0xcb               // VPXOR   YMM1,YMM1,YMM3   /* X2 = X2 ^ X6,  X3 = X3 ^ X7 */
+    BYTE $0xc4; BYTE $0xc1; BYTE $0x75; BYTE $0xef; BYTE $0xcd   // VPXOR   YMM1,YMM1,YMM13  /* X2 = X2 ^ X14, X3 = X3 ^ X15 */
+
+    // Store digest into &out
+    MOVQ  out+144(FP), SI     // SI: &out
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x06               // VMOVDQU [rsi], YMM0
+    BYTE $0xc5; BYTE $0xfe; BYTE $0x7f; BYTE $0x4e; BYTE $0x20   // VMOVDQU 32[rsi], YMM1
+
+    // Increment message pointer and check if there's more to do
+    ADDQ   $128, DX           // message += 128
+    SUBQ   $1, R8
+    JNZ    loop
+
+complete:
+    BYTE $0xc5; BYTE $0xf8; BYTE $0x77                           // VZEROUPPER  /* Prevent further context switches */
+    RET
+
diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go
new file mode 100644
index 000000000..cfa12c04f
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.go
@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 blake2b
+
+//go:noescape
+func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressAVX(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [2]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	blockAVXLoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s
new file mode 100644
index 000000000..f68e17392
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressAvx_amd64.s
@@ -0,0 +1,682 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+	\ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd479c1c4; BYTE $0xc0 \ // VPADDQ  XMM0,XMM0,XMM8   /* v0 += m[0], v1 += m[2] */
+	LONG $0xd471c1c4; BYTE $0xc9 \ // VPADDQ  XMM1,XMM1,XMM9   /* v2 += m[4], v3 += m[6] */
+	LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+	LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+	LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf670f9c5; BYTE $0xb1 \ // VPSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+	LONG $0xff70f9c5; BYTE $0xb1 \ // VPSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+	LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13  */
+	LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+	LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+	LONG $0x0069c2c4; BYTE $0xd4 \ // VPSHUFB XMM2,XMM2,XMM12  /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+	LONG $0x0061c2c4; BYTE $0xdc   // VPSHUFB XMM3,XMM3,XMM12  /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+	\ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd479c1c4; BYTE $0xc2 \ // VPADDQ  XMM0,XMM0,XMM10  /* v0 += m[1], v1 += m[3] */
+	LONG $0xd471c1c4; BYTE $0xcb \ // VPADDQ  XMM1,XMM1,XMM11  /* v2 += m[5], v3 += m[7] */
+	LONG $0xc2d4f9c5             \ // VPADDQ  XMM0,XMM0,XMM2   /* v0 += v4, v1 += v5 */
+	LONG $0xcbd4f1c5             \ // VPADDQ  XMM1,XMM1,XMM3   /* v2 += v6, v3 += v7 */
+	LONG $0xf0efc9c5             \ // VPXOR   XMM6,XMM6,XMM0   /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9efc1c5             \ // VPXOR   XMM7,XMM7,XMM1   /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf670fbc5; BYTE $0x39 \ // VPSHUFLW XMM6,XMM6,0x39  /* combined with next ... */
+	LONG $0xf670fac5; BYTE $0x39 \ // VPSHUFHW XMM6,XMM6,0x39  /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+	LONG $0xff70fbc5; BYTE $0x39 \ // VPSHUFLW XMM7,XMM7,0x39  /* combined with next ... */
+	LONG $0xff70fac5; BYTE $0x39 \ // VPSHUFHW XMM7,XMM7,0x39  /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+	LONG $0xe6d4d9c5             \ // VPADDQ  XMM4,XMM4,XMM6   /* v8 += v12, v9 += v13 */
+	LONG $0xefd4d1c5             \ // VPADDQ  XMM5,XMM5,XMM7   /* v10 += v14, v11 += v15 */
+	LONG $0xd4efe9c5             \ // VPXOR   XMM2,XMM2,XMM4   /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddefe1c5             \ // VPXOR   XMM3,XMM3,XMM5   /* v6 ^= v10, v7 ^= v11 */
+	LONG $0xfad469c5             \ // VPADDQ  XMM15,XMM2,XMM2  /* temp reg = reg*2   */
+	LONG $0xd273e9c5; BYTE $0x3f \ // VPSRLQ  XMM2,XMM2,0x3f   /*      reg = reg>>63 */
+	LONG $0xef69c1c4; BYTE $0xd7 \ // VPXOR   XMM2,XMM2,XMM15  /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+	LONG $0xfbd461c5             \ // VPADDQ XMM15,XMM3,XMM3   /* temp reg = reg*2   */
+	LONG $0xd373e1c5; BYTE $0x3f \ // VPSRLQ XMM3,XMM3,0x3f    /*      reg = reg>>63 */
+	LONG $0xef61c1c4; BYTE $0xdf   // VPXOR  XMM3,XMM3,XMM15   /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+	\ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X6, X13                \                                     /* t0 = row4l;\                                                            */
+	MOVOU X2, X14                \                                     /* t1 = row2l;\                                                            */
+	MOVOU X4, X6                 \                                     /* row4l = row3l;\                                                         */
+	MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+	MOVOU X6, X5                 \                                     /* row3h = row4l;\                                                         */
+	LONG $0x6c1141c4; BYTE $0xfd \ // VPUNPCKLQDQ XMM15, XMM13, XMM13  /*                                    _mm_unpacklo_epi64(t0, t0)           */
+	LONG $0x6d41c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM7, XMM15  /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+	LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+	LONG $0x6d11c1c4; BYTE $0xff \ // VPUNPCKHQDQ  XMM7, XMM13, XMM15  /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+	LONG $0x6d69c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM2, XMM15  /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+	LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG $0x6d61c1c4; BYTE $0xdf   // VPUNPCKHQDQ  XMM3,  XMM3, XMM15  /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+	\ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X4, X13                \                                     /* t0 = row3l;\                                                            */
+	MOVOU X5, X4                 \                                     /* row3l = row3h;\                                                         */
+	MOVOU X13, X5                \                                     /* row3h = t0;\                                                            */
+	MOVOU X2, X13                \                                     /* t0 = row2l;\                                                            */
+	MOVOU X6, X14                \                                     /* t1 = row4l;\                                                            */
+	LONG $0xfa6c69c5             \ // VPUNPCKLQDQ XMM15,  XMM2,  XMM2  /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+	LONG $0x6d61c1c4; BYTE $0xd7 \ // VPUNPCKHQDQ  XMM2,  XMM3, XMM15  /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+	LONG $0xfb6c61c5             \ // VPUNPCKLQDQ XMM15,  XMM3,  XMM3  /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+	LONG $0x6d11c1c4; BYTE $0xdf \ // VPUNPCKHQDQ  XMM3, XMM13, XMM15  /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG $0xff6c41c5             \ // VPUNPCKLQDQ XMM15,  XMM7,  XMM7  /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+	LONG $0x6d49c1c4; BYTE $0xf7 \ // VPUNPCKHQDQ  XMM6,  XMM6, XMM15  /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+	LONG $0x6c0941c4; BYTE $0xfe \ // VPUNPCKLQDQ XMM15, XMM14, XMM14  /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG $0x6d41c1c4; BYTE $0xff   // VPUNPCKHQDQ  XMM7,  XMM7, XMM15  /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+	\ // Load shuffle value
+	MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+	MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockAVXLoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockAVXLoop(SB), 7, $0
+	// REGISTER USE
+	//        R8: loop counter
+	//        DX: message pointer
+	//        SI: temp pointer for loading
+	//  X0 -  X7: v0 - v15
+	//  X8 - X11: m[0] - m[7]
+	//       X12: shuffle value
+	// X13 - X15: temp registers
+
+	// Load digest
+	MOVQ  in+24(FP), SI // SI: &in
+	MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Already store digest into &out (so we can reload it later generically)
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Initialize message pointer and loop counter
+	MOVQ message+0(FP), DX     // DX: &p (message)
+	MOVQ message_len+8(FP), R8 // R8: len(message)
+	SHRQ $7, R8                // len(message) / 128
+	CMPQ R8, $0
+	JEQ  complete
+
+loop:
+	// Increment counter
+	MOVQ t+72(FP), SI // SI: &t
+	MOVQ 0(SI), R9
+	ADDQ $128, R9     // /* d.t[0] += BlockSize */
+	MOVQ R9, 0(SI)
+	CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+	JGE  noincr
+	MOVQ 8(SI), R9
+	ADDQ $1, R9       // /*     d.t[1]++ */
+	MOVQ R9, 8(SI)
+noincr:               // /* } */
+
+	// Load initialization vector
+	MOVQ  iv+48(FP), SI // SI: &iv
+	MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] );                                    */
+	MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] );                                    */
+	MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+	MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+	MOVQ  t+72(FP), SI  // SI: &t
+	MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+	PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+	MOVQ  t+96(FP), SI  // SI: &f
+	MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+	PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+	LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+	LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   3
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x0f0943c4; WORD $0x08c5 // VPALIGNR     XMM8, XMM14, XMM13, 0x8  /* m[11],  m[12] */
+	LONG $0x6d1941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM12, XMM15  /*  m[5], m[15] */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X15              // X15 =  m[8]+ m[9]
+	LONG $0x6c0141c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM15, XMM12  /*  m[8],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[2],   ___ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12               // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13               // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14               // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15               // X15 = m[10]+m[11]
+	LONG  $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___, m[3] */
+	LONG  $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[10],  ___ */
+	LONG  $0x6d1141c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM13, XMM14  /*  m[7], m[9] */
+	MOVOU 0(DX), X12                // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X14               // X14 =  m[4]+ m[5]
+	MOVOU 112(DX), X15              // X15 = m[14]+m[15]
+	LONG  $0x6c0141c4; BYTE $0xd5   // VPUNPCKLQDQ XMM10, XMM15, XMM13  /* m[14], m[6] */
+	LONG  $0x0f0943c4; WORD $0x08dc // VPALIGNR    XMM11, XMM14, XMM12, 0x8  /*  m[1],  m[4] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   4
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15             // X15 = m[12]+m[13]
+	LONG  $0x6d1141c4; BYTE $0xc4 // VPUNPCKHQDQ  XMM8, XMM13, XMM12  /*  m[7],  m[3] */
+	LONG  $0x6d0141c4; BYTE $0xce // VPUNPCKHQDQ  XMM9, XMM15, XMM14  /* m[13], m[11] */
+	MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13             // X13 =  m[8]+ m[9]
+	MOVOU 112(DX), X14            // X14 = m[14]+m[15]
+	LONG  $0x6d1141c4; BYTE $0xd4 // VPUNPCKHQDQ XMM10, XMM13, XMM12  /*  m[9],  m[1] */
+	LONG  $0x6c0141c4; BYTE $0xde // VPUNPCKLQDQ XMM11, XMM15, XMM14  /* m[12], m[14] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12             // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13             // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14             // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15            // X15 = m[14]+m[15]
+	LONG  $0x6d1141c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM13, XMM13  /*   ___,  m[5] */
+	LONG  $0x6c1941c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM12,  XMM8  /*  m[2],  ____ */
+	LONG  $0x6d0141c4; BYTE $0xcf // VPUNPCKHQDQ  XMM9, XMM15, XMM15  /*   ___, m[15] */
+	LONG  $0x6c1141c4; BYTE $0xc9 // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[4],  ____ */
+	MOVOU 0(DX), X12              // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13             // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X15             // X15 =  m[8]+ m[9]
+	LONG  $0x6c1141c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM13, XMM14  /*  m[6], m[10] */
+	LONG  $0x6c1941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM12, XMM15  /*  m[0],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   5
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6d0941c4; BYTE $0xc5 // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /*  m[9],  m[5] */
+	LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[2], m[10] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xd6 // VPUNPCKHQDQ XMM10, XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c1941c4; BYTE $0xd2 // VPUNPCKLQDQ XMM10, XMM12, XMM10  /*  m[0],  ____ */
+	LONG $0x6d0141c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[15] */
+	LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc6   // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___, m[11] */
+	LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[14],  ____ */
+	LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+	LONG $0x6c1141c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM13,  XMM9  /*  m[6],  ____ */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x0f0943c4; WORD $0x08d4 // VPALIGNR    XMM10, XMM14, XMM12, 0x8  /*  m[1], m[12] */
+	LONG $0x6d0941c4; BYTE $0xde   // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c1141c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[8],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   6
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	LONG $0x6c1141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM13, XMM14  /*  m[2],  m[6] */
+	LONG $0x6c1941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM12, XMM15  /*  m[0],  m[8] */
+	MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4 // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[10] */
+	LONG $0x6d1941c4; BYTE $0xdd // VPUNPCKHQDQ XMM11, XMM12, XMM13  /* m[11],  m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc6 // VPUNPCKHQDQ  XMM8, XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c1141c4; BYTE $0xc0 // VPUNPCKLQDQ  XMM8, XMM13,  XMM8  /*  m[4],  ____ */
+	LONG $0x6d0141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM15, XMM12  /* m[15],  m[1] */
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	LONG $0x6d0941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM14, XMM13  /* m[13],  m[5] */
+	LONG $0x6d1941c4; BYTE $0xdc // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[9] */
+	LONG $0x6c0141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM15, XMM11  /* m[14],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   7
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d1941c4; BYTE $0xc4   // VPUNPCKHQDQ  XMM8, XMM12, XMM12  /*   ___,  m[1] */
+	LONG $0x6c0941c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM14,  XMM8  /* m[12],  ____ */
+	LONG $0x6c0141c4; BYTE $0xcd   // VPUNPCKLQDQ  XMM9, XMM15, XMM13  /* m[14],  m[4] */
+	MOVOU 80(DX), X12              // X12 = m[10]+m[11]
+	LONG $0x6d1141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM13, XMM15  /*  m[5], m[15] */
+	LONG $0x0f1943c4; WORD $0x08de // VPALIGNR    XMM11, XMM12, XMM14, 0x8  /* m[13], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15              // X15 = m[10]+m[11]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[0],  m[6] */
+	LONG $0x0f0943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM14, XMM14, 0x8  /*  m[9],  m[8] */
+	MOVOU 16(DX), X14              // X14 =  m[2]+ m[3]
+	LONG $0x6d1141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM13, XMM14  /*  m[7],  m[3] */
+	LONG $0x6d0141c4; BYTE $0xdf   // VPUNPCKHQDQ XMM11, XMM15, XMM15  /*   ___, m[11] */
+	LONG $0x6c0941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM14, XMM11  /*  m[2],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   8
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0941c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM14, XMM13  /* m[13],  m[7] */
+	LONG $0x6d1941c4; BYTE $0xcc   // VPUNPCKHQDQ  XMM9, XMM12, XMM12  /*   ___,  m[3] */
+	LONG $0x6c0941c4; BYTE $0xc9   // VPUNPCKLQDQ  XMM9, XMM14,  XMM9  /* m[12],  ____ */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f0143c4; WORD $0x08d6 // VPALIGNR    XMM10, XMM15, XMM14, 0x8  /* m[11], m[14] */
+	LONG $0x6d1941c4; BYTE $0xdd   // VPUNPCKHQDQ XMM11, XMM12, XMM13  /*  m[1],  m[9] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d1141c4; BYTE $0xc7 // VPUNPCKHQDQ  XMM8, XMM13, XMM15  /*  m[5], m[15] */
+	LONG $0x6c0941c4; BYTE $0xcc // VPUNPCKLQDQ  XMM9, XMM14, XMM12  /*  m[8],  m[2] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c1941c4; BYTE $0xd5 // VPUNPCKLQDQ XMM10, XMM12, XMM13  /*  m[0],  m[4] */
+	LONG $0x6c0941c4; BYTE $0xdf // VPUNPCKLQDQ XMM11, XMM14, XMM15  /*  m[6], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   9
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6c1141c4; BYTE $0xc7   // VPUNPCKLQDQ  XMM8, XMM13, XMM15  /*  m[6], m[14] */
+	LONG $0x0f1943c4; WORD $0x08ce // VPALIGNR     XMM9, XMM12, XMM14, 0x8  /* m[11],  m[0] */
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	LONG $0x6d0141c4; BYTE $0xd6   // VPUNPCKHQDQ XMM10, XMM15, XMM14  /* m[15],  m[9] */
+	LONG $0x0f0943c4; WORD $0x08dd // VPALIGNR    XMM11, XMM14, XMM13, 0x8  /*  m[3],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13              // X13 =  m[2]+ m[3]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6d0141c4; BYTE $0xc7   // VPUNPCKHQDQ  XMM8, XMM15, XMM15  /*   ___, m[13] */
+	LONG $0x6c0141c4; BYTE $0xc0   // VPUNPCKLQDQ  XMM8, XMM15,  XMM8  /* m[12],  ____ */
+	LONG $0x0f0943c4; WORD $0x08cc // VPALIGNR     XMM9, XMM14, XMM12, 0x8  /*  m[1], m[10] */
+	MOVOU 32(DX), X12              // X12 =  m[4]+ m[5]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6d0141c4; BYTE $0xd7   // VPUNPCKHQDQ XMM10, XMM15, XMM15  /*   ___,  m[7] */
+	LONG $0x6c1141c4; BYTE $0xd2   // VPUNPCKLQDQ XMM10, XMM13, XMM10  /*  m[2],  ____ */
+	LONG $0x6d1941c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM12, XMM12  /*   ___,  m[5] */
+	LONG $0x6c1941c4; BYTE $0xdb   // VPUNPCKLQDQ XMM11, XMM12, XMM11  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 0
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c0141c4; BYTE $0xc6 // VPUNPCKLQDQ  XMM8, XMM15, XMM14  /* m[10],  m[8] */
+	LONG $0x6d1141c4; BYTE $0xcc // VPUNPCKHQDQ  XMM9, XMM13, XMM12  /*  m[7],  m[1] */
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+	LONG $0x6c1941c4; BYTE $0xd6 // VPUNPCKLQDQ XMM10, XMM12, XMM14  /*  m[2],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xde // VPUNPCKHQDQ XMM11, XMM14, XMM14  /*   ___,  m[5] */
+	LONG $0x6c1141c4; BYTE $0xdb // VPUNPCKLQDQ XMM11, XMM13, XMM11  /*  m[6],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 64(DX), X13              // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15             // X15 = m[14]+m[15]
+	LONG $0x6d0141c4; BYTE $0xc5   // VPUNPCKHQDQ  XMM8, XMM15, XMM13  /* m[15],  m[9] */
+	LONG $0x6d1941c4; BYTE $0xce   // VPUNPCKHQDQ  XMM9, XMM12, XMM14  /*  m[3], m[13] */
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	LONG $0x0f0143c4; WORD $0x08d5 // VPALIGNR    XMM10, XMM15, XMM13, 0x8  /* m[11], m[14] */
+	LONG $0x6c0941c4; BYTE $0xdc   // VPUNPCKLQDQ XMM11, XMM14, XMM12  /* m[12],  m[0] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[0], m[2] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[4], m[6] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /* m[1], m[3] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6c1941c4; BYTE $0xc5 // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /*  m[8],m[10] */
+	LONG $0x6c0941c4; BYTE $0xcf // VPUNPCKLQDQ  XMM9, XMM14, XMM15  /* m[12],m[14] */
+	LONG $0x6d1941c4; BYTE $0xd5 // VPUNPCKHQDQ XMM10, XMM12, XMM13  /*  m[9],m[11] */
+	LONG $0x6d0941c4; BYTE $0xdf // VPUNPCKHQDQ XMM11, XMM14, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12             // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14              // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15              // X15 = m[12]+m[13]
+	LONG $0x6c1941c4; BYTE $0xc5   // VPUNPCKLQDQ  XMM8, XMM12, XMM13  /* m[14],  m[4] */
+	LONG $0x6d0941c4; BYTE $0xcf   // VPUNPCKHQDQ  XMM9, XMM14, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X13              // X13 = m[10]+m[11]
+	MOVOU 48(DX), X15              // X15 =  m[6]+ m[7]
+	LONG $0x6c1141c4; BYTE $0xd6   // VPUNPCKLQDQ XMM10, XMM13, XMM14  /* m[10],  m[8] */
+	LONG $0x0f0143c4; WORD $0x08dc // VPALIGNR    XMM11, XMM15, XMM12, 0x8  /* m[15],  m[6] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12               // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13              // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14              // X14 = m[10]+m[11]
+	LONG $0x0f1943c4; WORD $0x08c4 // VPALIGNR     XMM8, XMM12, XMM12, 0x8  /*  m[1],  m[0] */
+	LONG $0x6d0941c4; BYTE $0xcd   // VPUNPCKHQDQ  XMM9, XMM14, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12              // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13              // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14              // X14 = m[12]+m[13]
+	LONG $0x6c0941c4; BYTE $0xd4   // VPUNPCKLQDQ XMM10, XMM14, XMM12  /* m[12], m[2] */
+	LONG $0x6d1141c4; BYTE $0xdc   // VPUNPCKHQDQ XMM11, XMM13, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	// Reload digest (most current value store in &out)
+	MOVQ  out+144(FP), SI // SI: &in
+	MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Final computations and prepare for storing
+	PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+	PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+	PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+	PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+	PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+	PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+	PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+	PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+	// Store digest into &out
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Increment message pointer and check if there's more to do
+	ADDQ $128, DX // message += 128
+	SUBQ $1, R8
+	JNZ  loop
+
+complete:
+	RET
diff --git a/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go
new file mode 100644
index 000000000..d539a7ade
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.go
@@ -0,0 +1,41 @@
+//+build !noasm
+//+build !appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 blake2b
+
+//go:noescape
+func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+
+func compressSSE(d *digest, p []uint8) {
+	var (
+		in     [8]uint64
+		out    [8]uint64
+		shffle [2]uint64
+	)
+
+	// vector for PSHUFB instruction
+	shffle[0] = 0x0201000706050403
+	shffle[1] = 0x0a09080f0e0d0c0b
+
+	in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7] = d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	blockSSELoop(p, in[:], iv[:], d.t[:], d.f[:], shffle[:], out[:])
+
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7]
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s
new file mode 100644
index 000000000..6f31c949e
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compressSse_amd64.s
@@ -0,0 +1,770 @@
+//+build !noasm !appengine
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// Based on SSE implementation from https://github.com/BLAKE2/BLAKE2/blob/master/sse/blake2b.c
+//
+// Use github.com/fwessels/asm2plan9s on this file to assemble instructions to their Plan9 equivalent
+//
+// Assembly code below essentially follows the ROUND macro (see blake2b-round.h) which is defined as:
+//   #define ROUND(r) \
+//     LOAD_MSG_ ##r ##_1(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_2(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h); \
+//     LOAD_MSG_ ##r ##_3(b0, b1); \
+//     G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     LOAD_MSG_ ##r ##_4(b0, b1); \
+//     G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1); \
+//     UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+//
+// as well as the go equivalent in https://github.com/dchest/blake2b/blob/master/block.go
+//
+// As in the macro, G1/G2 in the 1st and 2nd half are identical (so literal copy of assembly)
+//
+// Rounds are also the same, except for the loading of the message (and rounds 1 & 11 and
+// rounds 2 & 12 are identical)
+//
+
+#define G1 \
+	\ // G1(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG $0xd40f4166; BYTE $0xc0   \ // PADDQ  XMM0,XMM8        /* v0 += m[0], v1 += m[2] */
+	LONG $0xd40f4166; BYTE $0xc9   \ // PADDQ  XMM1,XMM9        /* v2 += m[4], v3 += m[6] */
+	LONG $0xc2d40f66               \ // PADDQ  XMM0,XMM2        /* v0 += v4, v1 += v5 */
+	LONG $0xcbd40f66               \ // PADDQ  XMM1,XMM3        /* v2 += v6, v3 += v7 */
+	LONG $0xf0ef0f66               \ // PXOR   XMM6,XMM0        /* v12 ^= v0, v13 ^= v1 */
+	LONG $0xf9ef0f66               \ // PXOR   XMM7,XMM1        /* v14 ^= v2, v15 ^= v3 */
+	LONG $0xf6700f66; BYTE $0xb1   \ // PSHUFD XMM6,XMM6,0xb1   /* v12 = v12<<(64-32) | v12>>32, v13 = v13<<(64-32) | v13>>32 */
+	LONG $0xff700f66; BYTE $0xb1   \ // PSHUFD XMM7,XMM7,0xb1   /* v14 = v14<<(64-32) | v14>>32, v15 = v15<<(64-32) | v15>>32 */
+	LONG $0xe6d40f66               \ // PADDQ  XMM4,XMM6        /* v8 += v12, v9 += v13  */
+	LONG $0xefd40f66               \ // PADDQ  XMM5,XMM7        /* v10 += v14, v11 += v15 */
+	LONG $0xd4ef0f66               \ // PXOR   XMM2,XMM4        /* v4 ^= v8, v5 ^= v9 */
+	LONG $0xddef0f66               \ // PXOR   XMM3,XMM5        /* v6 ^= v10, v7 ^= v11 */
+	LONG $0x380f4166; WORD $0xd400 \ // PSHUFB XMM2,XMM12       /* v4 = v4<<(64-24) | v4>>24, v5 = v5<<(64-24) | v5>>24 */
+	LONG $0x380f4166; WORD $0xdc00   // PSHUFB XMM3,XMM12       /* v6 = v6<<(64-24) | v6>>24, v7 = v7<<(64-24) | v7>>24 */
+
+#define G2 \
+	\ // G2(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h,b0,b1);
+	LONG  $0xd40f4166; BYTE $0xc2   \ // PADDQ  XMM0,XMM10        /* v0 += m[1], v1 += m[3] */
+	LONG  $0xd40f4166; BYTE $0xcb   \ // PADDQ  XMM1,XMM11        /* v2 += m[5], v3 += m[7] */
+	LONG  $0xc2d40f66               \ // PADDQ  XMM0,XMM2         /* v0 += v4, v1 += v5 */
+	LONG  $0xcbd40f66               \ // PADDQ  XMM1,XMM3         /* v2 += v6, v3 += v7 */
+	LONG  $0xf0ef0f66               \ // PXOR   XMM6,XMM0         /* v12 ^= v0, v13 ^= v1 */
+	LONG  $0xf9ef0f66               \ // PXOR   XMM7,XMM1         /* v14 ^= v2, v15 ^= v3 */
+	LONG  $0xf6700ff2; BYTE $0x39   \ // PSHUFLW XMM6,XMM6,0x39   /* combined with next ... */
+	LONG  $0xf6700ff3; BYTE $0x39   \ // PSHUFHW XMM6,XMM6,0x39   /* v12 = v12<<(64-16) | v12>>16, v13 = v13<<(64-16) | v13>>16 */
+	LONG  $0xff700ff2; BYTE $0x39   \ // PSHUFLW XMM7,XMM7,0x39   /* combined with next ... */
+	LONG  $0xff700ff3; BYTE $0x39   \ // PSHUFHW XMM7,XMM7,0x39   /* v14 = v14<<(64-16) | v14>>16, v15 = v15<<(64-16) | v15>>16 */
+	LONG  $0xe6d40f66               \ // PADDQ  XMM4,XMM6         /* v8 += v12, v9 += v13 */
+	LONG  $0xefd40f66               \ // PADDQ  XMM5,XMM7         /* v10 += v14, v11 += v15 */
+	LONG  $0xd4ef0f66               \ // PXOR   XMM2,XMM4         /* v4 ^= v8, v5 ^= v9 */
+	LONG  $0xddef0f66               \ // PXOR   XMM3,XMM5         /* v6 ^= v10, v7 ^= v11 */
+	MOVOU X2, X15                   \
+	LONG  $0xd40f4466; BYTE $0xfa   \ // PADDQ  XMM15,XMM2        /* temp reg = reg*2   */
+	LONG  $0xd2730f66; BYTE $0x3f   \ // PSRLQ  XMM2,0x3f         /*      reg = reg>>63 */
+	LONG  $0xef0f4166; BYTE $0xd7   \ // PXOR   XMM2,XMM15        /* ORed together: v4 = v4<<(64-63) | v4>>63, v5 = v5<<(64-63) | v5>>63 */
+	MOVOU X3, X15                   \
+	LONG  $0xd40f4466; BYTE $0xfb   \ // PADDQ XMM15,XMM3         /* temp reg = reg*2   */
+	LONG  $0xd3730f66; BYTE $0x3f   \ // PSRLQ XMM3,0x3f          /*      reg = reg>>63 */
+	LONG  $0xef0f4166; BYTE $0xdf     // PXOR  XMM3,XMM15         /* ORed together: v6 = v6<<(64-63) | v6>>63, v7 = v7<<(64-63) | v7>>63 */
+
+#define DIAGONALIZE \
+	\ // DIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X6, X13                   \                                     /* t0 = row4l;\                                                            */
+	MOVOU X2, X14                   \                                     /* t1 = row2l;\                                                            */
+	MOVOU X4, X6                    \                                     /* row4l = row3l;\                                                         */
+	MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+	MOVOU X6, X5                    \                                     /* row3h = row4l;\                                                         */
+	LONG  $0x6c0f4566; BYTE $0xfd   \ // PUNPCKLQDQ XMM15, XMM13          /*                                    _mm_unpacklo_epi64(t0, t0)           */
+	MOVOU X7, X6                    \
+	LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4h,                           ); \       */
+	LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                 _mm_unpacklo_epi64(row4h, row4h)        */
+	MOVOU X13, X7                   \
+	LONG  $0x6d0f4166; BYTE $0xff   \ // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                    _mm_unpacklo_epi64(row2h, row2h)     */
+	LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2l,                                 ); \ */
+	LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG  $0x6d0f4166; BYTE $0xdf     // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(row2h,                           )          */
+
+#define UNDIAGONALIZE \
+	\ // UNDIAGONALIZE(row1l,row2l,row3l,row4l,row1h,row2h,row3h,row4h);
+	MOVOU X4, X13                   \                                     /* t0 = row3l;\                                                            */
+	MOVOU X5, X4                    \                                     /* row3l = row3h;\                                                         */
+	MOVOU X13, X5                   \                                     /* row3h = t0;\                                                            */
+	MOVOU X2, X13                   \                                     /* t0 = row2l;\                                                            */
+	MOVOU X6, X14                   \                                     /* t1 = row4l;\                                                            */
+	LONG  $0x6c0f4466; BYTE $0xfa   \ // PUNPCKLQDQ XMM15,  XMM2          /*                                    _mm_unpacklo_epi64(row2l, row2l)     */
+	MOVOU X3, X2                    \
+	LONG  $0x6d0f4166; BYTE $0xd7   \ // PUNPCKHQDQ  XMM2, XMM15          /*  row2l = _mm_unpackhi_epi64(row2h,                                 ); \ */
+	LONG  $0x6c0f4466; BYTE $0xfb   \ // PUNPCKLQDQ XMM15,  XMM3          /*                                 _mm_unpacklo_epi64(row2h, row2h)        */
+	MOVOU X13, X3                   \
+	LONG  $0x6d0f4166; BYTE $0xdf   \ // PUNPCKHQDQ  XMM3, XMM15          /*  row2h = _mm_unpackhi_epi64(t0,                                 ); \    */
+	LONG  $0x6c0f4466; BYTE $0xff   \ // PUNPCKLQDQ XMM15,  XMM7          /*                                    _mm_unpacklo_epi64(row4h, row4h)     */
+	LONG  $0x6d0f4166; BYTE $0xf7   \ // PUNPCKHQDQ  XMM6, XMM15          /*  row4l = _mm_unpackhi_epi64(row4l,                                 ); \ */
+	LONG  $0x6c0f4566; BYTE $0xfe   \ // PUNPCKLQDQ XMM15, XMM14          /*                                    _mm_unpacklo_epi64(t1, t1)           */
+	LONG  $0x6d0f4166; BYTE $0xff     // PUNPCKHQDQ  XMM7, XMM15          /*  row4h = _mm_unpackhi_epi64(row4h,                           )          */
+
+#define LOAD_SHUFFLE \
+	\ // Load shuffle value
+	MOVQ  shffle+120(FP), SI \ // SI: &shuffle
+	MOVOU 0(SI), X12           // X12 = 03040506 07000102 0b0c0d0e 0f08090a
+
+// func blockSSELoop(p []uint8, in, iv, t, f, shffle, out []uint64)
+TEXT ·blockSSELoop(SB), 7, $0
+	// REGISTER USE
+	//        R8: loop counter
+	//        DX: message pointer
+	//        SI: temp pointer for loading
+	//  X0 -  X7: v0 - v15
+	//  X8 - X11: m[0] - m[7]
+	//       X12: shuffle value
+	// X13 - X15: temp registers
+
+	// Load digest
+	MOVQ  in+24(FP), SI // SI: &in
+	MOVOU 0(SI), X0     // X0 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X1    // X1 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X2    // X2 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X3    // X3 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Already store digest into &out (so we can reload it later generically)
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Initialize message pointer and loop counter
+	MOVQ message+0(FP), DX     // DX: &p (message)
+	MOVQ message_len+8(FP), R8 // R8: len(message)
+	SHRQ $7, R8                // len(message) / 128
+	CMPQ R8, $0
+	JEQ  complete
+
+loop:
+	// Increment counter
+	MOVQ t+72(FP), SI // SI: &t
+	MOVQ 0(SI), R9
+	ADDQ $128, R9     // /* d.t[0] += BlockSize */
+	MOVQ R9, 0(SI)
+	CMPQ R9, $128     // /* if d.t[0] < BlockSize { */
+	JGE  noincr
+	MOVQ 8(SI), R9
+	ADDQ $1, R9       // /*     d.t[1]++ */
+	MOVQ R9, 8(SI)
+
+noincr:  // /* } */
+
+	// Load initialization vector
+	MOVQ  iv+48(FP), SI // SI: &iv
+	MOVOU 0(SI), X4     // X4 = iv[0]+iv[1]      /* row3l = LOAD( &blake2b_IV[0] ); */
+	MOVOU 16(SI), X5    // X5 = iv[2]+iv[3]      /* row3h = LOAD( &blake2b_IV[2] ); */
+	MOVOU 32(SI), X6    // X6 = iv[4]+iv[5]      /*                        LOAD( &blake2b_IV[4] )                      */
+	MOVOU 48(SI), X7    // X7 = iv[6]+iv[7]      /*                        LOAD( &blake2b_IV[6] )                      */
+	MOVQ  t+72(FP), SI  // SI: &t
+	MOVOU 0(SI), X8     // X8 = t[0]+t[1]        /*                                                LOAD( &S->t[0] )    */
+	PXOR  X8, X6        // X6 = X6 ^ X8          /* row4l = _mm_xor_si128(                       ,                  ); */
+	MOVQ  t+96(FP), SI  // SI: &f
+	MOVOU 0(SI), X8     // X8 = f[0]+f[1]        /*                                                LOAD( &S->f[0] )    */
+	PXOR  X8, X7        // X7 = X7 ^ X8          /* row4h = _mm_xor_si128(                       ,                  ); */
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+	LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   3
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+	MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X14, X8
+	LONG $0x3a0f4566; WORD $0xc50f; BYTE $0x08 // PALIGNR     XMM8, XMM13, 0x8  /* m[11],  m[12] */
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[5], m[15] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X10                          // X10 =  m[8]+ m[9]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /*  m[8],  m[0] */
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[2],   ___ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___, m[3] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[10],  ___ */
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[7], m[9] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X11                          // X11 =  m[4]+ m[5]
+	MOVOU 112(DX), X10                         // X10 = m[14]+m[15]
+	LONG $0x6c0f4566; BYTE $0xd5               // PUNPCKLQDQ XMM10, XMM13  /* m[14], m[6] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /*  m[1],  m[4] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   4
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15            // X15 = m[12]+m[13]
+	MOVOU X13, X8
+	LONG $0x6d0f4566; BYTE $0xc4 // PUNPCKHQDQ  XMM8, XMM12  /*  m[7],  m[3] */
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /* m[13], m[11] */
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X10            // X10 =  m[8]+ m[9]
+	MOVOU 112(DX), X14           // X14 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xd4 // PUNPCKHQDQ XMM10, XMM12  /*  m[9],  m[1] */
+	MOVOU X15, X11
+	LONG $0x6c0f4566; BYTE $0xde // PUNPCKLQDQ XMM11, XMM14  /* m[12], m[14] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14            // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xcd // PUNPCKHQDQ  XMM9, XMM13  /*   ___,  m[5] */
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[2],  ____ */
+	MOVOU X15, X10
+	LONG $0x6d0f4566; BYTE $0xd7 // PUNPCKHQDQ XMM10, XMM15  /*   ___, m[15] */
+	MOVOU X13, X9
+	LONG $0x6c0f4566; BYTE $0xca // PUNPCKLQDQ  XMM9, XMM10  /*  m[4],  ____ */
+	MOVOU 0(DX), X11             // X11 =  m[0]+ m[1]
+	MOVOU 48(DX), X10            // X10 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[6], m[10] */
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[0],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   5
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	MOVOU X14, X8
+	LONG $0x6d0f4566; BYTE $0xc5 // PUNPCKHQDQ  XMM8, XMM13  /*  m[9],  m[5] */
+	MOVOU X12, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[2], m[10] */
+	MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xf6 // PUNPCKHQDQ XMM14, XMM14  /*   ___,  m[7] */
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[0],  ____ */
+	LONG $0x6d0f4566; BYTE $0xff // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[15] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ  XMM14, XMM14  /*   ___, m[11] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc6               // PUNPCKLQDQ  XMM8,  XMM14  /* m[14],  ____ */
+	LONG $0x6d0f4566; BYTE $0xe4               // PUNPCKHQDQ  XMM12, XMM12  /*   ___,  m[3] */
+	MOVOU X13, X9
+	LONG $0x6c0f4566; BYTE $0xcc               // PUNPCKLQDQ  XMM9,  XMM12  /*  m[6],  ____ */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 64(DX), X11                          // X11 =  m[8]+ m[9]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU X14, X10
+	LONG $0x3a0f4566; WORD $0xd40f; BYTE $0x08 // PALIGNR    XMM10, XMM12, 0x8  /*  m[1], m[12] */
+	LONG $0x6d0f4566; BYTE $0xf6               // PUNPCKHQDQ XMM14, XMM14  /*   ___, m[13] */
+	LONG $0x6c0f4566; BYTE $0xde               // PUNPCKLQDQ XMM11, XMM14  /*  m[8],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   6
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13            // X13 =  m[2]+ m[3]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 64(DX), X15            // X15 =  m[8]+ m[9]
+	MOVOU X13, X8
+	LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /*  m[2],  m[6] */
+	MOVOU X12, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /*  m[0],  m[8] */
+	MOVOU 80(DX), X12            // X12 = m[10]+m[11]
+	MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4 // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[10] */
+	MOVOU X12, X11
+	LONG $0x6d0f4566; BYTE $0xdd // PUNPCKHQDQ XMM11, XMM13  /* m[11],  m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 48(DX), X14            // X14 =  m[6]+ m[7]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xce // PUNPCKHQDQ  XMM9, XMM14  /*   ___,  m[7] */
+	MOVOU X13, X8
+	LONG $0x6c0f4566; BYTE $0xc1 // PUNPCKLQDQ  XMM8,  XMM9  /*  m[4],  ____ */
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /* m[15],  m[1] */
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 96(DX), X10            // X10 = m[12]+m[13]
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[13],  m[5] */
+	LONG $0x6d0f4566; BYTE $0xe4 // PUNPCKHQDQ XMM12, XMM12  /*   ___,  m[9] */
+	MOVOU X15, X11
+	LONG $0x6c0f4566; BYTE $0xdc // PUNPCKLQDQ XMM11, XMM12  /* m[14],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   7
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xcc               // PUNPCKHQDQ  XMM9, XMM12  /*   ___,  m[1] */
+	MOVOU X14, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+	MOVOU X15, X9
+	LONG $0x6c0f4566; BYTE $0xcd               // PUNPCKLQDQ  XMM9, XMM13  /* m[14],  m[4] */
+	MOVOU 80(DX), X11                          // X11 = m[10]+m[11]
+	MOVOU X13, X10
+	LONG $0x6d0f4566; BYTE $0xd7               // PUNPCKHQDQ XMM10, XMM15  /*  m[5], m[15] */
+	LONG $0x3a0f4566; WORD $0xde0f; BYTE $0x08 // PALIGNR    XMM11, XMM14, 0x8  /* m[13], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15                          // X15 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /*  m[0],  m[6] */
+	MOVOU X14, X9
+	LONG $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /*  m[9],  m[8] */
+	MOVOU 16(DX), X11                          // X14 =  m[2]+ m[3]
+	MOVOU X13, X10
+	LONG $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /*  m[7],  m[3] */
+	LONG $0x6d0f4566; BYTE $0xff               // PUNPCKHQDQ XMM15, XMM15  /*   ___, m[11] */
+	LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[2],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   8
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X13                          // X13 =  m[6]+ m[7]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X14, X8
+	LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[13],  m[7] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd4               // PUNPCKHQDQ XMM10, XMM12  /*   ___,  m[3] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xca               // PUNPCKLQDQ  XMM9,  XMM10  /* m[12],  ____ */
+	MOVOU 0(DX), X11                           // X11 =  m[0]+ m[1]
+	MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X15, X10
+	LONG $0x3a0f4566; WORD $0xd60f; BYTE $0x08 // PALIGNR    XMM10, XMM14, 0x8  /* m[11], m[14] */
+	LONG $0x6d0f4566; BYTE $0xdd               // PUNPCKHQDQ XMM11, XMM13  /*  m[1],  m[9] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12            // X12 =  m[2]+ m[3]
+	MOVOU 32(DX), X13            // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X13, X8
+	LONG $0x6d0f4566; BYTE $0xc7 // PUNPCKHQDQ  XMM8, XMM15  /*  m[5], m[15] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcc // PUNPCKLQDQ  XMM9, XMM12  /*  m[8],  m[2] */
+	MOVOU 0(DX), X10             // X10 =  m[0]+ m[1]
+	MOVOU 48(DX), X11            // X11 =  m[6]+ m[7]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	LONG $0x6c0f4566; BYTE $0xd5 // PUNPCKLQDQ XMM10, XMM13  /*  m[0],  m[4] */
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6], m[10] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   9
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                            // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13                           // X13 =  m[6]+ m[7]
+	MOVOU 80(DX), X14                           // X14 = m[10]+m[11]
+	MOVOU 112(DX), X15                          // X15 = m[14]+m[15]
+	MOVOU X13, X8
+	LONG  $0x6c0f4566; BYTE $0xc7               // PUNPCKLQDQ  XMM8, XMM15  /*  m[6], m[14] */
+	MOVOU X12, X9
+	LONG  $0x3a0f4566; WORD $0xce0f; BYTE $0x08 // PALIGNR     XMM9, XMM14, 0x8  /* m[11],  m[0] */
+	MOVOU 16(DX), X13                           // X13 =  m[2]+ m[3]
+	MOVOU 64(DX), X11                           // X11 =  m[8]+ m[9]
+	MOVOU X15, X10
+	LONG  $0x6d0f4566; BYTE $0xd3               // PUNPCKHQDQ XMM10, XMM11  /* m[15],  m[9] */
+	LONG  $0x3a0f4566; WORD $0xdd0f; BYTE $0x08 // PALIGNR    XMM11, XMM13, 0x8  /*  m[3],  m[8] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 16(DX), X13                          // X13 =  m[2]+ m[3]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X15, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*   ___, m[13] */
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc1               // PUNPCKLQDQ  XMM8,  XMM9  /* m[12],  ____ */
+	MOVOU X14, X9
+	LONG $0x3a0f4566; WORD $0xcc0f; BYTE $0x08 // PALIGNR     XMM9, XMM12, 0x8  /*  m[1], m[10] */
+	MOVOU 32(DX), X12                          // X12 =  m[4]+ m[5]
+	MOVOU 48(DX), X15                          // X15 =  m[6]+ m[7]
+	MOVOU X15, X11
+	LONG $0x6d0f4566; BYTE $0xdf               // PUNPCKHQDQ XMM11, XMM15  /*   ___,  m[7] */
+	MOVOU X13, X10
+	LONG $0x6c0f4566; BYTE $0xd3               // PUNPCKLQDQ XMM10, XMM11  /*  m[2],  ____ */
+	MOVOU X12, X15
+	LONG $0x6d0f4566; BYTE $0xfc               // PUNPCKHQDQ XMM15, XMM12  /*   ___,  m[5] */
+	MOVOU X12, X11
+	LONG $0x6c0f4566; BYTE $0xdf               // PUNPCKLQDQ XMM11, XMM15  /*  m[4],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 0
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 =  m[0]+ m[1]
+	MOVOU 48(DX), X13            // X13 =  m[6]+ m[7]
+	MOVOU 64(DX), X14            // X14 =  m[8]+ m[9]
+	MOVOU 80(DX), X15            // X15 = m[10]+m[11]
+	MOVOU X15, X8
+	LONG $0x6c0f4566; BYTE $0xc6 // PUNPCKLQDQ  XMM8, XMM14  /* m[10],  m[8] */
+	MOVOU X13, X9
+	LONG $0x6d0f4566; BYTE $0xcc // PUNPCKHQDQ  XMM9, XMM12  /*  m[7],  m[1] */
+	MOVOU 16(DX), X10            // X10 =  m[2]+ m[3]
+	MOVOU 32(DX), X14            // X14 =  m[4]+ m[5]
+	LONG $0x6c0f4566; BYTE $0xd6 // PUNPCKLQDQ XMM10, XMM14  /*  m[2],  m[4] */
+	MOVOU X14, X15
+	LONG $0x6d0f4566; BYTE $0xfe // PUNPCKHQDQ XMM15, XMM14  /*   ___,  m[5] */
+	MOVOU X13, X11
+	LONG $0x6c0f4566; BYTE $0xdf // PUNPCKLQDQ XMM11, XMM15  /*  m[6],  ____ */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 64(DX), X13                          // X13 =  m[8]+ m[9]
+	MOVOU 96(DX), X14                          // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15                         // X15 = m[14]+m[15]
+	MOVOU X15, X8
+	LONG $0x6d0f4566; BYTE $0xc5               // PUNPCKHQDQ  XMM8, XMM13  /* m[15],  m[9] */
+	MOVOU X12, X9
+	LONG $0x6d0f4566; BYTE $0xce               // PUNPCKHQDQ  XMM9, XMM14  /*  m[3], m[13] */
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 80(DX), X13                          // X13 = m[10]+m[11]
+	MOVOU X15, X10
+	LONG $0x3a0f4566; WORD $0xd50f; BYTE $0x08 // PALIGNR    XMM10, XMM13, 0x8  /* m[11], m[14] */
+	MOVOU X14, X11
+	LONG $0x6c0f4566; BYTE $0xdc               // PUNPCKLQDQ XMM11, XMM12  /* m[12],  m[0] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 1
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12             // X12 = m[0]+m[1]
+	MOVOU 16(DX), X13            // X13 = m[2]+m[3]
+	MOVOU 32(DX), X14            // X14 = m[4]+m[5]
+	MOVOU 48(DX), X15            // X15 = m[6]+m[7]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /* m[0], m[2] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[4], m[6] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /* m[1], m[3] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[5], m[7] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 64(DX), X12            // X12 =  m[8]+ m[9]
+	MOVOU 80(DX), X13            // X13 = m[10]+m[11]
+	MOVOU 96(DX), X14            // X14 = m[12]+m[13]
+	MOVOU 112(DX), X15           // X15 = m[14]+m[15]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5 // PUNPCKLQDQ  XMM8, XMM13  /*  m[8],m[10] */
+	MOVOU X14, X9
+	LONG $0x6c0f4566; BYTE $0xcf // PUNPCKLQDQ  XMM9, XMM15  /* m[12],m[14] */
+	MOVOU X12, X10
+	LONG $0x6d0f4566; BYTE $0xd5 // PUNPCKHQDQ XMM10, XMM13  /*  m[9],m[11] */
+	MOVOU X14, X11
+	LONG $0x6d0f4566; BYTE $0xdf // PUNPCKHQDQ XMM11, XMM15  /* m[13],m[15] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	///////////////////////////////////////////////////////////////////////////
+	// R O U N D   1 2
+	///////////////////////////////////////////////////////////////////////////
+
+	// LOAD_MSG_ ##r ##_1 / ##_2(b0, b1); (X12 is temp register)
+	MOVOU 112(DX), X12                         // X12 = m[14]+m[15]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 64(DX), X14                          // X14 =  m[8]+ m[9]
+	MOVOU 96(DX), X15                          // X15 = m[12]+m[13]
+	MOVOU X12, X8
+	LONG $0x6c0f4566; BYTE $0xc5               // PUNPCKLQDQ  XMM8, XMM13  /* m[14],  m[4] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcf               // PUNPCKHQDQ  XMM9, XMM15  /*  m[9], m[13] */
+	MOVOU 80(DX), X10                          // X10 = m[10]+m[11]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	LONG $0x6c0f4566; BYTE $0xd6               // PUNPCKLQDQ XMM10, XMM14  /* m[10],  m[8] */
+	LONG $0x3a0f4566; WORD $0xdc0f; BYTE $0x08 // PALIGNR    XMM11, XMM12, 0x8  /* m[15],  m[6] */; ; ; ; ;
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	DIAGONALIZE
+
+	// LOAD_MSG_ ##r ##_3 / ##_4(b0, b1); (X12 is temp register)
+	MOVOU 0(DX), X12                           // X12 =  m[0]+ m[1]
+	MOVOU 32(DX), X13                          // X13 =  m[4]+ m[5]
+	MOVOU 80(DX), X14                          // X14 = m[10]+m[11]
+	MOVOU X12, X8
+	LONG $0x3a0f4566; WORD $0xc40f; BYTE $0x08 // PALIGNR     XMM8, XMM12, 0x8  /*  m[1],  m[0] */
+	MOVOU X14, X9
+	LONG $0x6d0f4566; BYTE $0xcd               // PUNPCKHQDQ  XMM9, XMM13  /* m[11], m[5] */
+	MOVOU 16(DX), X12                          // X12 =  m[2]+ m[3]
+	MOVOU 48(DX), X11                          // X11 =  m[6]+ m[7]
+	MOVOU 96(DX), X10                          // X10 = m[12]+m[13]
+	LONG $0x6c0f4566; BYTE $0xd4               // PUNPCKLQDQ XMM10, XMM12  /* m[12], m[2] */
+	LONG $0x6d0f4566; BYTE $0xdc               // PUNPCKHQDQ XMM11, XMM12  /*  m[7], m[3] */
+
+	LOAD_SHUFFLE
+	G1
+	G2
+	UNDIAGONALIZE
+
+	// Reload digest (most current value store in &out)
+	MOVQ  out+144(FP), SI // SI: &in
+	MOVOU 0(SI), X12      // X12 = in[0]+in[1]      /* row1l = LOAD( &S->h[0] ); */
+	MOVOU 16(SI), X13     // X13 = in[2]+in[3]      /* row1h = LOAD( &S->h[2] ); */
+	MOVOU 32(SI), X14     // X14 = in[4]+in[5]      /* row2l = LOAD( &S->h[4] ); */
+	MOVOU 48(SI), X15     // X15 = in[6]+in[7]      /* row2h = LOAD( &S->h[6] ); */
+
+	// Final computations and prepare for storing
+	PXOR X4, X0  // X0 = X0 ^ X4          /* row1l = _mm_xor_si128( row3l, row1l ); */
+	PXOR X5, X1  // X1 = X1 ^ X5          /* row1h = _mm_xor_si128( row3h, row1h ); */
+	PXOR X12, X0 // X0 = X0 ^ X12         /*  STORE( &S->h[0], _mm_xor_si128( LOAD( &S->h[0] ), row1l ) ); */
+	PXOR X13, X1 // X1 = X1 ^ X13         /*  STORE( &S->h[2], _mm_xor_si128( LOAD( &S->h[2] ), row1h ) ); */
+	PXOR X6, X2  // X2 = X2 ^ X6          /*  row2l = _mm_xor_si128( row4l, row2l ); */
+	PXOR X7, X3  // X3 = X3 ^ X7          /*  row2h = _mm_xor_si128( row4h, row2h ); */
+	PXOR X14, X2 // X2 = X2 ^ X14         /*  STORE( &S->h[4], _mm_xor_si128( LOAD( &S->h[4] ), row2l ) ); */
+	PXOR X15, X3 // X3 = X3 ^ X15         /*  STORE( &S->h[6], _mm_xor_si128( LOAD( &S->h[6] ), row2h ) ); */
+
+	// Store digest into &out
+	MOVQ  out+144(FP), SI // SI: &out
+	MOVOU X0, 0(SI)       // out[0]+out[1] = X0
+	MOVOU X1, 16(SI)      // out[2]+out[3] = X1
+	MOVOU X2, 32(SI)      // out[4]+out[5] = X2
+	MOVOU X3, 48(SI)      // out[6]+out[7] = X3
+
+	// Increment message pointer and check if there's more to do
+	ADDQ $128, DX // message += 128
+	SUBQ $1, R8
+	JNZ  loop
+
+complete:
+	RET
diff --git a/vendor/github.com/minio/blake2b-simd/compress_amd64.go b/vendor/github.com/minio/blake2b-simd/compress_amd64.go
new file mode 100644
index 000000000..4fc5e388c
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_amd64.go
@@ -0,0 +1,30 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 blake2b
+
+func compress(d *digest, p []uint8) {
+	// Verifies if AVX2 or AVX is available, use optimized code path.
+	if avx2 {
+		compressAVX2(d, p)
+	} else if avx {
+		compressAVX(d, p)
+	} else if ssse3 {
+		compressSSE(d, p)
+	} else {
+		compressGeneric(d, p)
+	}
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compress_generic.go b/vendor/github.com/minio/blake2b-simd/compress_generic.go
new file mode 100644
index 000000000..e9e16e8b9
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_generic.go
@@ -0,0 +1,1419 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package blake2b
+
+func compressGeneric(d *digest, p []uint8) {
+	h0, h1, h2, h3, h4, h5, h6, h7 := d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7]
+
+	for len(p) >= BlockSize {
+		// Increment counter.
+		d.t[0] += BlockSize
+		if d.t[0] < BlockSize {
+			d.t[1]++
+		}
+		// Initialize compression function.
+		v0, v1, v2, v3, v4, v5, v6, v7 := h0, h1, h2, h3, h4, h5, h6, h7
+		v8 := iv[0]
+		v9 := iv[1]
+		v10 := iv[2]
+		v11 := iv[3]
+		v12 := iv[4] ^ d.t[0]
+		v13 := iv[5] ^ d.t[1]
+		v14 := iv[6] ^ d.f[0]
+		v15 := iv[7] ^ d.f[1]
+
+		j := 0
+		var m [16]uint64
+		for i := range m {
+			m[i] = uint64(p[j]) | uint64(p[j+1])<<8 | uint64(p[j+2])<<16 |
+				uint64(p[j+3])<<24 | uint64(p[j+4])<<32 | uint64(p[j+5])<<40 |
+				uint64(p[j+6])<<48 | uint64(p[j+7])<<56
+			j += 8
+		}
+
+		// Round 1.
+		v0 += m[0]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[2]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[4]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[6]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[5]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[7]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[3]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[1]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[8]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[10]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[12]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[14]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[13]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[15]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[11]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[9]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 2.
+		v0 += m[14]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[4]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[9]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[13]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[15]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[6]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[8]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[10]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[1]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[0]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[11]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[5]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[7]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[3]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[2]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[12]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 3.
+		v0 += m[11]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[12]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[5]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[15]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[2]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[13]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[0]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[8]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[10]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[3]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[7]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[9]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[1]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[4]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[6]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[14]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 4.
+		v0 += m[7]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[3]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[13]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[11]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[12]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[14]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[1]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[9]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[2]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[5]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[4]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[15]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[0]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[8]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[10]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[6]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 5.
+		v0 += m[9]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[5]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[2]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[10]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[4]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[15]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[7]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[0]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[14]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[11]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[6]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[3]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[8]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[13]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[12]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[1]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 6.
+		v0 += m[2]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[6]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[0]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[8]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[11]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[3]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[10]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[12]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[4]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[7]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[15]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[1]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[14]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[9]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[5]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[13]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 7.
+		v0 += m[12]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[1]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[14]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[4]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[13]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[10]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[15]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[5]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[0]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[6]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[9]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[8]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[2]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[11]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[3]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[7]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 8.
+		v0 += m[13]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[7]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[12]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[3]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[1]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[9]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[14]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[11]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[5]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[15]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[8]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[2]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[6]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[10]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[4]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[0]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 9.
+		v0 += m[6]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[14]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[11]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[0]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[3]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[8]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[9]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[15]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[12]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[13]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[1]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[10]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[4]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[5]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[7]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[2]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 10.
+		v0 += m[10]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[8]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[7]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[1]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[6]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[5]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[4]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[2]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[15]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[9]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[3]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[13]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[12]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[0]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[14]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[11]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 11.
+		v0 += m[0]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[2]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[4]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[6]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[5]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[7]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[3]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[1]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[8]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[10]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[12]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[14]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[13]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[15]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[11]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[9]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		// Round 12.
+		v0 += m[14]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-32) | v12>>32
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-24) | v4>>24
+		v1 += m[4]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-32) | v13>>32
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-24) | v5>>24
+		v2 += m[9]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-32) | v14>>32
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-24) | v6>>24
+		v3 += m[13]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-32) | v15>>32
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-24) | v7>>24
+		v2 += m[15]
+		v2 += v6
+		v14 ^= v2
+		v14 = v14<<(64-16) | v14>>16
+		v10 += v14
+		v6 ^= v10
+		v6 = v6<<(64-63) | v6>>63
+		v3 += m[6]
+		v3 += v7
+		v15 ^= v3
+		v15 = v15<<(64-16) | v15>>16
+		v11 += v15
+		v7 ^= v11
+		v7 = v7<<(64-63) | v7>>63
+		v1 += m[8]
+		v1 += v5
+		v13 ^= v1
+		v13 = v13<<(64-16) | v13>>16
+		v9 += v13
+		v5 ^= v9
+		v5 = v5<<(64-63) | v5>>63
+		v0 += m[10]
+		v0 += v4
+		v12 ^= v0
+		v12 = v12<<(64-16) | v12>>16
+		v8 += v12
+		v4 ^= v8
+		v4 = v4<<(64-63) | v4>>63
+		v0 += m[1]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-32) | v15>>32
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-24) | v5>>24
+		v1 += m[0]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-32) | v12>>32
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-24) | v6>>24
+		v2 += m[11]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-32) | v13>>32
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-24) | v7>>24
+		v3 += m[5]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-32) | v14>>32
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-24) | v4>>24
+		v2 += m[7]
+		v2 += v7
+		v13 ^= v2
+		v13 = v13<<(64-16) | v13>>16
+		v8 += v13
+		v7 ^= v8
+		v7 = v7<<(64-63) | v7>>63
+		v3 += m[3]
+		v3 += v4
+		v14 ^= v3
+		v14 = v14<<(64-16) | v14>>16
+		v9 += v14
+		v4 ^= v9
+		v4 = v4<<(64-63) | v4>>63
+		v1 += m[2]
+		v1 += v6
+		v12 ^= v1
+		v12 = v12<<(64-16) | v12>>16
+		v11 += v12
+		v6 ^= v11
+		v6 = v6<<(64-63) | v6>>63
+		v0 += m[12]
+		v0 += v5
+		v15 ^= v0
+		v15 = v15<<(64-16) | v15>>16
+		v10 += v15
+		v5 ^= v10
+		v5 = v5<<(64-63) | v5>>63
+
+		h0 ^= v0 ^ v8
+		h1 ^= v1 ^ v9
+		h2 ^= v2 ^ v10
+		h3 ^= v3 ^ v11
+		h4 ^= v4 ^ v12
+		h5 ^= v5 ^ v13
+		h6 ^= v6 ^ v14
+		h7 ^= v7 ^ v15
+
+		p = p[BlockSize:]
+	}
+	d.h[0], d.h[1], d.h[2], d.h[3], d.h[4], d.h[5], d.h[6], d.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}
diff --git a/vendor/github.com/minio/blake2b-simd/compress_noasm.go b/vendor/github.com/minio/blake2b-simd/compress_noasm.go
new file mode 100644
index 000000000..d3c675847
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/compress_noasm.go
@@ -0,0 +1,23 @@
+//+build !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 blake2b
+
+func compress(d *digest, p []uint8) {
+	compressGeneric(d, p)
+}
diff --git a/vendor/github.com/minio/blake2b-simd/cpuid.go b/vendor/github.com/minio/blake2b-simd/cpuid.go
new file mode 100644
index 000000000..a9f95508e
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid.go
@@ -0,0 +1,60 @@
+// +build 386,!gccgo amd64,!gccgo
+
+// Copyright 2016 Frank Wessels <fwessels@xs4all.nl>
+//
+// 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 blake2b
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+// True when SIMD instructions are available.
+var avx2 = haveAVX2()
+var avx = haveAVX()
+var ssse3 = haveSSSE3()
+
+// haveAVX returns true when there is AVX support
+func haveAVX() bool {
+	_, _, c, _ := cpuid(1)
+
+	// Check XGETBV, OXSAVE and AVX bits
+	if c&(1<<26) != 0 && c&(1<<27) != 0 && c&(1<<28) != 0 {
+		// Check for OS support
+		eax, _ := xgetbv(0)
+		return (eax & 0x6) == 0x6
+	}
+	return false
+}
+
+// haveAVX2 returns true when there is AVX2 support
+func haveAVX2() bool {
+	mfi, _, _, _ := cpuid(0)
+
+	// Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+	if mfi >= 7 && haveAVX() {
+		_, ebx, _, _ := cpuidex(7, 0)
+		return (ebx & 0x00000020) != 0
+	}
+	return false
+}
+
+// haveSSSE3 returns true when there is SSSE3 support
+func haveSSSE3() bool {
+
+	_, _, c, _ := cpuid(1)
+
+	return (c & 0x00000200) != 0
+}
diff --git a/vendor/github.com/minio/blake2b-simd/cpuid_386.s b/vendor/github.com/minio/blake2b-simd/cpuid_386.s
new file mode 100644
index 000000000..fa38814ec
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid_386.s
@@ -0,0 +1,33 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORL CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+4(FP)
+        MOVL BX, ebx+8(FP)
+        MOVL CX, ecx+12(FP)
+        MOVL DX, edx+16(FP)
+        RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+4(FP)
+        MOVL DX, edx+8(FP)
+        RET
diff --git a/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s b/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s
new file mode 100644
index 000000000..fb45a6560
--- /dev/null
+++ b/vendor/github.com/minio/blake2b-simd/cpuid_amd64.s
@@ -0,0 +1,34 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORQ CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+8(FP)
+        MOVL DX, edx+12(FP)
+        RET
diff --git a/vendor/github.com/minio/sha256-simd/LICENSE b/vendor/github.com/minio/sha256-simd/LICENSE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/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/github.com/minio/sha256-simd/cpuid.go b/vendor/github.com/minio/sha256-simd/cpuid.go
new file mode 100644
index 000000000..bf9d6b0db
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid.go
@@ -0,0 +1,93 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+// True when SIMD instructions are available.
+var avx512 = haveAVX512()
+var avx2 = haveAVX2()
+var avx = haveAVX()
+var ssse3 = haveSSSE3()
+var armSha = haveArmSha()
+
+// haveAVX returns true when there is AVX support
+func haveAVX() bool {
+	_, _, c, _ := cpuid(1)
+
+	// Check XGETBV, OXSAVE and AVX bits
+	if c&(1<<26) != 0 && c&(1<<27) != 0 && c&(1<<28) != 0 {
+		// Check for OS support
+		eax, _ := xgetbv(0)
+		return (eax & 0x6) == 0x6
+	}
+	return false
+}
+
+// haveAVX2 returns true when there is AVX2 support
+func haveAVX2() bool {
+	mfi, _, _, _ := cpuid(0)
+
+	// Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+	if mfi >= 7 && haveAVX() {
+		_, ebx, _, _ := cpuidex(7, 0)
+		return (ebx & 0x00000020) != 0
+	}
+	return false
+}
+
+// haveAVX512 returns true when there is AVX512 support
+func haveAVX512() bool {
+	mfi, _, _, _ := cpuid(0)
+
+	// Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+	if mfi >= 7 {
+		_, _, c, _ := cpuid(1)
+
+		// Only detect AVX-512 features if XGETBV is supported
+		if c&((1<<26)|(1<<27)) == (1<<26)|(1<<27) {
+			// Check for OS support
+			eax, _ := xgetbv(0)
+			_, ebx, _, _ := cpuidex(7, 0)
+
+			// Verify that XCR0[7:5] = ‘111b’ (OPMASK state, upper 256-bit of ZMM0-ZMM15 and
+			// ZMM16-ZMM31 state are enabled by OS)
+			/// and that XCR0[2:1] = ‘11b’ (XMM state and YMM state are enabled by OS).
+			if (eax>>5)&7 == 7 && (eax>>1)&3 == 3 {
+				if ebx&(1<<16) == 0 {
+					return false // no AVX512F
+				}
+				if ebx&(1<<17) == 0 {
+					return false // no AVX512DQ
+				}
+				if ebx&(1<<30) == 0 {
+					return false // no AVX512BW
+				}
+				if ebx&(1<<31) == 0 {
+					return false // no AVX512VL
+				}
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// haveSSSE3 returns true when there is SSSE3 support
+func haveSSSE3() bool {
+
+	_, _, c, _ := cpuid(1)
+
+	return (c & 0x00000200) != 0
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_386.go b/vendor/github.com/minio/sha256-simd/cpuid_386.go
new file mode 100644
index 000000000..c9890be47
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_386.go
@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+	return false
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_386.s b/vendor/github.com/minio/sha256-simd/cpuid_386.s
new file mode 100644
index 000000000..f908ae862
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_386.s
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// 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.
+
+// +build 386,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORL CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+4(FP)
+        MOVL BX, ebx+8(FP)
+        MOVL CX, ecx+12(FP)
+        MOVL DX, edx+16(FP)
+        RET
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+4(FP)
+        MOVL DX, edx+8(FP)
+        RET
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_amd64.go b/vendor/github.com/minio/sha256-simd/cpuid_amd64.go
new file mode 100644
index 000000000..c9890be47
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_amd64.go
@@ -0,0 +1,24 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func xgetbv(index uint32) (eax, edx uint32)
+
+func haveArmSha() bool {
+	return false
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_amd64.s b/vendor/github.com/minio/sha256-simd/cpuid_amd64.s
new file mode 100644
index 000000000..9a8a03297
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_amd64.s
@@ -0,0 +1,54 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Klaus Post
+//
+// 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.
+
+// +build amd64,!gccgo
+
+// func cpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuid(SB), 7, $0
+        XORQ CX, CX
+        MOVL op+0(FP), AX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+
+// func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·cpuidex(SB), 7, $0
+        MOVL op+0(FP), AX
+        MOVL op2+4(FP), CX
+        CPUID
+        MOVL AX, eax+8(FP)
+        MOVL BX, ebx+12(FP)
+        MOVL CX, ecx+16(FP)
+        MOVL DX, edx+20(FP)
+        RET
+
+// func xgetbv(index uint32) (eax, edx uint32)
+TEXT ·xgetbv(SB), 7, $0
+        MOVL index+0(FP), CX
+        BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
+        MOVL AX, eax+8(FP)
+        MOVL DX, edx+12(FP)
+        RET
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_arm.go b/vendor/github.com/minio/sha256-simd/cpuid_arm.go
new file mode 100644
index 000000000..351dff4b6
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_arm.go
@@ -0,0 +1,32 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+func haveArmSha() bool {
+	return false
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go b/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go
new file mode 100644
index 000000000..e739996d9
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_linux_arm64.go
@@ -0,0 +1,49 @@
+// +build arm64,linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+import (
+	"bytes"
+	"io/ioutil"
+)
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+// File to check for cpu capabilities.
+const procCPUInfo = "/proc/cpuinfo"
+
+// Feature to check for.
+const sha256Feature = "sha2"
+
+func haveArmSha() bool {
+	cpuInfo, err := ioutil.ReadFile(procCPUInfo)
+	if err != nil {
+		return false
+	}
+	return bytes.Contains(cpuInfo, []byte(sha256Feature))
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_other.go b/vendor/github.com/minio/sha256-simd/cpuid_other.go
new file mode 100644
index 000000000..e26952a82
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_other.go
@@ -0,0 +1,34 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x
+
+package sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+func haveArmSha() bool {
+	return false
+}
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go b/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go
new file mode 100644
index 000000000..0fb4022f7
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_others_arm64.go
@@ -0,0 +1,35 @@
+// +build arm64,!linux
+
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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 sha256
+
+func cpuid(op uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func cpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) {
+	return 0, 0, 0, 0
+}
+
+func xgetbv(index uint32) (eax, edx uint32) {
+	return 0, 0
+}
+
+// Check for sha2 instruction flag.
+func haveArmSha() bool {
+	return false
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256.go b/vendor/github.com/minio/sha256-simd/sha256.go
new file mode 100644
index 000000000..f28236eba
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256.go
@@ -0,0 +1,177 @@
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+import (
+	"crypto/sha256"
+	"hash"
+	"runtime"
+)
+
+// Size - The size of a SHA256 checksum in bytes.
+const Size = 32
+
+// BlockSize - The blocksize of SHA256 in bytes.
+const BlockSize = 64
+
+const (
+	chunk = 64
+	init0 = 0x6A09E667
+	init1 = 0xBB67AE85
+	init2 = 0x3C6EF372
+	init3 = 0xA54FF53A
+	init4 = 0x510E527F
+	init5 = 0x9B05688C
+	init6 = 0x1F83D9AB
+	init7 = 0x5BE0CD19
+)
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+	h   [8]uint32
+	x   [chunk]byte
+	nx  int
+	len uint64
+}
+
+// Reset digest back to default
+func (d *digest) Reset() {
+	d.h[0] = init0
+	d.h[1] = init1
+	d.h[2] = init2
+	d.h[3] = init3
+	d.h[4] = init4
+	d.h[5] = init5
+	d.h[6] = init6
+	d.h[7] = init7
+	d.nx = 0
+	d.len = 0
+}
+
+func block(dig *digest, p []byte) {
+	is386bit := runtime.GOARCH == "386"
+	isARM := runtime.GOARCH == "arm"
+	if is386bit || isARM {
+		blockGeneric(dig, p)
+	}
+	switch !is386bit && !isARM {
+	case avx2:
+		blockAvx2Go(dig, p)
+	case avx:
+		blockAvxGo(dig, p)
+	case ssse3:
+		blockSsseGo(dig, p)
+	case armSha:
+		blockArmGo(dig, p)
+	default:
+		blockGeneric(dig, p)
+	}
+}
+
+// New returns a new hash.Hash computing the SHA256 checksum.
+func New() hash.Hash {
+	if avx2 || avx || ssse3 || armSha {
+		d := new(digest)
+		d.Reset()
+		return d
+	}
+	// Fallback to the standard golang implementation
+	// if no features were found.
+	return sha256.New()
+}
+
+// Sum256 - single caller sha256 helper
+func Sum256(data []byte) [Size]byte {
+	var d digest
+	d.Reset()
+	d.Write(data)
+	return d.checkSum()
+}
+
+// Return size of checksum
+func (d *digest) Size() int { return Size }
+
+// Return blocksize of checksum
+func (d *digest) BlockSize() int { return BlockSize }
+
+// Write to digest
+func (d *digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			block(d, d.x[:])
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		block(d, p[:n])
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+// Return sha256 sum in bytes
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d0 so that caller can keep writing and summing.
+	d0 := *d
+	hash := d0.checkSum()
+	return append(in, hash[:]...)
+}
+
+// Intermediate checksum function
+func (d *digest) checkSum() [Size]byte {
+	len := d.len
+	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+	var tmp [64]byte
+	tmp[0] = 0x80
+	if len%64 < 56 {
+		d.Write(tmp[0 : 56-len%64])
+	} else {
+		d.Write(tmp[0 : 64+56-len%64])
+	}
+
+	// Length in bits.
+	len <<= 3
+	for i := uint(0); i < 8; i++ {
+		tmp[i] = byte(len >> (56 - 8*i))
+	}
+	d.Write(tmp[0:8])
+
+	if d.nx != 0 {
+		panic("d.nx != 0")
+	}
+
+	h := d.h[:]
+
+	var digest [Size]byte
+	for i, s := range h {
+		digest[i*4] = byte(s >> 24)
+		digest[i*4+1] = byte(s >> 16)
+		digest[i*4+2] = byte(s >> 8)
+		digest[i*4+3] = byte(s)
+	}
+
+	return digest
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go
new file mode 100644
index 000000000..43ee7a948
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+//go:noescape
+func blockAvx2(h []uint32, message []uint8)
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s
new file mode 100644
index 000000000..ff5d2a65d
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx2_amd64.s
@@ -0,0 +1,1442 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for AVX2
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+DATA K256<>+0x000(SB)/8, $0x71374491428a2f98
+DATA K256<>+0x008(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA K256<>+0x010(SB)/8, $0x71374491428a2f98
+DATA K256<>+0x018(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA K256<>+0x020(SB)/8, $0x59f111f13956c25b
+DATA K256<>+0x028(SB)/8, $0xab1c5ed5923f82a4
+DATA K256<>+0x030(SB)/8, $0x59f111f13956c25b
+DATA K256<>+0x038(SB)/8, $0xab1c5ed5923f82a4
+DATA K256<>+0x040(SB)/8, $0x12835b01d807aa98
+DATA K256<>+0x048(SB)/8, $0x550c7dc3243185be
+DATA K256<>+0x050(SB)/8, $0x12835b01d807aa98
+DATA K256<>+0x058(SB)/8, $0x550c7dc3243185be
+DATA K256<>+0x060(SB)/8, $0x80deb1fe72be5d74
+DATA K256<>+0x068(SB)/8, $0xc19bf1749bdc06a7
+DATA K256<>+0x070(SB)/8, $0x80deb1fe72be5d74
+DATA K256<>+0x078(SB)/8, $0xc19bf1749bdc06a7
+DATA K256<>+0x080(SB)/8, $0xefbe4786e49b69c1
+DATA K256<>+0x088(SB)/8, $0x240ca1cc0fc19dc6
+DATA K256<>+0x090(SB)/8, $0xefbe4786e49b69c1
+DATA K256<>+0x098(SB)/8, $0x240ca1cc0fc19dc6
+DATA K256<>+0x0a0(SB)/8, $0x4a7484aa2de92c6f
+DATA K256<>+0x0a8(SB)/8, $0x76f988da5cb0a9dc
+DATA K256<>+0x0b0(SB)/8, $0x4a7484aa2de92c6f
+DATA K256<>+0x0b8(SB)/8, $0x76f988da5cb0a9dc
+DATA K256<>+0x0c0(SB)/8, $0xa831c66d983e5152
+DATA K256<>+0x0c8(SB)/8, $0xbf597fc7b00327c8
+DATA K256<>+0x0d0(SB)/8, $0xa831c66d983e5152
+DATA K256<>+0x0d8(SB)/8, $0xbf597fc7b00327c8
+DATA K256<>+0x0e0(SB)/8, $0xd5a79147c6e00bf3
+DATA K256<>+0x0e8(SB)/8, $0x1429296706ca6351
+DATA K256<>+0x0f0(SB)/8, $0xd5a79147c6e00bf3
+DATA K256<>+0x0f8(SB)/8, $0x1429296706ca6351
+DATA K256<>+0x100(SB)/8, $0x2e1b213827b70a85
+DATA K256<>+0x108(SB)/8, $0x53380d134d2c6dfc
+DATA K256<>+0x110(SB)/8, $0x2e1b213827b70a85
+DATA K256<>+0x118(SB)/8, $0x53380d134d2c6dfc
+DATA K256<>+0x120(SB)/8, $0x766a0abb650a7354
+DATA K256<>+0x128(SB)/8, $0x92722c8581c2c92e
+DATA K256<>+0x130(SB)/8, $0x766a0abb650a7354
+DATA K256<>+0x138(SB)/8, $0x92722c8581c2c92e
+DATA K256<>+0x140(SB)/8, $0xa81a664ba2bfe8a1
+DATA K256<>+0x148(SB)/8, $0xc76c51a3c24b8b70
+DATA K256<>+0x150(SB)/8, $0xa81a664ba2bfe8a1
+DATA K256<>+0x158(SB)/8, $0xc76c51a3c24b8b70
+DATA K256<>+0x160(SB)/8, $0xd6990624d192e819
+DATA K256<>+0x168(SB)/8, $0x106aa070f40e3585
+DATA K256<>+0x170(SB)/8, $0xd6990624d192e819
+DATA K256<>+0x178(SB)/8, $0x106aa070f40e3585
+DATA K256<>+0x180(SB)/8, $0x1e376c0819a4c116
+DATA K256<>+0x188(SB)/8, $0x34b0bcb52748774c
+DATA K256<>+0x190(SB)/8, $0x1e376c0819a4c116
+DATA K256<>+0x198(SB)/8, $0x34b0bcb52748774c
+DATA K256<>+0x1a0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA K256<>+0x1a8(SB)/8, $0x682e6ff35b9cca4f
+DATA K256<>+0x1b0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA K256<>+0x1b8(SB)/8, $0x682e6ff35b9cca4f
+DATA K256<>+0x1c0(SB)/8, $0x78a5636f748f82ee
+DATA K256<>+0x1c8(SB)/8, $0x8cc7020884c87814
+DATA K256<>+0x1d0(SB)/8, $0x78a5636f748f82ee
+DATA K256<>+0x1d8(SB)/8, $0x8cc7020884c87814
+DATA K256<>+0x1e0(SB)/8, $0xa4506ceb90befffa
+DATA K256<>+0x1e8(SB)/8, $0xc67178f2bef9a3f7
+DATA K256<>+0x1f0(SB)/8, $0xa4506ceb90befffa
+DATA K256<>+0x1f8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA K256<>+0x200(SB)/8, $0x0405060700010203
+DATA K256<>+0x208(SB)/8, $0x0c0d0e0f08090a0b
+DATA K256<>+0x210(SB)/8, $0x0405060700010203
+DATA K256<>+0x218(SB)/8, $0x0c0d0e0f08090a0b
+DATA K256<>+0x220(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x228(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x230(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x238(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x240(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x248(SB)/8, $0x0b0a090803020100
+DATA K256<>+0x250(SB)/8, $0xffffffffffffffff
+DATA K256<>+0x258(SB)/8, $0x0b0a090803020100
+
+GLOBL K256<>(SB), 8, $608
+
+// func blockAvx2(h []uint32, message []uint8)
+TEXT ·blockAvx2(SB), 7, $0
+
+    MOVQ  ctx+0(FP), DI                        // DI: &h
+    MOVQ  inp+24(FP), SI                       // SI: &message
+    MOVQ  inplength+32(FP), DX                 // len(message)
+    ADDQ  SI, DX                               // end pointer of input
+    MOVQ  SP, R11                              // copy stack pointer
+    SUBQ  $0x220, SP                           // sp -= 0x220
+    ANDQ  $0xfffffffffffffc00, SP              // align stack frame
+    ADDQ  $0x1c0, SP
+    MOVQ DI, 0x40(SP)                          // save ctx
+    MOVQ SI, 0x48(SP)                          // save input
+    MOVQ DX, 0x50(SP)                          // save end pointer
+    MOVQ R11, 0x58(SP)                         // save copy of stack pointer
+
+    WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+    ADDQ $0x40, SI			                   // input++
+    MOVL (DI), AX
+    MOVQ SI, R12                               // borrow $T1
+    MOVL 4(DI), BX
+    CMPQ SI, DX                                // $_end
+    MOVL 8(DI), CX
+    LONG $0xe4440f4c                           // cmove  r12,rsp            /* next block or random data */
+    MOVL 12(DI), DX
+    MOVL 16(DI), R8
+    MOVL 20(DI), R9
+    MOVL 24(DI), R10
+    MOVL 28(DI), R11
+
+    LEAQ K256<>(SB), BP
+    LONG $0x856f7dc5; LONG $0x00000220         // VMOVDQA YMM8, 0x220[rbp]  /* vmovdqa ymm8,YMMWORD PTR [rip+0x220] */
+    LONG $0x8d6f7dc5; LONG $0x00000240         // VMOVDQA YMM9, 0x240[rbp]  /* vmovdqa ymm9,YMMWORD PTR [rip+0x240] */
+    LONG $0x956f7dc5; LONG $0x00000200         // VMOVDQA YMM10, 0x200[rbp] /* vmovdqa ymm7,YMMWORD PTR [rip+0x200] */
+
+loop0:
+    LONG $0x6f7dc1c4; BYTE $0xfa               // VMOVDQA YMM7, YMM10
+
+    // Load first 16 dwords from two blocks
+    MOVOU -64(SI), X0                          // vmovdqu xmm0,XMMWORD PTR [rsi-0x40]
+    MOVOU -48(SI), X1                          // vmovdqu xmm1,XMMWORD PTR [rsi-0x30]
+    MOVOU -32(SI), X2                          // vmovdqu xmm2,XMMWORD PTR [rsi-0x20]
+    MOVOU -16(SI), X3                          // vmovdqu xmm3,XMMWORD PTR [rsi-0x10]
+
+    // Byte swap data and transpose data into high/low
+    LONG $0x387dc3c4; WORD $0x2404; BYTE $0x01 // vinserti128 ymm0,ymm0,[r12],0x1
+    LONG $0x3875c3c4; LONG $0x0110244c         // vinserti128 ymm1,ymm1,0x10[r12],0x1
+    LONG $0x007de2c4; BYTE $0xc7               // vpshufb     ymm0,ymm0,ymm7
+    LONG $0x386dc3c4; LONG $0x01202454         // vinserti128 ymm2,ymm2,0x20[r12],0x1
+    LONG $0x0075e2c4; BYTE $0xcf               // vpshufb     ymm1,ymm1,ymm7
+    LONG $0x3865c3c4; LONG $0x0130245c         // vinserti128 ymm3,ymm3,0x30[r12],0x1
+
+    LEAQ K256<>(SB), BP
+    LONG $0x006de2c4; BYTE $0xd7               // vpshufb ymm2,ymm2,ymm7
+    LONG $0x65fefdc5; BYTE $0x00               // vpaddd  ymm4,ymm0,[rbp]
+    LONG $0x0065e2c4; BYTE $0xdf               // vpshufb ymm3,ymm3,ymm7
+    LONG $0x6dfef5c5; BYTE $0x20               // vpaddd  ymm5,ymm1,0x20[rbp]
+    LONG $0x75feedc5; BYTE $0x40               // vpaddd  ymm6,ymm2,0x40[rbp]
+    LONG $0x7dfee5c5; BYTE $0x60               // vpaddd  ymm7,ymm3,0x60[rbp]
+
+    LONG $0x247ffdc5; BYTE $0x24               // vmovdqa [rsp],ymm4
+    XORQ R14, R14
+    LONG $0x6c7ffdc5; WORD $0x2024             // vmovdqa [rsp+0x20],ymm5
+
+    ADDQ $-0x40, SP
+    MOVQ BX, DI
+    LONG $0x347ffdc5; BYTE $0x24               // vmovdqa [rsp],ymm6
+    XORQ CX, DI                                // magic
+    LONG $0x7c7ffdc5; WORD $0x2024             // vmovdqa [rsp+0x20],ymm7
+    MOVQ R9, R12
+    ADDQ $0x80,BP
+
+loop1:
+    // Schedule 48 input dwords, by doing 3 rounds of 12 each
+    // Note: SIMD instructions are interleaved with the SHA calculations
+    ADDQ $-0x40, SP
+    LONG $0x0f75e3c4; WORD $0x04e0 // vpalignr ymm4,ymm1,ymm0,0x4
+
+    // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
+    LONG $0x249c0344; LONG $0x00000080 // add    r11d,[rsp+0x80]
+    WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+    LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+    LONG $0x0f65e3c4; WORD $0x04fa // vpalignr ymm7,ymm3,ymm2,0x4
+    LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+    LONG $0x30048d42               // lea    eax,[rax+r14*1]            
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    LONG $0xd472cdc5; BYTE $0x07   // vpsrld ymm6,ymm4,0x7
+    LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+    LONG $0xc7fefdc5               // vpaddd ymm0,ymm0,ymm7
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+    LONG $0xd472c5c5; BYTE $0x03   // vpsrld ymm7,ymm4,0x3
+    LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+    LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+    WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+    LONG $0xf472d5c5; BYTE $0x0e   // vpslld ymm5,ymm4,0xe
+    LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+    LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+    LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+    LONG $0xe6efc5c5               // vpxor  ymm4,ymm7,ymm6
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xdf31                   // xor    edi,ebx
+    LONG $0xfb70fdc5; BYTE $0xfa   // vpshufd ymm7,ymm3,0xfa
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+    WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+    LONG $0xd672cdc5; BYTE $0x0b   // vpsrld ymm6,ymm6,0xb
+
+    // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
+    LONG $0x24940344; LONG $0x00000084 // add    r10d,[rsp+0x84]
+    WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+    LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+    LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    LONG $0xf572d5c5; BYTE $0x0b   // vpslld ymm5,ymm5,0xb
+    LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+    LONG $0xe6efddc5               // vpxor  ymm4,ymm4,ymm6
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+    LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+    WORD $0xc731                   // xor    edi,eax
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+    LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+    LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+    LONG $0xc4fefdc5               // vpaddd ymm0,ymm0,ymm4
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+    WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
+    LONG $0x248c0344; LONG $0x00000088 // add    r9d,[rsp+0x88]
+    WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+    LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+    LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+    LONG $0x004dc2c4; BYTE $0xf0   // vpshufb ymm6,ymm6,ymm8
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+    LONG $0xc6fefdc5               // vpaddd ymm0,ymm0,ymm6
+    LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+    LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+    WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+    LONG $0xf870fdc5; BYTE $0x50   // vpshufd ymm7,ymm0,0x50
+    LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+    LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+    LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+    WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
+    LONG $0x24840344; LONG $0x0000008c // add    r8d,[rsp+0x8c]
+    WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+    LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+    LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+    LONG $0x004dc2c4; BYTE $0xf1   // vpshufb ymm6,ymm6,ymm9
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+    LONG $0xc6fefdc5               // vpaddd ymm0,ymm0,ymm6
+    LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+    LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+    WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+    LONG $0x75fefdc5; BYTE $0x00   // vpaddd ymm6,ymm0,[rbp+0x0]
+    LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+    LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+    LONG $0x00048d42               // lea    eax,[rax+r8*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+    WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+    LONG $0x347ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm6
+    LONG $0x0f6de3c4; WORD $0x04e1 // vpalignr ymm4,ymm2,ymm1,0x4
+
+    // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
+    LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add    edx,[rsp+0xa0]
+    WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+    LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+    LONG $0x0f7de3c4; WORD $0x04fb // vpalignr ymm7,ymm0,ymm3,0x4
+    LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+    LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    LONG $0xd472cdc5; BYTE $0x07   // vpsrld ymm6,ymm4,0x7
+    LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+    LONG $0xcffef5c5               // vpaddd ymm1,ymm1,ymm7
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+    LONG $0xd472c5c5; BYTE $0x03   // vpsrld ymm7,ymm4,0x3
+    LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+    LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+    WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+    LONG $0xf472d5c5; BYTE $0x0e   // vpslld ymm5,ymm4,0xe
+    LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+    LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+    LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+    LONG $0xe6efc5c5               // vpxor  ymm4,ymm7,ymm6
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+    LONG $0xf870fdc5; BYTE $0xfa   // vpshufd ymm7,ymm0,0xfa
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+    WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+    LONG $0xd672cdc5; BYTE $0x0b   // vpsrld ymm6,ymm6,0xb
+
+    // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
+    LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add    ecx,[rsp+0xa4]
+    WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+    LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+    LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    LONG $0xf572d5c5; BYTE $0x0b   // vpslld ymm5,ymm5,0xb
+    LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+    LONG $0xe6efddc5               // vpxor  ymm4,ymm4,ymm6
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xd789                   // mov    edi,edx
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+    LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+    WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+    LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+    LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+    LONG $0xccfef5c5               // vpaddd ymm1,ymm1,ymm4
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+    WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
+    LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add    ebx,[rsp+0xa8]
+    WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+    LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+    LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+    LONG $0x004dc2c4; BYTE $0xf0   // vpshufb ymm6,ymm6,ymm8
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+    LONG $0xcefef5c5               // vpaddd ymm1,ymm1,ymm6
+    LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+    LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+    WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+    LONG $0xf970fdc5; BYTE $0x50   // vpshufd ymm7,ymm1,0x50
+    LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+    LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+    LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xd731                   // xor    edi,edx
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+    WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
+    LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add    eax,[rsp+0xac]
+    WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+    LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+    LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+    LONG $0x004dc2c4; BYTE $0xf1   // vpshufb ymm6,ymm6,ymm9
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xdf89                   // mov    edi,ebx
+    LONG $0xcefef5c5               // vpaddd ymm1,ymm1,ymm6
+    LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+    LONG $0x28048d42               // lea    eax,[rax+r13*1]
+    WORD $0xcf31                   // xor    edi,ecx
+    LONG $0x75fef5c5; BYTE $0x20   // vpaddd ymm6,ymm1,[rbp+0x20]
+    LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+    LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+    LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d42               // lea    eax,[rax+r15*1]
+    WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+    LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
+
+    LONG $0x24648d48; BYTE $0xc0   // lea    rsp,[rsp-0x40]
+    LONG $0x0f65e3c4; WORD $0x04e2 // vpalignr ymm4,ymm3,ymm2,0x4
+
+    // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x80)
+    LONG $0x249c0344; LONG $0x00000080 // add    r11d,[rsp+0x80]
+    WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+    LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+    LONG $0x0f75e3c4; WORD $0x04f8 // vpalignr ymm7,ymm1,ymm0,0x4
+    LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+    LONG $0x30048d42               // lea    eax,[rax+r14*1]
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    LONG $0xd472cdc5; BYTE $0x07   // vpsrld ymm6,ymm4,0x7
+    LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+    LONG $0xd7feedc5               // vpaddd ymm2,ymm2,ymm7
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+    LONG $0xd472c5c5; BYTE $0x03   // vpsrld ymm7,ymm4,0x3
+    LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+    LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+    WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+    LONG $0xf472d5c5; BYTE $0x0e   // vpslld ymm5,ymm4,0xe
+    LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+    LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+    LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+    LONG $0xe6efc5c5               // vpxor  ymm4,ymm7,ymm6
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xdf31                   // xor    edi,ebx
+    LONG $0xf970fdc5; BYTE $0xfa   // vpshufd ymm7,ymm1,0xfa
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+    WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+    LONG $0xd672cdc5; BYTE $0x0b   // vpsrld ymm6,ymm6,0xb
+
+    // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x84)
+    LONG $0x24940344; LONG $0x00000084 // add    r10d,[rsp+0x84]
+    WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+    LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+    LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    LONG $0xf572d5c5; BYTE $0x0b   // vpslld ymm5,ymm5,0xb
+    LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+    LONG $0xe6efddc5               // vpxor  ymm4,ymm4,ymm6
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+    LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+    WORD $0xc731                   // xor    edi,eax
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+    LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+    LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+    LONG $0xd4feedc5               // vpaddd ymm2,ymm2,ymm4
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+    WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x88)
+    LONG $0x248c0344; LONG $0x00000088 // add    r9d,[rsp+0x88]
+    WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+    LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+    LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+    LONG $0x004dc2c4; BYTE $0xf0   // vpshufb ymm6,ymm6,ymm8
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+    LONG $0xd6feedc5               // vpaddd ymm2,ymm2,ymm6
+    LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+    LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+    WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+    LONG $0xfa70fdc5; BYTE $0x50   // vpshufd ymm7,ymm2,0x50
+    LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+    LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+    LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+    WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x8c)
+    LONG $0x24840344; LONG $0x0000008c // add    r8d,[rsp+0x8c]
+    WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+    LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+    LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+    LONG $0x004dc2c4; BYTE $0xf1   // vpshufb ymm6,ymm6,ymm9
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+    LONG $0xd6feedc5               // vpaddd ymm2,ymm2,ymm6
+    LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+    LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+    WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+    LONG $0x75feedc5; BYTE $0x40   // vpaddd ymm6,ymm2,[rbp+0x40]
+    LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+    LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+    LONG $0x00048d42               // lea    eax,[rax+r8*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+    WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+    LONG $0x347ffdc5; BYTE $0x24 // vmovdqa [rsp],ymm6
+    LONG $0x0f7de3c4; WORD $0x04e3 // vpalignr ymm4,ymm0,ymm3,0x4
+
+    // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0xa0)
+    LONG $0xa0249403; WORD $0x0000; BYTE $0x00 // add    edx,[rsp+0xa0]
+    WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+    LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+    LONG $0x0f6de3c4; WORD $0x04f9 // vpalignr ymm7,ymm2,ymm1,0x4
+    LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+    LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    LONG $0xd472cdc5; BYTE $0x07   // vpsrld ymm6,ymm4,0x7
+    LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+    LONG $0xdffee5c5               // vpaddd ymm3,ymm3,ymm7
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+    LONG $0xd472c5c5; BYTE $0x03   // vpsrld ymm7,ymm4,0x3
+    LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+    LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+    WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+    LONG $0xf472d5c5; BYTE $0x0e   // vpslld ymm5,ymm4,0xe
+    LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+    LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+    LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+    LONG $0xe6efc5c5               // vpxor  ymm4,ymm7,ymm6
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+    LONG $0xfa70fdc5; BYTE $0xfa   // vpshufd ymm7,ymm2,0xfa
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+    WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+    LONG $0xd672cdc5; BYTE $0x0b   // vpsrld ymm6,ymm6,0xb
+
+    // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0xa4)
+    LONG $0xa4248c03; WORD $0x0000; BYTE $0x00 // add    ecx,[rsp+0xa4]
+    WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+    LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+    LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    LONG $0xf572d5c5; BYTE $0x0b   // vpslld ymm5,ymm5,0xb
+    LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+    LONG $0xe6efddc5               // vpxor  ymm4,ymm4,ymm6
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xd789                   // mov    edi,edx
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+    LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+    WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+    LONG $0xe5efddc5               // vpxor  ymm4,ymm4,ymm5
+    LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+    LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+    LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+    LONG $0xdcfee5c5               // vpaddd ymm3,ymm3,ymm4
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+    WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0xa8)
+    LONG $0xa8249c03; WORD $0x0000; BYTE $0x00 // add    ebx,[rsp+0xa8]
+    WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+    LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+    LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+    LONG $0x004dc2c4; BYTE $0xf0   // vpshufb ymm6,ymm6,ymm8
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+    LONG $0xdefee5c5               // vpaddd ymm3,ymm3,ymm6
+    LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+    LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+    WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+    LONG $0xfb70fdc5; BYTE $0x50   // vpshufd ymm7,ymm3,0x50
+    LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+    LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+    LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+    LONG $0xd772cdc5; BYTE $0x0a   // vpsrld ymm6,ymm7,0xa
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xd731                   // xor    edi,edx
+    LONG $0xd773c5c5; BYTE $0x11   // vpsrlq ymm7,ymm7,0x11
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+    WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+
+    // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0xac)
+    LONG $0xac248403; WORD $0x0000; BYTE $0x00 // add    eax,[rsp+0xac]
+    WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+    LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+    LONG $0xd773c5c5; BYTE $0x02   // vpsrlq ymm7,ymm7,0x2
+    LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+    LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    LONG $0xf7efcdc5               // vpxor  ymm6,ymm6,ymm7
+    LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+    LONG $0x004dc2c4; BYTE $0xf1   // vpshufb ymm6,ymm6,ymm9
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xdf89                   // mov    edi,ebx
+    LONG $0xdefee5c5               // vpaddd ymm3,ymm3,ymm6
+    LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+    LONG $0x28048d42               // lea    eax,[rax+r13*1]
+    WORD $0xcf31                   // xor    edi,ecx
+    LONG $0x75fee5c5; BYTE $0x60   // vpaddd ymm6,ymm3,[rbp+0x60]
+    LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+    LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+    LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d42               // lea    eax,[rax+r15*1]
+    WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+    LONG $0x747ffdc5; WORD $0x2024 // vmovdqa [rsp+0x20],ymm6
+    ADDQ $0x80, BP
+
+    CMPB 0x3(BP),$0x0
+    JNE  loop1
+
+    // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x40)
+    LONG $0x245c0344; BYTE $0x40   // add    r11d,[rsp+0x40]
+    WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+    LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+    LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+    LONG $0x30048d42               // lea    eax,[rax+r14*1]
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+    LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+    LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+    WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+    LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+    LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+    LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xdf31                   // xor    edi,ebx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+    WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+    // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x44)
+    LONG $0x24540344; BYTE $0x44   // add    r10d,[rsp+0x44]
+    WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+    LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+    LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+    LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+    LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+    WORD $0xc731                   // xor    edi,eax
+    LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+    LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+    LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+    WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+    // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x48)
+    LONG $0x244c0344; BYTE $0x48   // add    r9d,[rsp+0x48]
+    WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+    LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+    LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+    LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+    LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+    LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+    WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+    LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+    LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+    LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+    WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+    // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x4c)
+    LONG $0x24440344; BYTE $0x4c   // add    r8d,[rsp+0x4c]
+    WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+    LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+    LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+    LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+    LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+    WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+    LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+    LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+    LONG $0x00048d42               // lea    eax,[rax+r8*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+    WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+    // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x60)
+    LONG $0x60245403               // add    edx,[rsp+0x60]
+    WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+    LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+    LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+    LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+    LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+    LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+    WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+    LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+    LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+    LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+    WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+    // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x64)
+    LONG $0x64244c03               // add    ecx,[rsp+0x64]
+    WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+    LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+    LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xd789                   // mov    edi,edx
+    LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+    LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+    WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+    LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+    LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+    LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+    WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+    // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x68)
+    LONG $0x68245c03               // add    ebx,[rsp+0x68]
+    WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+    LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+    LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+    LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+    LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+    LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+    WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+    LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+    LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+    LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xd731                   // xor    edi,edx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+    WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+    // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x6c)
+    LONG $0x6c244403               // add    eax,[rsp+0x6c]
+    WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+    LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+    LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xdf89                   // mov    edi,ebx
+    LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+    LONG $0x28048d42               // lea    eax,[rax+r13*1]
+    WORD $0xcf31                   // xor    edi,ecx
+    LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+    LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+    LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d42               // lea    eax,[rax+r15*1]
+    WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+    // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, SP, 0x00)
+    LONG $0x241c0344               // add    r11d,[rsp]
+    WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+    LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+    LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+    LONG $0x30048d42               // lea    eax,[rax+r14*1]
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+    LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+    LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+    WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+    LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+    LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+    LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xdf31                   // xor    edi,ebx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+    WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+    // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, SP, 0x04)
+    LONG $0x24540344; BYTE $0x04   // add    r10d,[rsp+0x4]
+    WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+    LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+    LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+    LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+    LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+    WORD $0xc731                   // xor    edi,eax
+    LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+    LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+    LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+    WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+    // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, SP, 0x08)
+    LONG $0x244c0344; BYTE $0x08   // add    r9d,[rsp+0x8]
+    WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+    LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+    LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+    LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+    LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+    LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+    WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+    LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+    LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+    LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+    WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+    // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, SP, 0x0c)
+    LONG $0x24440344; BYTE $0x0c   // add    r8d,[rsp+0xc]
+    WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+    LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+    LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+    LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+    LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+    WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+    LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+    LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+    LONG $0x00048d42               // lea    eax,[rax+r8*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+    WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+    // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, SP, 0x20)
+    LONG $0x20245403               // add    edx,[rsp+0x20]
+    WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+    LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+    LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+    LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+    LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+    LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+    WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+    LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+    LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+    LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+    WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+    // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, SP, 0x24)
+    LONG $0x24244c03               // add    ecx,[rsp+0x24]
+    WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+    LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+    LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xd789                   // mov    edi,edx
+    LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+    LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+    WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+    LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+    LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+    LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+    WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+    // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, SP, 0x28)
+    LONG $0x28245c03               // add    ebx,[rsp+0x28]
+    WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+    LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+    LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+    LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+    LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+    LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+    WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+    LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+    LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+    LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xd731                   // xor    edi,edx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+    WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+    // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, SP, 0x2c)
+    LONG $0x2c244403               // add    eax,[rsp+0x2c]
+    WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+    LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+    LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xdf89                   // mov    edi,ebx
+    LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+    LONG $0x28048d42               // lea    eax,[rax+r13*1]
+    WORD $0xcf31                   // xor    edi,ecx
+    LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+    LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+    LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d42               // lea    eax,[rax+r15*1]
+    WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+    MOVQ 0x200(SP), DI             // $_ctx
+    ADDQ R14, AX
+
+    LEAQ 0x1c0(SP), BP
+
+    ADDL (DI), AX
+    ADDL 4(DI), BX
+    ADDL 8(DI), CX
+    ADDL 12(DI), DX
+    ADDL 16(DI), R8
+    ADDL 20(DI), R9
+    ADDL 24(DI), R10
+    ADDL 28(DI), R11
+
+    MOVL AX, (DI)
+    MOVL BX, 4(DI)
+    MOVL CX, 8(DI)
+    MOVL DX, 12(DI)
+    MOVL R8, 16(DI)
+    MOVL R9, 20(DI)
+    MOVL R10, 24(DI)
+    MOVL R11, 28(DI)
+
+    CMPQ SI, 0x50(BP)              // $_end
+    JE   done
+
+    XORQ R14, R14
+    MOVQ BX, DI
+    XORQ CX, DI                    // magic
+    MOVQ R9, R12
+
+loop2:
+    // ROUND(AX, BX, CX, DX, R8, R9, R10, R11, R12, R13, R14, R15, DI, BP, 0x10)
+    LONG $0x105d0344               // add    r11d,[rbp+0x10]
+    WORD $0x2145; BYTE $0xc4       // and    r12d,r8d
+    LONG $0xf07b43c4; WORD $0x19e8 // rorx   r13d,r8d,0x19
+    LONG $0xf07b43c4; WORD $0x0bf8 // rorx   r15d,r8d,0xb
+    LONG $0x30048d42               // lea    eax,[rax+r14*1]
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    LONG $0xf23842c4; BYTE $0xe2   // andn   r12d,r8d,r10d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f0 // rorx   r14d,r8d,0x6
+    LONG $0x231c8d47               // lea    r11d,[r11+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xc7       // mov    r15d,eax
+    LONG $0xf07b63c4; WORD $0x16e0 // rorx   r12d,eax,0x16
+    LONG $0x2b1c8d47               // lea    r11d,[r11+r13*1]
+    WORD $0x3141; BYTE $0xdf       // xor    r15d,ebx
+    LONG $0xf07b63c4; WORD $0x0df0 // rorx   r14d,eax,0xd
+    LONG $0xf07b63c4; WORD $0x02e8 // rorx   r13d,eax,0x2
+    LONG $0x1a148d42               // lea    edx,[rdx+r11*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xdf31                   // xor    edi,ebx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3b1c8d45               // lea    r11d,[r11+rdi*1]
+    WORD $0x8945; BYTE $0xc4       // mov    r12d,r8d
+
+    // ROUND(R11, AX, BX, CX, DX, R8, R9, R10, R12, R13, R14, DI, R15, BP, 0x14)
+    LONG $0x14550344               // add    r10d,[rbp+0x14]
+    WORD $0x2141; BYTE $0xd4       // and    r12d,edx
+    LONG $0xf07b63c4; WORD $0x19ea // rorx   r13d,edx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfa // rorx   edi,edx,0xb
+    LONG $0x331c8d47               // lea    r11d,[r11+r14*1]
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    LONG $0xf26842c4; BYTE $0xe1   // andn   r12d,edx,r9d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f2 // rorx   r14d,edx,0x6
+    LONG $0x22148d47               // lea    r10d,[r10+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xdf       // mov    edi,r11d
+    LONG $0xf07b43c4; WORD $0x16e3 // rorx   r12d,r11d,0x16
+    LONG $0x2a148d47               // lea    r10d,[r10+r13*1]
+    WORD $0xc731                   // xor    edi,eax
+    LONG $0xf07b43c4; WORD $0x0df3 // rorx   r14d,r11d,0xd
+    LONG $0xf07b43c4; WORD $0x02eb // rorx   r13d,r11d,0x2
+    LONG $0x110c8d42               // lea    ecx,[rcx+r10*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xc7       // xor    r15d,eax
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x3a148d47               // lea    r10d,[r10+r15*1]
+    WORD $0x8941; BYTE $0xd4       // mov    r12d,edx
+
+    // ROUND(R10, R11, AX, BX, CX, DX, R8, R9, R12, R13, R14, R15, DI, BP, 0x18)
+    LONG $0x184d0344               // add    r9d,[rbp+0x18]
+    WORD $0x2141; BYTE $0xcc       // and    r12d,ecx
+    LONG $0xf07b63c4; WORD $0x19e9 // rorx   r13d,ecx,0x19
+    LONG $0xf07b63c4; WORD $0x0bf9 // rorx   r15d,ecx,0xb
+    LONG $0x32148d47               // lea    r10d,[r10+r14*1]
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    LONG $0xf27042c4; BYTE $0xe0   // andn   r12d,ecx,r8d
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f1 // rorx   r14d,ecx,0x6
+    LONG $0x210c8d47               // lea    r9d,[r9+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xd7       // mov    r15d,r10d
+    LONG $0xf07b43c4; WORD $0x16e2 // rorx   r12d,r10d,0x16
+    LONG $0x290c8d47               // lea    r9d,[r9+r13*1]
+    WORD $0x3145; BYTE $0xdf       // xor    r15d,r11d
+    LONG $0xf07b43c4; WORD $0x0df2 // rorx   r14d,r10d,0xd
+    LONG $0xf07b43c4; WORD $0x02ea // rorx   r13d,r10d,0x2
+    LONG $0x0b1c8d42               // lea    ebx,[rbx+r9*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xdf       // xor    edi,r11d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d45               // lea    r9d,[r9+rdi*1]
+    WORD $0x8941; BYTE $0xcc       // mov    r12d,ecx
+
+    // ROUND(R9, R10, R11, AX, BX, CX, DX, R8, R12, R13, R14, DI, R15, BP, 0x1c)
+    LONG $0x1c450344               // add    r8d,[rbp+0x1c]
+    WORD $0x2141; BYTE $0xdc       // and    r12d,ebx
+    LONG $0xf07b63c4; WORD $0x19eb // rorx   r13d,ebx,0x19
+    LONG $0xf07be3c4; WORD $0x0bfb // rorx   edi,ebx,0xb
+    LONG $0x310c8d47               // lea    r9d,[r9+r14*1]
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    LONG $0xf26062c4; BYTE $0xe2   // andn   r12d,ebx,edx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b63c4; WORD $0x06f3 // rorx   r14d,ebx,0x6
+    LONG $0x20048d47               // lea    r8d,[r8+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8944; BYTE $0xcf       // mov    edi,r9d
+    LONG $0xf07b43c4; WORD $0x16e1 // rorx   r12d,r9d,0x16
+    LONG $0x28048d47               // lea    r8d,[r8+r13*1]
+    WORD $0x3144; BYTE $0xd7       // xor    edi,r10d
+    LONG $0xf07b43c4; WORD $0x0df1 // rorx   r14d,r9d,0xd
+    LONG $0xf07b43c4; WORD $0x02e9 // rorx   r13d,r9d,0x2
+    LONG $0x00048d42               // lea    eax,[rax+r8*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xd7       // xor    r15d,r10d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d47               // lea    r8d,[r8+r15*1]
+    WORD $0x8941; BYTE $0xdc       // mov    r12d,ebx
+
+    // ROUND(R8, R9, R10, R11, AX, BX, CX, DX, R12, R13, R14, R15, DI, BP, 0x30)
+    WORD $0x5503; BYTE $0x30       // add    edx,[rbp+0x30]
+    WORD $0x2141; BYTE $0xc4       // and    r12d,eax
+    LONG $0xf07b63c4; WORD $0x19e8 // rorx   r13d,eax,0x19
+    LONG $0xf07b63c4; WORD $0x0bf8 // rorx   r15d,eax,0xb
+    LONG $0x30048d47               // lea    r8d,[r8+r14*1]
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    LONG $0xf27862c4; BYTE $0xe1   // andn   r12d,eax,ecx
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b63c4; WORD $0x06f0 // rorx   r14d,eax,0x6
+    LONG $0x22148d42               // lea    edx,[rdx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8945; BYTE $0xc7       // mov    r15d,r8d
+    LONG $0xf07b43c4; WORD $0x16e0 // rorx   r12d,r8d,0x16
+    LONG $0x2a148d42               // lea    edx,[rdx+r13*1]
+    WORD $0x3145; BYTE $0xcf       // xor    r15d,r9d
+    LONG $0xf07b43c4; WORD $0x0df0 // rorx   r14d,r8d,0xd
+    LONG $0xf07b43c4; WORD $0x02e8 // rorx   r13d,r8d,0x2
+    LONG $0x131c8d45               // lea    r11d,[r11+rdx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3144; BYTE $0xcf       // xor    edi,r9d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x148d; BYTE $0x3a       // lea    edx,[rdx+rdi*1]
+    WORD $0x8941; BYTE $0xc4       // mov    r12d,eax
+
+    // ROUND(DX, R8, R9, R10, R11, AX, BX, CX, R12, R13, R14, DI, R15, BP, 0x34)
+    WORD $0x4d03; BYTE $0x34       // add    ecx,[rbp+0x34]
+    WORD $0x2145; BYTE $0xdc       // and    r12d,r11d
+    LONG $0xf07b43c4; WORD $0x19eb // rorx   r13d,r11d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bfb // rorx   edi,r11d,0xb
+    LONG $0x32148d42               // lea    edx,[rdx+r14*1]
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    LONG $0xf22062c4; BYTE $0xe3   // andn   r12d,r11d,ebx
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f3 // rorx   r14d,r11d,0x6
+    LONG $0x210c8d42               // lea    ecx,[rcx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xd789                   // mov    edi,edx
+    LONG $0xf07b63c4; WORD $0x16e2 // rorx   r12d,edx,0x16
+    LONG $0x290c8d42               // lea    ecx,[rcx+r13*1]
+    WORD $0x3144; BYTE $0xc7       // xor    edi,r8d
+    LONG $0xf07b63c4; WORD $0x0df2 // rorx   r14d,edx,0xd
+    LONG $0xf07b63c4; WORD $0x02ea // rorx   r13d,edx,0x2
+    LONG $0x0a148d45               // lea    r10d,[r10+rcx*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3145; BYTE $0xc7       // xor    r15d,r8d
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x390c8d42               // lea    ecx,[rcx+r15*1]
+    WORD $0x8945; BYTE $0xdc       // mov    r12d,r11d
+
+    // ROUND(CX, DX, R8, R9, R10, R11, AX, BX, R12, R13, R14, R15, DI, BP, 0x38)
+    WORD $0x5d03; BYTE $0x38       // add    ebx,[rbp+0x38]
+    WORD $0x2145; BYTE $0xd4       // and    r12d,r10d
+    LONG $0xf07b43c4; WORD $0x19ea // rorx   r13d,r10d,0x19
+    LONG $0xf07b43c4; WORD $0x0bfa // rorx   r15d,r10d,0xb
+    LONG $0x310c8d42               // lea    ecx,[rcx+r14*1]
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    LONG $0xf22862c4; BYTE $0xe0   // andn   r12d,r10d,eax
+    WORD $0x3145; BYTE $0xfd       // xor    r13d,r15d
+    LONG $0xf07b43c4; WORD $0x06f2 // rorx   r14d,r10d,0x6
+    LONG $0x231c8d42               // lea    ebx,[rbx+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0x8941; BYTE $0xcf       // mov    r15d,ecx
+    LONG $0xf07b63c4; WORD $0x16e1 // rorx   r12d,ecx,0x16
+    LONG $0x2b1c8d42               // lea    ebx,[rbx+r13*1]
+    WORD $0x3141; BYTE $0xd7       // xor    r15d,edx
+    LONG $0xf07b63c4; WORD $0x0df1 // rorx   r14d,ecx,0xd
+    LONG $0xf07b63c4; WORD $0x02e9 // rorx   r13d,ecx,0x2
+    LONG $0x190c8d45               // lea    r9d,[r9+rbx*1]
+    WORD $0x2144; BYTE $0xff       // and    edi,r15d
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0xd731                   // xor    edi,edx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    WORD $0x1c8d; BYTE $0x3b       // lea    ebx,[rbx+rdi*1]
+    WORD $0x8945; BYTE $0xd4       // mov    r12d,r10d
+
+    // ROUND(BX, CX, DX, R8, R9, R10, R11, AX, R12, R13, R14, DI, R15, BP, 0x3c)
+    WORD $0x4503; BYTE $0x3c       // add    eax,[rbp+0x3c]
+    WORD $0x2145; BYTE $0xcc       // and    r12d,r9d
+    LONG $0xf07b43c4; WORD $0x19e9 // rorx   r13d,r9d,0x19
+    LONG $0xf07bc3c4; WORD $0x0bf9 // rorx   edi,r9d,0xb
+    LONG $0x331c8d42               // lea    ebx,[rbx+r14*1]
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    LONG $0xf23042c4; BYTE $0xe3   // andn   r12d,r9d,r11d
+    WORD $0x3141; BYTE $0xfd       // xor    r13d,edi
+    LONG $0xf07b43c4; WORD $0x06f1 // rorx   r14d,r9d,0x6
+    LONG $0x20048d42               // lea    eax,[rax+r12*1]
+    WORD $0x3145; BYTE $0xf5       // xor    r13d,r14d
+    WORD $0xdf89                   // mov    edi,ebx
+    LONG $0xf07b63c4; WORD $0x16e3 // rorx   r12d,ebx,0x16
+    LONG $0x28048d42               // lea    eax,[rax+r13*1]
+    WORD $0xcf31                   // xor    edi,ecx
+    LONG $0xf07b63c4; WORD $0x0df3 // rorx   r14d,ebx,0xd
+    LONG $0xf07b63c4; WORD $0x02eb // rorx   r13d,ebx,0x2
+    LONG $0x00048d45               // lea    r8d,[r8+rax*1]
+    WORD $0x2141; BYTE $0xff       // and    r15d,edi
+    WORD $0x3145; BYTE $0xe6       // xor    r14d,r12d
+    WORD $0x3141; BYTE $0xcf       // xor    r15d,ecx
+    WORD $0x3145; BYTE $0xee       // xor    r14d,r13d
+    LONG $0x38048d42               // lea    eax,[rax+r15*1]
+    WORD $0x8945; BYTE $0xcc       // mov    r12d,r9d
+
+    ADDQ $-0x40, BP
+    CMPQ BP, SP
+    JAE  loop2
+
+    MOVQ 0x200(SP), DI             // $_ctx
+    ADDQ R14, AX
+
+    ADDQ $0x1c0, SP
+
+    ADDL (DI), AX
+    ADDL 4(DI), BX
+    ADDL 8(DI), CX
+    ADDL 12(DI), DX
+    ADDL 16(DI), R8
+    ADDL 20(DI), R9
+
+    ADDQ $0x80, SI                 // input += 2
+    ADDL 24(DI), R10
+    MOVQ SI, R12
+    ADDL 28(DI), R11
+    CMPQ  SI, 0x50(SP)             // input == _end
+
+    MOVL AX, (DI)
+    LONG $0xe4440f4c               // cmove  r12,rsp                /* next block or stale data */
+    MOVL AX, (DI)
+    MOVL BX, 4(DI)
+    MOVL CX, 8(DI)
+    MOVL DX, 12(DI)
+    MOVL R8, 16(DI)
+    MOVL R9, 20(DI)
+    MOVL R10, 24(DI)
+    MOVL R11, 28(DI)
+
+    JBE loop0
+    LEAQ (SP), BP
+
+done:
+    MOVQ BP, SP
+    MOVQ 0x58(SP), SP
+    WORD $0xf8c5; BYTE $0x77     // vzeroupper
+
+    RET
+
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
new file mode 100644
index 000000000..1bf45fd45
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
@@ -0,0 +1,497 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2017 Minio, Inc.
+ *
+ * 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 sha256
+
+import (
+	"encoding/binary"
+	"errors"
+	"hash"
+	"sort"
+	"sync/atomic"
+	"time"
+)
+
+//go:noescape
+func sha256_x16_avx512(digests *[512]byte, scratch *[512]byte, table *[512]uint64, mask []uint64, inputs [16][]byte)
+
+// Do not start at 0 but next multiple of 16 so as to be able to
+// differentiate with default initialiation value of 0
+const Avx512ServerUid = 16
+
+var uidCounter uint64
+
+func NewAvx512(a512srv *Avx512Server) hash.Hash {
+	uid := atomic.AddUint64(&uidCounter, 1)
+	return &Avx512Digest{uid: uid, a512srv: a512srv}
+}
+
+// Type for computing SHA256 using AVX51
+type Avx512Digest struct {
+	uid     uint64
+	a512srv *Avx512Server
+	x       [chunk]byte
+	nx      int
+	len     uint64
+	final   bool
+	result  [Size]byte
+}
+
+// Return size of checksum
+func (d *Avx512Digest) Size() int { return Size }
+
+// Return blocksize of checksum
+func (d Avx512Digest) BlockSize() int { return BlockSize }
+
+func (d *Avx512Digest) Reset() {
+	d.a512srv.blocksCh <- blockInput{uid: d.uid, reset: true}
+	d.nx = 0
+	d.len = 0
+	d.final = false
+}
+
+// Write to digest
+func (d *Avx512Digest) Write(p []byte) (nn int, err error) {
+
+	if d.final {
+		return 0, errors.New("Avx512Digest already finalized. Reset first before writing again.")
+	}
+
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: d.x[:]}
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: p[:n]}
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+// Return sha256 sum in bytes
+func (d *Avx512Digest) Sum(in []byte) (result []byte) {
+
+	if d.final {
+		return append(in, d.result[:]...)
+	}
+
+	trail := make([]byte, 0, 128)
+
+	len := d.len
+	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+	var tmp [64]byte
+	tmp[0] = 0x80
+	if len%64 < 56 {
+		trail = append(d.x[:d.nx], tmp[0:56-len%64]...)
+	} else {
+		trail = append(d.x[:d.nx], tmp[0:64+56-len%64]...)
+	}
+	d.nx = 0
+
+	// Length in bits.
+	len <<= 3
+	for i := uint(0); i < 8; i++ {
+		tmp[i] = byte(len >> (56 - 8*i))
+	}
+	trail = append(trail, tmp[0:8]...)
+
+	sumCh := make(chan [Size]byte)
+	d.a512srv.blocksCh <- blockInput{uid: d.uid, msg: trail, final: true, sumCh: sumCh}
+	d.result = <-sumCh
+	d.final = true
+	return append(in, d.result[:]...)
+}
+
+var table = [512]uint64{
+	0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+	0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98, 0x428a2f98428a2f98,
+	0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+	0x7137449171374491, 0x7137449171374491, 0x7137449171374491, 0x7137449171374491,
+	0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+	0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf, 0xb5c0fbcfb5c0fbcf,
+	0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+	0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5, 0xe9b5dba5e9b5dba5,
+	0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+	0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b, 0x3956c25b3956c25b,
+	0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+	0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1, 0x59f111f159f111f1,
+	0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+	0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4, 0x923f82a4923f82a4,
+	0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+	0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5, 0xab1c5ed5ab1c5ed5,
+	0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+	0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98, 0xd807aa98d807aa98,
+	0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+	0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01, 0x12835b0112835b01,
+	0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+	0x243185be243185be, 0x243185be243185be, 0x243185be243185be, 0x243185be243185be,
+	0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+	0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3, 0x550c7dc3550c7dc3,
+	0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+	0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74, 0x72be5d7472be5d74,
+	0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+	0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe, 0x80deb1fe80deb1fe,
+	0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+	0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7, 0x9bdc06a79bdc06a7,
+	0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+	0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174, 0xc19bf174c19bf174,
+	0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+	0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1, 0xe49b69c1e49b69c1,
+	0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+	0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786, 0xefbe4786efbe4786,
+	0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+	0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6, 0x0fc19dc60fc19dc6,
+	0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+	0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc, 0x240ca1cc240ca1cc,
+	0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+	0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f, 0x2de92c6f2de92c6f,
+	0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+	0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa, 0x4a7484aa4a7484aa,
+	0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+	0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc, 0x5cb0a9dc5cb0a9dc,
+	0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+	0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da, 0x76f988da76f988da,
+	0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+	0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152, 0x983e5152983e5152,
+	0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+	0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d, 0xa831c66da831c66d,
+	0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+	0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8, 0xb00327c8b00327c8,
+	0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+	0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7, 0xbf597fc7bf597fc7,
+	0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+	0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3, 0xc6e00bf3c6e00bf3,
+	0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+	0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147, 0xd5a79147d5a79147,
+	0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+	0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351, 0x06ca635106ca6351,
+	0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+	0x1429296714292967, 0x1429296714292967, 0x1429296714292967, 0x1429296714292967,
+	0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+	0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85, 0x27b70a8527b70a85,
+	0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+	0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138, 0x2e1b21382e1b2138,
+	0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+	0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc, 0x4d2c6dfc4d2c6dfc,
+	0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+	0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13, 0x53380d1353380d13,
+	0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+	0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354, 0x650a7354650a7354,
+	0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+	0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb, 0x766a0abb766a0abb,
+	0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+	0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e, 0x81c2c92e81c2c92e,
+	0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+	0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85, 0x92722c8592722c85,
+	0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+	0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1, 0xa2bfe8a1a2bfe8a1,
+	0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+	0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b, 0xa81a664ba81a664b,
+	0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+	0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70, 0xc24b8b70c24b8b70,
+	0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+	0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3, 0xc76c51a3c76c51a3,
+	0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+	0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819, 0xd192e819d192e819,
+	0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+	0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624, 0xd6990624d6990624,
+	0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+	0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585, 0xf40e3585f40e3585,
+	0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+	0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070, 0x106aa070106aa070,
+	0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+	0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116, 0x19a4c11619a4c116,
+	0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+	0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08, 0x1e376c081e376c08,
+	0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+	0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c, 0x2748774c2748774c,
+	0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+	0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5, 0x34b0bcb534b0bcb5,
+	0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+	0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3, 0x391c0cb3391c0cb3,
+	0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+	0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a, 0x4ed8aa4a4ed8aa4a,
+	0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+	0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f, 0x5b9cca4f5b9cca4f,
+	0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+	0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3, 0x682e6ff3682e6ff3,
+	0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+	0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee, 0x748f82ee748f82ee,
+	0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+	0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f, 0x78a5636f78a5636f,
+	0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+	0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814, 0x84c8781484c87814,
+	0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+	0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208, 0x8cc702088cc70208,
+	0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+	0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa, 0x90befffa90befffa,
+	0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+	0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb, 0xa4506ceba4506ceb,
+	0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+	0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7, 0xbef9a3f7bef9a3f7,
+	0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2,
+	0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2, 0xc67178f2c67178f2}
+
+// Interface function to assembly ode
+func blockAvx512(digests *[512]byte, input [16][]byte, mask []uint64) [16][Size]byte {
+
+	scratch := [512]byte{}
+	sha256_x16_avx512(digests, &scratch, &table, mask, input)
+
+	output := [16][Size]byte{}
+	for i := 0; i < 16; i++ {
+		output[i] = getDigest(i, digests[:])
+	}
+
+	return output
+}
+
+func getDigest(index int, state []byte) (sum [Size]byte) {
+	for j := 0; j < 16; j += 2 {
+		for i := index*4 + j*Size; i < index*4+(j+1)*Size; i += Size {
+			binary.BigEndian.PutUint32(sum[j*2:], binary.LittleEndian.Uint32(state[i:i+4]))
+		}
+	}
+	return
+}
+
+// Message to send across input channel
+type blockInput struct {
+	uid   uint64
+	msg   []byte
+	reset bool
+	final bool
+	sumCh chan [Size]byte
+}
+
+// Type to implement 16x parallel handling of SHA256 invocations
+type Avx512Server struct {
+	blocksCh chan blockInput       // Input channel
+	totalIn  int                   // Total number of inputs waiting to be processed
+	lanes    [16]Avx512LaneInfo    // Array with info per lane (out of 16)
+	digests  map[uint64][Size]byte // Map of uids to (interim) digest results
+}
+
+// Info for each lane
+type Avx512LaneInfo struct {
+	uid      uint64          // unique identification for this SHA processing
+	block    []byte          // input block to be processed
+	outputCh chan [Size]byte // channel for output result
+}
+
+// Create new object for parallel processing handling
+func NewAvx512Server() *Avx512Server {
+	a512srv := &Avx512Server{}
+	a512srv.digests = make(map[uint64][Size]byte)
+	a512srv.blocksCh = make(chan blockInput)
+
+	// Start a single thread for reading from the input channel
+	go a512srv.Process()
+	return a512srv
+}
+
+// Sole handler for reading from the input channel
+func (a512srv *Avx512Server) Process() {
+	for {
+		select {
+		case block := <-a512srv.blocksCh:
+			if block.reset {
+				a512srv.reset(block.uid)
+				continue
+			}
+			index := block.uid & 0xf
+			// fmt.Println("Adding message:", block.uid, index)
+
+			if a512srv.lanes[index].block != nil { // If slot is already filled, process all inputs
+				//fmt.Println("Invoking Blocks()")
+				a512srv.blocks()
+			}
+			a512srv.totalIn++
+			a512srv.lanes[index] = Avx512LaneInfo{uid: block.uid, block: block.msg}
+			if block.final {
+				a512srv.lanes[index].outputCh = block.sumCh
+			}
+			if a512srv.totalIn == len(a512srv.lanes) {
+				// fmt.Println("Invoking Blocks() while FULL: ")
+				a512srv.blocks()
+			}
+
+			// TODO: test with larger timeout
+		case <-time.After(1 * time.Microsecond):
+			for _, lane := range a512srv.lanes {
+				if lane.block != nil { // check if there is any input to process
+					// fmt.Println("Invoking Blocks() on TIMEOUT: ")
+					a512srv.blocks()
+					break // we are done
+				}
+			}
+		}
+	}
+}
+
+// Do a reset for this calculation
+func (a512srv *Avx512Server) reset(uid uint64) {
+
+	// Check if there is a message still waiting to be processed (and remove if so)
+	for i, lane := range a512srv.lanes {
+		if lane.uid == uid {
+			if lane.block != nil {
+				a512srv.lanes[i] = Avx512LaneInfo{} // clear message
+				a512srv.totalIn -= 1
+			}
+		}
+	}
+
+	// Delete entry from hash map
+	delete(a512srv.digests, uid)
+}
+
+// Invoke assembly and send results back
+func (a512srv *Avx512Server) blocks() (err error) {
+
+	inputs := [16][]byte{}
+	for i := range inputs {
+		inputs[i] = a512srv.lanes[i].block
+	}
+
+	mask := expandMask(genMask(inputs))
+	outputs := blockAvx512(a512srv.getDigests(), inputs, mask)
+
+	a512srv.totalIn = 0
+	for i := 0; i < len(outputs); i++ {
+		uid, outputCh := a512srv.lanes[i].uid, a512srv.lanes[i].outputCh
+		a512srv.digests[uid] = outputs[i]
+		a512srv.lanes[i] = Avx512LaneInfo{}
+
+		if outputCh != nil {
+			// Send back result
+			outputCh <- outputs[i]
+			delete(a512srv.digests, uid) // Delete entry from hashmap
+		}
+	}
+	return
+}
+
+func (a512srv *Avx512Server) Write(uid uint64, p []byte) (nn int, err error) {
+	a512srv.blocksCh <- blockInput{uid: uid, msg: p}
+	return len(p), nil
+}
+
+func (a512srv *Avx512Server) Sum(uid uint64, p []byte) [32]byte {
+	sumCh := make(chan [32]byte)
+	a512srv.blocksCh <- blockInput{uid: uid, msg: p, final: true, sumCh: sumCh}
+	return <-sumCh
+}
+
+func (a512srv *Avx512Server) getDigests() *[512]byte {
+	digests := [512]byte{}
+	for i, lane := range a512srv.lanes {
+		a, ok := a512srv.digests[lane.uid]
+		if ok {
+			binary.BigEndian.PutUint32(digests[(i+0*16)*4:], binary.LittleEndian.Uint32(a[0:4]))
+			binary.BigEndian.PutUint32(digests[(i+1*16)*4:], binary.LittleEndian.Uint32(a[4:8]))
+			binary.BigEndian.PutUint32(digests[(i+2*16)*4:], binary.LittleEndian.Uint32(a[8:12]))
+			binary.BigEndian.PutUint32(digests[(i+3*16)*4:], binary.LittleEndian.Uint32(a[12:16]))
+			binary.BigEndian.PutUint32(digests[(i+4*16)*4:], binary.LittleEndian.Uint32(a[16:20]))
+			binary.BigEndian.PutUint32(digests[(i+5*16)*4:], binary.LittleEndian.Uint32(a[20:24]))
+			binary.BigEndian.PutUint32(digests[(i+6*16)*4:], binary.LittleEndian.Uint32(a[24:28]))
+			binary.BigEndian.PutUint32(digests[(i+7*16)*4:], binary.LittleEndian.Uint32(a[28:32]))
+		} else {
+			binary.LittleEndian.PutUint32(digests[(i+0*16)*4:], init0)
+			binary.LittleEndian.PutUint32(digests[(i+1*16)*4:], init1)
+			binary.LittleEndian.PutUint32(digests[(i+2*16)*4:], init2)
+			binary.LittleEndian.PutUint32(digests[(i+3*16)*4:], init3)
+			binary.LittleEndian.PutUint32(digests[(i+4*16)*4:], init4)
+			binary.LittleEndian.PutUint32(digests[(i+5*16)*4:], init5)
+			binary.LittleEndian.PutUint32(digests[(i+6*16)*4:], init6)
+			binary.LittleEndian.PutUint32(digests[(i+7*16)*4:], init7)
+		}
+	}
+	return &digests
+}
+
+// Helper struct for sorting blocks based on length
+type lane struct {
+	len uint
+	pos uint
+}
+
+type lanes []lane
+
+func (lns lanes) Len() int           { return len(lns) }
+func (lns lanes) Swap(i, j int)      { lns[i], lns[j] = lns[j], lns[i] }
+func (lns lanes) Less(i, j int) bool { return lns[i].len < lns[j].len }
+
+// Helper struct for
+type maskRounds struct {
+	mask   uint64
+	rounds uint64
+}
+
+func genMask(input [16][]byte) [16]maskRounds {
+
+	// Sort on blocks length small to large
+	var sorted [16]lane
+	for c, inpt := range input {
+		sorted[c] = lane{uint(len(inpt)), uint(c)}
+	}
+	sort.Sort(lanes(sorted[:]))
+
+	// Create mask array including 'rounds' between masks
+	m, round, index := uint64(0xffff), uint64(0), 0
+	var mr [16]maskRounds
+	for _, s := range sorted {
+		if s.len > 0 {
+			if uint64(s.len)>>6 > round {
+				mr[index] = maskRounds{m, (uint64(s.len) >> 6) - round}
+				index++
+			}
+			round = uint64(s.len) >> 6
+		}
+		m = m & ^(1 << uint(s.pos))
+	}
+
+	return mr
+}
+
+// TODO: remove function
+func expandMask(mr [16]maskRounds) []uint64 {
+	size := uint64(0)
+	for _, r := range mr {
+		size += r.rounds
+	}
+	result, index := make([]uint64, size), 0
+	for _, r := range mr {
+		for j := uint64(0); j < r.rounds; j++ {
+			result[index] = r.mask
+			index++
+		}
+	}
+	return result
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
new file mode 100644
index 000000000..a6733f986
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
@@ -0,0 +1,231 @@
+TEXT ·sha256_x16_avx512(SB), 7, $0
+	MOVQ digests+0(FP), DI
+	MOVQ scratch+8(FP), R12
+	MOVQ mask_len+32(FP), SI
+	MOVQ r14+24(FP), R13
+	MOVQ (R13), R14
+	LONG $0x92fbc1c4; BYTE $0xce
+	LEAQ inputs+48(FP), AX
+	QUAD $0xf162076f487ef162; QUAD $0x7ef162014f6f487e; QUAD $0x487ef16202576f48; QUAD $0x6f487ef162035f6f; QUAD $0x6f6f487ef1620467; QUAD $0x06776f487ef16205; LONG $0x487ef162; WORD $0x7f6f; BYTE $0x07
+	MOVQ table+16(FP), DX
+	WORD $0x3148; BYTE $0xc9
+	TESTQ $(1<<0), R14
+	JE skipInput0
+	MOVQ 0*24(AX), R9
+	LONG $0x487cc162; WORD $0x0410; BYTE $0x09
+skipInput0:
+	TESTQ $(1<<1), R14
+	JE skipInput1
+	MOVQ 1*24(AX), R9
+	LONG $0x487cc162; WORD $0x0c10; BYTE $0x09
+skipInput1:
+	TESTQ $(1<<2), R14
+	JE skipInput2
+	MOVQ 2*24(AX), R9
+	LONG $0x487cc162; WORD $0x1410; BYTE $0x09
+skipInput2:
+	TESTQ $(1<<3), R14
+	JE skipInput3
+	MOVQ 3*24(AX), R9
+	LONG $0x487cc162; WORD $0x1c10; BYTE $0x09
+skipInput3:
+	TESTQ $(1<<4), R14
+	JE skipInput4
+	MOVQ 4*24(AX), R9
+	LONG $0x487cc162; WORD $0x2410; BYTE $0x09
+skipInput4:
+	TESTQ $(1<<5), R14
+	JE skipInput5
+	MOVQ 5*24(AX), R9
+	LONG $0x487cc162; WORD $0x2c10; BYTE $0x09
+skipInput5:
+	TESTQ $(1<<6), R14
+	JE skipInput6
+	MOVQ 6*24(AX), R9
+	LONG $0x487cc162; WORD $0x3410; BYTE $0x09
+skipInput6:
+	TESTQ $(1<<7), R14
+	JE skipInput7
+	MOVQ 7*24(AX), R9
+	LONG $0x487cc162; WORD $0x3c10; BYTE $0x09
+skipInput7:
+	TESTQ $(1<<8), R14
+	JE skipInput8
+	MOVQ 8*24(AX), R9
+	LONG $0x487c4162; WORD $0x0410; BYTE $0x09
+skipInput8:
+	TESTQ $(1<<9), R14
+	JE skipInput9
+	MOVQ 9*24(AX), R9
+	LONG $0x487c4162; WORD $0x0c10; BYTE $0x09
+skipInput9:
+	TESTQ $(1<<10), R14
+	JE skipInput10
+	MOVQ 10*24(AX), R9
+	LONG $0x487c4162; WORD $0x1410; BYTE $0x09
+skipInput10:
+	TESTQ $(1<<11), R14
+	JE skipInput11
+	MOVQ 11*24(AX), R9
+	LONG $0x487c4162; WORD $0x1c10; BYTE $0x09
+skipInput11:
+	TESTQ $(1<<12), R14
+	JE skipInput12
+	MOVQ 12*24(AX), R9
+	LONG $0x487c4162; WORD $0x2410; BYTE $0x09
+skipInput12:
+	TESTQ $(1<<13), R14
+	JE skipInput13
+	MOVQ 13*24(AX), R9
+	LONG $0x487c4162; WORD $0x2c10; BYTE $0x09
+skipInput13:
+	TESTQ $(1<<14), R14
+	JE skipInput14
+	MOVQ 14*24(AX), R9
+	LONG $0x487c4162; WORD $0x3410; BYTE $0x09
+skipInput14:
+	TESTQ $(1<<15), R14
+	JE skipInput15
+	MOVQ 15*24(AX), R9
+	LONG $0x487c4162; WORD $0x3c10; BYTE $0x09
+skipInput15:
+lloop:
+	LEAQ PSHUFFLE_BYTE_FLIP_MASK<>(SB), DX
+	LONG $0x487e7162; WORD $0x1a6f
+	MOVQ table+16(FP), DX
+	QUAD $0xd162226f487e7162; QUAD $0x7ed16224047f487e; QUAD $0x7ed16201244c7f48; QUAD $0x7ed1620224547f48; QUAD $0x7ed16203245c7f48; QUAD $0x7ed1620424647f48; QUAD $0x7ed16205246c7f48; QUAD $0x7ed1620624747f48; QUAD $0xc1834807247c7f48; QUAD $0x44c9c6407c316240; QUAD $0x62eec1c6407ca162; QUAD $0xa16244d3c6406c31; QUAD $0x34c162eed3c6406c; QUAD $0x407ca162dddac648; QUAD $0xc6407ca16288cac6; QUAD $0xcac648345162ddc2; QUAD $0x44d5c6405ca16288; QUAD $0x62eee5c6405ca162; QUAD $0xa16244d7c6404c31; QUAD $0x6cc162eef7c6404c; QUAD $0x405ca162ddfac640; QUAD $0xc6405ca16288eec6; QUAD $0xd2c6406cc162dde6; QUAD $0x44f1c6403c816288; QUAD $0x62eec1c6403c0162; QUAD $0x016244d3c6402c11; QUAD $0x4c4162eed3c6402c; QUAD $0x403c0162dddac640; QUAD $0xc6403c016288cac6; QUAD $0xf2c6404cc162ddc2; QUAD $0x44d5c6401c016288; QUAD $0x62eee5c6401c0162; QUAD $0x016244d7c6400c11; QUAD $0x2c4162eef7c6400c; QUAD $0x401c0162ddfac640; QUAD $0xc6401c016288eec6; QUAD $0xd2c6402c4162dde6; BYTE $0x88
+	LEAQ PSHUFFLE_TRANSPOSE16_MASK1<>(SB), BX
+	LEAQ PSHUFFLE_TRANSPOSE16_MASK2<>(SB), R8
+	QUAD $0x2262336f487e6162; QUAD $0x487e5162f27648b5; QUAD $0xd27648b53262106f; QUAD $0xa262136f487ee162; QUAD $0x487e5162d77640e5; QUAD $0xcf7640e53262086f; QUAD $0xa2621b6f487ee162; QUAD $0x487ec162dd7640f5; QUAD $0xfd7640f5a262386f; QUAD $0xa2620b6f487ee162; QUAD $0x487ec162cc7640fd; QUAD $0xec7640fda262286f; QUAD $0x8262036f487ee162; QUAD $0x487ec162c27640cd; QUAD $0xe27640cd8262206f; QUAD $0x8262336f487ee162; QUAD $0x487e4162f77640a5; QUAD $0xd77640a50262106f; QUAD $0x02621b6f487e6162; QUAD $0x487e4162dd7640b5; QUAD $0xfd7640b50262386f; QUAD $0x02620b6f487e6162; QUAD $0x487e4162cc7640bd; QUAD $0xec7640bd0262286f; QUAD $0x62eec023408d2362; QUAD $0x236244c023408da3; QUAD $0xada362eee42348ad; QUAD $0x40c5036244e42348; QUAD $0x2340c51362eef723; QUAD $0xfd2340d5036244d7; QUAD $0x44fd2340d58362ee; QUAD $0x62eeea2348b50362; QUAD $0x036244ea2348b583; QUAD $0xe51362eed32340e5; QUAD $0x40f5036244cb2340; QUAD $0x2340f58362eed923; QUAD $0xce2340ed236244d9; QUAD $0x44ce2340eda362ee; QUAD $0xc162d16f487ec162; QUAD $0x407dc262f26f487e; QUAD $0xcb004075c262c300; QUAD $0xc262d300406dc262; QUAD $0x405dc262db004065; QUAD $0xeb004055c262e300; QUAD $0xc262f300404dc262; QUAD $0x403d4262fb004045; QUAD $0xcb0040354262c300; QUAD $0x4262d300402d4262; QUAD $0x401d4262db004025; QUAD $0xeb0040154262e300; QUAD $0x4262f300400d4262; QUAD $0x48455162fb004005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6201626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916202626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16203; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16204626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16205626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x06626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16207626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1620862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6209626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1620a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591620b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91620c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591620d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x0e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591620f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591621062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6211626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916212626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16213; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16214626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16215626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x16626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16217626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1621862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6219626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1621a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591621b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91621c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591621d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x1e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591621f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591622062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6221626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916222626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16223; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16224626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16225626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x26626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16227626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1622862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6229626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1622a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591622b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91622c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591622d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x2e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591622f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591623062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x01ee8348fdfe4005
+	JE lastLoop
+	ADDQ $8, R13
+	MOVQ (R13), R14
+	QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x31
+	TESTQ $(1<<0), R14
+	JE skipNext0
+	MOVQ 0*24(AX), R9
+	LONG $0x487cc162; WORD $0x0410; BYTE $0x09
+skipNext0:
+	QUAD $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x32
+	TESTQ $(1<<1), R14
+	JE skipNext1
+	MOVQ 1*24(AX), R9
+	LONG $0x487cc162; WORD $0x0c10; BYTE $0x09
+skipNext1:
+	QUAD $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x33
+	TESTQ $(1<<2), R14
+	JE skipNext2
+	MOVQ 2*24(AX), R9
+	LONG $0x487cc162; WORD $0x1410; BYTE $0x09
+skipNext2:
+	QUAD $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x34
+	TESTQ $(1<<3), R14
+	JE skipNext3
+	MOVQ 3*24(AX), R9
+	LONG $0x487cc162; WORD $0x1c10; BYTE $0x09
+skipNext3:
+	QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x35
+	TESTQ $(1<<4), R14
+	JE skipNext4
+	MOVQ 4*24(AX), R9
+	LONG $0x487cc162; WORD $0x2410; BYTE $0x09
+skipNext4:
+	QUAD $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x36
+	TESTQ $(1<<5), R14
+	JE skipNext5
+	MOVQ 5*24(AX), R9
+	LONG $0x487cc162; WORD $0x2c10; BYTE $0x09
+skipNext5:
+	QUAD $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x37
+	TESTQ $(1<<6), R14
+	JE skipNext6
+	MOVQ 6*24(AX), R9
+	LONG $0x487cc162; WORD $0x3410; BYTE $0x09
+skipNext6:
+	QUAD $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x38
+	TESTQ $(1<<7), R14
+	JE skipNext7
+	MOVQ 7*24(AX), R9
+	LONG $0x487cc162; WORD $0x3c10; BYTE $0x09
+skipNext7:
+	QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x39
+	TESTQ $(1<<8), R14
+	JE skipNext8
+	MOVQ 8*24(AX), R9
+	LONG $0x487c4162; WORD $0x0410; BYTE $0x09
+skipNext8:
+	QUAD $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x3a
+	TESTQ $(1<<9), R14
+	JE skipNext9
+	MOVQ 9*24(AX), R9
+	LONG $0x487c4162; WORD $0x0c10; BYTE $0x09
+skipNext9:
+	QUAD $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x3b
+	TESTQ $(1<<10), R14
+	JE skipNext10
+	MOVQ 10*24(AX), R9
+	LONG $0x487c4162; WORD $0x1410; BYTE $0x09
+skipNext10:
+	QUAD $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x3c
+	TESTQ $(1<<11), R14
+	JE skipNext11
+	MOVQ 11*24(AX), R9
+	LONG $0x487c4162; WORD $0x1c10; BYTE $0x09
+skipNext11:
+	QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x3d
+	TESTQ $(1<<12), R14
+	JE skipNext12
+	MOVQ 12*24(AX), R9
+	LONG $0x487c4162; WORD $0x2410; BYTE $0x09
+skipNext12:
+	QUAD $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x3e
+	TESTQ $(1<<13), R14
+	JE skipNext13
+	MOVQ 13*24(AX), R9
+	LONG $0x487c4162; WORD $0x2c10; BYTE $0x09
+skipNext13:
+	QUAD $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x3f
+	TESTQ $(1<<14), R14
+	JE skipNext14
+	MOVQ 14*24(AX), R9
+	LONG $0x487c4162; WORD $0x3410; BYTE $0x09
+skipNext14:
+	QUAD $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x40
+	TESTQ $(1<<15), R14
+	JE skipNext15
+	MOVQ 15*24(AX), R9
+	LONG $0x487c4162; WORD $0x3c10; BYTE $0x09
+skipNext15:
+	QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0xc4fbfe4945d16207; LONG $0xce92fbc1
+	JMP lloop
+lastLoop:
+	QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516231626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d3162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x516232626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d516233; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x4865516234626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d3162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x6235626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623662; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d516237626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d3162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x38626f487e7162c0; QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516239626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d1162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x51623a626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d51623b; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x486551623c626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d1162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x623d626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623e62; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d51623f626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d1162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x40626f487e7162c0; QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0x62fbfe4945d16207; QUAD $0x7ef162077f487ef1; QUAD $0x487ef162014f7f48; QUAD $0x7f487ef16202577f; QUAD $0x677f487ef162035f; QUAD $0x056f7f487ef16204; QUAD $0x6206777f487ef162; LONG $0x7f487ef1; WORD $0x077f
+	VZEROUPPER
+	RET
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x000(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x008(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x010(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x018(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x020(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x028(SB)/8, $0x0c0d0e0f08090a0b
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x030(SB)/8, $0x0405060700010203
+DATA PSHUFFLE_BYTE_FLIP_MASK<>+0x038(SB)/8, $0x0c0d0e0f08090a0b
+GLOBL PSHUFFLE_BYTE_FLIP_MASK<>(SB), 8, $64
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x000(SB)/8, $0x0000000000000000
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x008(SB)/8, $0x0000000000000001
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x010(SB)/8, $0x0000000000000008
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x018(SB)/8, $0x0000000000000009
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x020(SB)/8, $0x0000000000000004
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x028(SB)/8, $0x0000000000000005
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x030(SB)/8, $0x000000000000000C
+DATA PSHUFFLE_TRANSPOSE16_MASK1<>+0x038(SB)/8, $0x000000000000000D
+GLOBL PSHUFFLE_TRANSPOSE16_MASK1<>(SB), 8, $64
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x000(SB)/8, $0x0000000000000002
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x008(SB)/8, $0x0000000000000003
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x010(SB)/8, $0x000000000000000A
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x018(SB)/8, $0x000000000000000B
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x020(SB)/8, $0x0000000000000006
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x028(SB)/8, $0x0000000000000007
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x030(SB)/8, $0x000000000000000E
+DATA PSHUFFLE_TRANSPOSE16_MASK2<>+0x038(SB)/8, $0x000000000000000F
+GLOBL PSHUFFLE_TRANSPOSE16_MASK2<>(SB), 8, $64
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go
new file mode 100644
index 000000000..eb8a0ff0c
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+//go:noescape
+func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s
new file mode 100644
index 000000000..512e3cf4c
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx_amd64.s
@@ -0,0 +1,409 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for AVX
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+    MOVOU  X4, X15 \
+    MOVOU  X5, X4 \
+    MOVOU  X6, X5 \
+    MOVOU  X7, X6 \
+    MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+    MOVL e, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL a, R14 \                                                        /* y1 = a                                  */
+    LONG $0x0f41e3c4; WORD $0x04c6 \ // VPALIGNR XMM0,XMM7,XMM6,0x4      /* XTMP0 = W[-7]                           */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL f, R15 \                                                        /* y2 = f                                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    XORL g, R15 \                                                        /* y2 = f^g                                */
+    LONG $0xc4fef9c5               \ // VPADDD XMM0,XMM0,XMM4            /* XTMP0 = W[-7] + W[-16]                  */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) ) */
+    ANDL e, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    \                                                                    /*                                         */
+    \                                                                    /* compute s0                              */
+    \                                                                    /*                                         */
+    LONG $0x0f51e3c4; WORD $0x04cc \ // VPALIGNR XMM1,XMM5,XMM4,0x4      /* XTMP1 = W[-15]                          */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL g, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+48(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    MOVL a, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, h \                                                        /*  h = h + S1 + CH + k + w                */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL a, R15 \                                                        /* y2 = a                                  */
+    LONG $0xd172e9c5; BYTE $0x07   \ // VPSRLD XMM2,XMM1,0x7             /*                                         */
+    ORL  c, R13 \                                                        /* y0 = a|c                                */
+    ADDL h, d \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL c, R15 \                                                        /* y2 = a&c                                */
+    LONG $0xf172e1c5; BYTE $0x19   \ // VPSLLD XMM3,XMM1,0x19            /*                                         */
+    ANDL b, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, h \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    LONG $0xdaebe1c5               \ // VPOR   XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7                 */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, h \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL d, R13 \                                                        /* y0 = e                                  */
+    MOVL h, R14 \                                                        /* y1 = a                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    XORL d, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL e, R15 \                                                        /* y2 = f                                  */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    LONG $0xd172e9c5; BYTE $0x12   \ // VPSRLD XMM2,XMM1,0x12            /*                                         */
+    XORL h, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL f, R15 \                                                        /* y2 = f^g                                */
+    LONG $0xd172b9c5; BYTE $0x03   \ // VPSRLD XMM8,XMM1,0x3             /* XTMP4 = W[-15] >> 3                     */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    XORL d, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL d, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    LONG $0xf172f1c5; BYTE $0x0e   \ // VPSLLD XMM1,XMM1,0xe             /*                                         */
+    XORL h, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    XORL f, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    LONG $0xd9efe1c5               \ // VPXOR  XMM3,XMM3,XMM1            /*                                         */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+52(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    LONG $0xdaefe1c5               \ // VPXOR  XMM3,XMM3,XMM2            /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+    MOVL h, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, g \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL h, R15 \                                                        /* y2 = a                                  */
+    LONG $0xef61c1c4; BYTE $0xc8   \ // VPXOR  XMM1,XMM3,XMM8            /* XTMP1 = s0                              */
+    ORL  b, R13 \                                                        /* y0 = a|c                                */
+    ADDL g, c \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL b, R15 \                                                        /* y2 = a&c                                */
+    \                                                                    /*                                         */
+    \                                                                    /* compute low s1                          */
+    \                                                                    /*                                         */
+    LONG $0xd770f9c5; BYTE $0xfa   \ // VPSHUFD XMM2,XMM7,0xfa           /* XTMP2 = W[-2] {BBAA}                    */
+    ANDL a, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, g \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    LONG $0xc1fef9c5               \ // VPADDD XMM0,XMM0,XMM1            /* XTMP0 = W[-16] + W[-7] + s0             */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, g \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL c, R13 \                                                        /* y0 = e                                  */
+    MOVL g, R14 \                                                        /* y1 = a                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    XORL c, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    MOVL d, R15 \                                                        /* y2 = f                                  */
+    XORL g, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    LONG $0xd272b9c5; BYTE $0x0a   \ // VPSRLD XMM8,XMM2,0xa             /* XTMP4 = W[-2] >> 10 {BBAA}              */
+    XORL e, R15 \                                                        /* y2 = f^g                                */
+    LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+    XORL c, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL c, R15 \                                                        /* y2 = (f^g)&e                            */
+    LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    XORL g, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    XORL e, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL _xfer+56(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    LONG $0xc2ef39c5               \ // VPXOR  XMM8,XMM8,XMM2            /* XTMP4 = s1 {xBxA}                       */
+    MOVL g, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, f \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL g, R15 \                                                        /* y2 = a                                  */
+    LONG $0x003942c4; BYTE $0xc2   \ // VPSHUFB XMM8,XMM8,XMM10          /* XTMP4 = s1 {00BA}                       */
+    ORL  a, R13 \                                                        /* y0 = a|c                                */
+    ADDL f, b \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL a, R15 \                                                        /* y2 = a&c                                */
+    LONG $0xfe79c1c4; BYTE $0xc0   \ // VPADDD XMM0,XMM0,XMM8            /* XTMP0 = {..., ..., W[1], W[0]}          */
+    ANDL h, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, f \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    \                                                                    /*                                         */
+    \                                                                    /* compute high s1                         */
+    \                                                                    /*                                         */
+    LONG $0xd070f9c5; BYTE $0x50   \ // VPSHUFD XMM2,XMM0,0x50           /* XTMP2 = W[-2] {DDCC}                    */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, f \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL b, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL f, R14 \                                                        /* y1 = a                                  */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    XORL b, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL c, R15 \                                                        /* y2 = f                                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    LONG $0xd272a1c5; BYTE $0x0a   \ // VPSRLD XMM11,XMM2,0xa            /* XTMP5 = W[-2] >> 10 {DDCC}              */
+    XORL f, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    XORL d, R15 \                                                        /* y2 = f^g                                */
+    LONG $0xd273e1c5; BYTE $0x13   \ // VPSRLQ XMM3,XMM2,0x13            /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+    XORL b, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL b, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    LONG $0xd273e9c5; BYTE $0x11   \ // VPSRLQ XMM2,XMM2,0x11            /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+    XORL f, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL d, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    LONG $0xd3efe9c5               \ // VPXOR  XMM2,XMM2,XMM3            /*                                         */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+60(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    LONG $0xdaef21c5               \ // VPXOR  XMM11,XMM11,XMM2          /* XTMP5 = s1 {xDxC}                       */
+    MOVL f, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, e \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL f, R15 \                                                        /* y2 = a                                  */
+    LONG $0x002142c4; BYTE $0xdc   \ // VPSHUFB XMM11,XMM11,XMM12        /* XTMP5 = s1 {DC00}                       */
+    ORL  h, R13 \                                                        /* y0 = a|c                                */
+    ADDL e, a \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL h, R15 \                                                        /* y2 = a&c                                */
+    LONG $0xe0fea1c5               \ // VPADDD XMM4,XMM11,XMM0           /* X0 = {W[3], W[2], W[1], W[0]}           */
+    ANDL g, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, e \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, e \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    ROTATE_XS
+
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+    MOVL e, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL a, R14 \                                                        /* y1 = a                                  */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    MOVL f, R15 \                                                        /* y2 = f                                  */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL g, R15 \                                                        /* y2 = f^g                                */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    ANDL e, R15 \                                                        /* y2 = (f^g)&e                            */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL g, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL _xfer+offset(FP), R15 \                                         /* y2 = k + w + S1 + CH                    */
+    MOVL a, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, h \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL a, R15 \                                                        /* y2 = a                                  */
+    ORL  c, R13 \                                                        /* y0 = a|c                                */
+    ADDL h, d \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL c, R15 \                                                        /* y2 = a&c                                */
+    ANDL b, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, h \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, h                                                          /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+
+
+// func blockAvx(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockAvx(SB), 7, $0
+
+	MOVQ  h+0(FP), SI // SI: &h
+    MOVQ  message+24(FP), R8    // &message
+    MOVQ  lenmessage+32(FP), R9 // length of message
+    CMPQ  R9, $0
+	JEQ   done_hash
+    ADDQ  R8, R9
+    MOVQ  R9, _inp_end+64(FP)   // store end of message
+
+    // Register definition
+    //  a -->  eax
+    //  b -->  ebx
+    //  c -->  ecx
+    //  d -->  r8d
+    //  e -->  edx
+    //  f -->  r9d
+    //  g --> r10d
+    //  h --> r11d
+    //
+    // y0 --> r13d
+    // y1 --> r14d
+    // y2 --> r15d
+
+    MOVL    (0*4)(SI),  AX        // a = H0
+    MOVL    (1*4)(SI),  BX        // b = H1
+    MOVL    (2*4)(SI),  CX        // c = H2
+    MOVL    (3*4)(SI),  R8        // d = H3
+    MOVL    (4*4)(SI),  DX        // e = H4
+    MOVL    (5*4)(SI),  R9        // f = H5
+    MOVL    (6*4)(SI), R10        // g = H6
+    MOVL    (7*4)(SI), R11        // h = H7
+
+	MOVOU bflipMask<>(SB), X13
+	MOVOU  shuf00BA<>(SB), X10    // shuffle xBxA -> 00BA
+	MOVOU  shufDC00<>(SB), X12    // shuffle xDxC -> DC00
+
+	MOVQ  message+24(FP), SI // SI: &message
+
+loop0:
+	LEAQ constants<>(SB), BP
+
+	// byte swap first 16 dwords
+    MOVOU 0*16(SI), X4
+    LONG $0x0059c2c4; BYTE $0xe5 // VPSHUFB XMM4, XMM4, XMM13
+    MOVOU 1*16(SI), X5
+    LONG $0x0051c2c4; BYTE $0xed // VPSHUFB XMM5, XMM5, XMM13
+    MOVOU 2*16(SI), X6
+    LONG $0x0049c2c4; BYTE $0xf5 // VPSHUFB XMM6, XMM6, XMM13
+    MOVOU 3*16(SI), X7
+    LONG $0x0041c2c4; BYTE $0xfd // VPSHUFB XMM7, XMM7, XMM13
+
+    MOVQ SI, _inp+72(FP)
+    MOVD $0x3, DI
+
+	// schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+    LONG $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+    LONG $0x4dfe59c5; BYTE $0x10 // VPADDD XMM9, XMM4, 16[RBP]   /* Add 2nd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+    LONG $0x4dfe59c5; BYTE $0x20 // VPADDD XMM9, XMM4, 32[RBP]   /* Add 3rd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+    LONG $0x4dfe59c5; BYTE $0x30 // VPADDD XMM9, XMM4, 48[RBP]   /* Add 4th constant to message */
+    MOVOU X9, _xfer+48(FP)
+    ADDQ $64, BP
+    FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	SUBQ    $1, DI
+	JNE     loop1
+
+    MOVD $0x2, DI
+loop2:
+    LONG $0x4dfe59c5; BYTE $0x00 // VPADDD XMM9, XMM4, 0[RBP]   /* Add 1st constant to first part of message */
+    MOVOU X9, _xfer+48(FP)
+    DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+    DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+    DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+    DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+    LONG $0x4dfe51c5; BYTE $0x10 // VPADDD XMM9, XMM5, 16[RBP]   /* Add 2nd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    ADDQ $32, BP
+    DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+    DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+    DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+    DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+    MOVOU  X6, X4
+    MOVOU  X7, X5
+
+	SUBQ    $1, DI
+	JNE     loop2
+
+    MOVQ    h+0(FP), SI // SI: &h
+    ADDL    (0*4)(SI), AX     // H0 = a + H0
+    MOVL    AX, (0*4)(SI)
+    ADDL    (1*4)(SI), BX     // H1 = b + H1
+    MOVL    BX, (1*4)(SI)
+    ADDL    (2*4)(SI), CX     // H2 = c + H2
+    MOVL    CX, (2*4)(SI)
+    ADDL    (3*4)(SI), R8     // H3 = d + H3
+    MOVL    R8, (3*4)(SI)
+    ADDL    (4*4)(SI), DX     // H4 = e + H4
+    MOVL    DX, (4*4)(SI)
+    ADDL    (5*4)(SI), R9     // H5 = f + H5
+    MOVL    R9, (5*4)(SI)
+    ADDL    (6*4)(SI), R10    // H6 = g + H6
+    MOVL    R10, (6*4)(SI)
+    ADDL    (7*4)(SI), R11    // H7 = h + H7
+    MOVL    R11, (7*4)(SI)
+
+    MOVQ _inp+72(FP), SI
+	ADDQ $64, SI
+	CMPQ _inp_end+64(FP), SI
+ 	JNE  loop0
+
+done_hash:
+    RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go
new file mode 100644
index 000000000..54abbb0f0
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.go
@@ -0,0 +1,22 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+//go:noescape
+func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s
new file mode 100644
index 000000000..cf1248442
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockSsse_amd64.s
@@ -0,0 +1,430 @@
+//+build !noasm !appengine
+
+// SHA256 implementation for SSSE3
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// This code is based on an Intel White-Paper:
+// "Fast SHA-256 Implementations on Intel Architecture Processors"
+//
+// together with the reference implementation from the following authors:
+//    James Guilford <james.guilford@intel.com>
+//    Kirk Yap <kirk.s.yap@intel.com>
+//    Tim Chen <tim.c.chen@linux.intel.com>
+//
+// For Golang it has been converted to Plan 9 assembly with the help of
+// github.com/minio/asm2plan9s to assemble Intel instructions to their Plan9
+// equivalents
+//
+
+#include "textflag.h"
+
+#define ROTATE_XS \
+    MOVOU  X4, X15 \
+    MOVOU  X5, X4 \
+    MOVOU  X6, X5 \
+    MOVOU  X7, X6 \
+    MOVOU X15, X7
+
+// compute s0 four at a time and s1 two at a time
+// compute W[-16] + W[-7] 4 at a time
+#define FOUR_ROUNDS_AND_SCHED(a, b, c, d, e, f, g, h) \
+    MOVL e, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL a, R14 \                                                        /* y1 = a                                  */
+    MOVOU X7, X0 \
+    LONG $0x0f3a0f66; WORD $0x04c6 \ // PALIGNR XMM0,XMM6,0x4            /* XTMP0 = W[-7]                           */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL f, R15 \                                                        /* y2 = f                                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    XORL g, R15 \                                                        /* y2 = f^g                                */
+    LONG $0xc4fe0f66               \ // PADDD XMM0,XMM4                  /* XTMP0 = W[-7] + W[-16]                  */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6) ) */
+    ANDL e, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    \                                                                    /*                                         */
+    \                                                                    /* compute s0                              */
+    \                                                                    /*                                         */
+    MOVOU X5, X1 \
+    LONG $0x0f3a0f66; WORD $0x04cc \ // PALIGNR XMM1,XMM4,0x4            /* XTMP1 = W[-15]                          */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL g, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+48(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    MOVL a, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, h \                                                        /*  h = h + S1 + CH + k + w                */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL a, R15 \                                                        /* y2 = a                                  */
+    MOVOU X1, X2 \
+    LONG $0xd2720f66; BYTE $0x07   \ // PSRLD XMM2,0x7                   /*                                         */
+    ORL  c, R13 \                                                        /* y0 = a|c                                */
+    ADDL h, d \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL c, R15 \                                                        /* y2 = a&c                                */
+    MOVOU X1, X3 \
+    LONG $0xf3720f66; BYTE $0x19   \ // PSLLD XMM3,0x19                  /*                                         */
+    ANDL b, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, h \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    LONG $0xdaeb0f66               \ // POR   XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7                 */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, h \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL d, R13 \                                                        /* y0 = e                                  */
+    MOVL h, R14 \                                                        /* y1 = a                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    XORL d, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL e, R15 \                                                        /* y2 = f                                  */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    MOVOU X1, X2 \
+    LONG $0xd2720f66; BYTE $0x12   \ // PSRLD XMM2,0x12                  /*                                         */
+    XORL h, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL f, R15 \                                                        /* y2 = f^g                                */
+    MOVOU X1, X8 \
+    LONG $0x720f4166; WORD $0x03d0 \ // PSRLD XMM8,0x3                   /* XTMP4 = W[-15] >> 3                     */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    XORL d, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL d, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    LONG $0xf1720f66; BYTE $0x0e   \ // PSLLD XMM1,0xe                   /*                                         */
+    XORL h, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    XORL f, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    LONG $0xd9ef0f66               \ // PXOR  XMM3,XMM1                  /*                                         */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+52(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    LONG $0xdaef0f66               \ // PXOR  XMM3,XMM2                  /* XTMP1 = W[-15] MY_ROR 7 ^ W[-15] MY_ROR */
+    MOVL h, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, g \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL h, R15 \                                                        /* y2 = a                                  */
+    MOVOU X3, X1 \
+    LONG $0xef0f4166; BYTE $0xc8   \ // PXOR  XMM1,XMM8                  /* XTMP1 = s0                              */
+    ORL  b, R13 \                                                        /* y0 = a|c                                */
+    ADDL g, c \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL b, R15 \                                                        /* y2 = a&c                                */
+    \                                                                    /*                                         */
+    \                                                                    /* compute low s1                          */
+    \                                                                    /*                                         */
+    LONG $0xd7700f66; BYTE $0xfa   \ // PSHUFD XMM2,XMM7,0xfa            /* XTMP2 = W[-2] {BBAA}                    */
+    ANDL a, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, g \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    LONG $0xc1fe0f66               \ // PADDD XMM0,XMM1                  /* XTMP0 = W[-16] + W[-7] + s0             */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, g \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL c, R13 \                                                        /* y0 = e                                  */
+    MOVL g, R14 \                                                        /* y1 = a                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    XORL c, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    MOVL d, R15 \                                                        /* y2 = f                                  */
+    XORL g, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    MOVOU X2, X8 \
+    LONG $0x720f4166; WORD $0x0ad0 \ // PSRLD XMM8,0xa                   /* XTMP4 = W[-2] >> 10 {BBAA}              */
+    XORL e, R15 \                                                        /* y2 = f^g                                */
+    MOVOU X2, X3 \
+    LONG $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xBxA}          */
+    XORL c, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL c, R15 \                                                        /* y2 = (f^g)&e                            */
+    LONG $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xBxA}          */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    XORL g, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    XORL e, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    LONG $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL _xfer+56(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    LONG $0xef0f4466; BYTE $0xc2   \ // PXOR  XMM8,XMM2                  /* XTMP4 = s1 {xBxA}                       */
+    MOVL g, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, f \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL g, R15 \                                                        /* y2 = a                                  */
+    LONG $0x380f4566; WORD $0xc200 \ // PSHUFB XMM8,XMM10                /* XTMP4 = s1 {00BA}                       */
+    ORL  a, R13 \                                                        /* y0 = a|c                                */
+    ADDL f, b \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL a, R15 \                                                        /* y2 = a&c                                */
+    LONG $0xfe0f4166; BYTE $0xc0   \ // PADDD XMM0,XMM8                  /* XTMP0 = {..., ..., W[1], W[0]}          */
+    ANDL h, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, f \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    \                                                                    /*                                         */
+    \                                                                    /* compute high s1                         */
+    \                                                                    /*                                         */
+    LONG $0xd0700f66; BYTE $0x50   \ // PSHUFD XMM2,XMM0,0x50            /* XTMP2 = W[-2] {DDCC}                    */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, f \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    MOVL b, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL f, R14 \                                                        /* y1 = a                                  */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    XORL b, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    MOVL c, R15 \                                                        /* y2 = f                                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    MOVOU X2, X11 \
+    LONG $0x720f4166; WORD $0x0ad3 \ // PSRLD XMM11,0xa                  /* XTMP5 = W[-2] >> 10 {DDCC}              */
+    XORL f, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    XORL d, R15 \                                                        /* y2 = f^g                                */
+    MOVOU X2, X3 \
+    LONG $0xd3730f66; BYTE $0x13   \ // PSRLQ XMM3,0x13                  /* XTMP3 = W[-2] MY_ROR 19 {xDxC}          */
+    XORL b, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ANDL b, R15 \                                                        /* y2 = (f^g)&e                            */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    LONG $0xd2730f66; BYTE $0x11   \ // PSRLQ XMM2,0x11                  /* XTMP2 = W[-2] MY_ROR 17 {xDxC}          */
+    XORL f, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL d, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    LONG $0xd3ef0f66               \ // PXOR  XMM2,XMM3                  /*                                         */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ADDL _xfer+60(FP), R15 \                                             /* y2 = k + w + S1 + CH                    */
+    LONG $0xef0f4466; BYTE $0xda   \ // PXOR  XMM11,XMM2                 /* XTMP5 = s1 {xDxC}                       */
+    MOVL f, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, e \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL f, R15 \                                                        /* y2 = a                                  */
+    LONG $0x380f4566; WORD $0xdc00 \ // PSHUFB XMM11,XMM12               /* XTMP5 = s1 {DC00}                       */
+    ORL  h, R13 \                                                        /* y0 = a|c                                */
+    ADDL e, a \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL h, R15 \                                                        /* y2 = a&c                                */
+    MOVOU X11, X4 \
+    LONG $0xe0fe0f66               \ // PADDD XMM4,XMM0                  /* X0 = {W[3], W[2], W[1], W[0]}           */
+    ANDL g, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, e \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, e \                                                        /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+    \                                                                    /* ROTATE_ARGS                             */
+    ROTATE_XS
+
+
+#define DO_ROUND(a, b, c, d, e, f, g, h, offset) \
+    MOVL e, R13 \                                                        /* y0 = e                                  */
+    ROLL $18, R13 \                                                      /* y0 = e >> (25-11)                       */
+    MOVL a, R14 \                                                        /* y1 = a                                  */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (25-11))                 */
+    ROLL $23, R14 \                                                      /* y1 = a >> (22-13)                       */
+    MOVL f, R15 \                                                        /* y2 = f                                  */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (22-13)                  */
+    ROLL $27, R13 \                                                      /* y0 = (e >> (11-6)) ^ (e >> (25-6))      */
+    XORL g, R15 \                                                        /* y2 = f^g                                */
+    XORL e, R13 \                                                        /* y0 = e ^ (e >> (11-6)) ^ (e >> (25-6))  */
+    ROLL $21, R14 \                                                      /* y1 = (a >> (13-2)) ^ (a >> (22-2))      */
+    ANDL e, R15 \                                                        /* y2 = (f^g)&e                            */
+    XORL a, R14 \                                                        /* y1 = a ^ (a >> (13-2)) ^ (a >> (22-2))  */
+    ROLL $26, R13 \                                                      /* y0 = S1 = (e>>6) & (e>>11) ^ (e>>25)    */
+    XORL g, R15 \                                                        /* y2 = CH = ((f^g)&e)^g                   */
+    ADDL R13, R15 \                                                      /* y2 = S1 + CH                            */
+    ROLL $30, R14 \                                                      /* y1 = S0 = (a>>2) ^ (a>>13) ^ (a>>22)    */
+    ADDL _xfer+offset(FP), R15 \                                         /* y2 = k + w + S1 + CH                    */
+    MOVL a, R13 \                                                        /* y0 = a                                  */
+    ADDL R15, h \                                                        /*  h = h + S1 + CH + k + w                */
+    MOVL a, R15 \                                                        /* y2 = a                                  */
+    ORL  c, R13 \                                                        /* y0 = a|c                                */
+    ADDL h, d \                                                          /*  d = d + h + S1 + CH + k + w            */
+    ANDL c, R15 \                                                        /* y2 = a&c                                */
+    ANDL b, R13 \                                                        /* y0 = (a|c)&b                            */
+    ADDL R14, h \                                                        /*  h = h + S1 + CH + k + w + S0           */
+    ORL  R15, R13 \                                                      /* y0 = MAJ = (a|c)&b)|(a&c)               */
+    ADDL R13, h                                                          /*  h = h + S1 + CH + k + w + S0 + MAJ     */
+
+
+// func blockSsse(h []uint32, message []uint8, reserved0, reserved1, reserved2, reserved3 uint64)
+TEXT ·blockSsse(SB), 7, $0
+
+	MOVQ  h+0(FP), SI // SI: &h
+    MOVQ  message+24(FP), R8    // &message
+    MOVQ  lenmessage+32(FP), R9 // length of message
+    CMPQ  R9, $0
+	JEQ   done_hash
+    ADDQ  R8, R9
+    MOVQ  R9, _inp_end+64(FP)   // store end of message
+
+    // Register definition
+    //  a -->  eax
+    //  b -->  ebx
+    //  c -->  ecx
+    //  d -->  r8d
+    //  e -->  edx
+    //  f -->  r9d
+    //  g --> r10d
+    //  h --> r11d
+    //
+    // y0 --> r13d
+    // y1 --> r14d
+    // y2 --> r15d
+
+    MOVL    (0*4)(SI),  AX        // a = H0
+    MOVL    (1*4)(SI),  BX        // b = H1
+    MOVL    (2*4)(SI),  CX        // c = H2
+    MOVL    (3*4)(SI),  R8        // d = H3
+    MOVL    (4*4)(SI),  DX        // e = H4
+    MOVL    (5*4)(SI),  R9        // f = H5
+    MOVL    (6*4)(SI), R10        // g = H6
+    MOVL    (7*4)(SI), R11        // h = H7
+
+	MOVOU bflipMask<>(SB), X13
+	MOVOU  shuf00BA<>(SB), X10    // shuffle xBxA -> 00BA
+	MOVOU  shufDC00<>(SB), X12    // shuffle xDxC -> DC00
+
+	MOVQ  message+24(FP), SI // SI: &message
+
+loop0:
+	LEAQ constants<>(SB), BP
+
+	// byte swap first 16 dwords
+    MOVOU 0*16(SI), X4
+    LONG $0x380f4166; WORD $0xe500 // PSHUFB XMM4, XMM13
+    MOVOU 1*16(SI), X5
+    LONG $0x380f4166; WORD $0xed00 // PSHUFB XMM5, XMM13
+    MOVOU 2*16(SI), X6
+    LONG $0x380f4166; WORD $0xf500 // PSHUFB XMM6, XMM13
+    MOVOU 3*16(SI), X7
+    LONG $0x380f4166; WORD $0xfd00 // PSHUFB XMM7, XMM13
+
+    MOVQ SI, _inp+72(FP)
+    MOVD $0x3, DI
+
+    // Align
+    //  nop    WORD PTR [rax+rax*1+0x0]
+
+	// schedule 48 input dwords, by doing 3 rounds of 16 each
+loop1:
+    MOVOU X4, X9
+    LONG $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+    MOVOU X4, X9
+    LONG $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+    MOVOU X4, X9
+    LONG $0xfe0f4466; WORD $0x204d // PADDD XMM9, 32[RBP]   /* Add 3rd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    FOUR_ROUNDS_AND_SCHED(AX, BX,  CX,  R8, DX, R9, R10, R11)
+
+    MOVOU X4, X9
+    LONG $0xfe0f4466; WORD $0x304d // PADDD XMM9, 48[RBP]   /* Add 4th constant to message */
+    MOVOU X9, _xfer+48(FP)
+    ADDQ $64, BP
+    FOUR_ROUNDS_AND_SCHED(DX, R9, R10, R11, AX, BX,  CX,  R8)
+
+	SUBQ    $1, DI
+	JNE     loop1
+
+    MOVD $0x2, DI
+loop2:
+    MOVOU X4, X9
+    LONG $0xfe0f4466; WORD $0x004d // PADDD XMM9, 0[RBP]   /* Add 1st constant to first part of message */
+    MOVOU X9, _xfer+48(FP)
+    DO_ROUND( AX,  BX,  CX,  R8,  DX,  R9, R10, R11, 48)
+    DO_ROUND(R11,  AX,  BX,  CX,  R8,  DX,  R9, R10, 52)
+    DO_ROUND(R10, R11,  AX,  BX,  CX,  R8,  DX,  R9, 56)
+    DO_ROUND( R9, R10, R11,  AX,  BX,  CX,  R8,  DX, 60)
+
+    MOVOU X5, X9
+    LONG $0xfe0f4466; WORD $0x104d // PADDD XMM9, 16[RBP]   /* Add 2nd constant to message */
+    MOVOU X9, _xfer+48(FP)
+    ADDQ $32, BP
+    DO_ROUND( DX,  R9, R10, R11,  AX,  BX,  CX,  R8, 48)
+    DO_ROUND( R8,  DX,  R9, R10, R11,  AX,  BX,  CX, 52)
+    DO_ROUND( CX,  R8,  DX,  R9, R10, R11,  AX,  BX, 56)
+    DO_ROUND( BX,  CX,  R8,  DX,  R9, R10, R11,  AX, 60)
+
+    MOVOU  X6, X4
+    MOVOU  X7, X5
+
+	SUBQ    $1, DI
+	JNE     loop2
+
+    MOVQ    h+0(FP), SI // SI: &h
+    ADDL    (0*4)(SI), AX     // H0 = a + H0
+    MOVL    AX, (0*4)(SI)
+    ADDL    (1*4)(SI), BX     // H1 = b + H1
+    MOVL    BX, (1*4)(SI)
+    ADDL    (2*4)(SI), CX     // H2 = c + H2
+    MOVL    CX, (2*4)(SI)
+    ADDL    (3*4)(SI), R8     // H3 = d + H3
+    MOVL    R8, (3*4)(SI)
+    ADDL    (4*4)(SI), DX     // H4 = e + H4
+    MOVL    DX, (4*4)(SI)
+    ADDL    (5*4)(SI), R9     // H5 = f + H5
+    MOVL    R9, (5*4)(SI)
+    ADDL    (6*4)(SI), R10    // H6 = g + H6
+    MOVL    R10, (6*4)(SI)
+    ADDL    (7*4)(SI), R11    // H7 = h + H7
+    MOVL    R11, (7*4)(SI)
+
+    MOVQ _inp+72(FP), SI
+	ADDQ $64, SI
+	CMPQ _inp_end+64(FP), SI
+     JNE  loop0
+
+done_hash:
+    RET
+
+// Constants table
+DATA constants<>+0x0(SB)/8, $0x71374491428a2f98
+DATA constants<>+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA constants<>+0x10(SB)/8, $0x59f111f13956c25b
+DATA constants<>+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA constants<>+0x20(SB)/8, $0x12835b01d807aa98
+DATA constants<>+0x28(SB)/8, $0x550c7dc3243185be
+DATA constants<>+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA constants<>+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA constants<>+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA constants<>+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA constants<>+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA constants<>+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA constants<>+0x60(SB)/8, $0xa831c66d983e5152
+DATA constants<>+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA constants<>+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA constants<>+0x78(SB)/8, $0x1429296706ca6351
+DATA constants<>+0x80(SB)/8, $0x2e1b213827b70a85
+DATA constants<>+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA constants<>+0x90(SB)/8, $0x766a0abb650a7354
+DATA constants<>+0x98(SB)/8, $0x92722c8581c2c92e
+DATA constants<>+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA constants<>+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA constants<>+0xb0(SB)/8, $0xd6990624d192e819
+DATA constants<>+0xb8(SB)/8, $0x106aa070f40e3585
+DATA constants<>+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA constants<>+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA constants<>+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA constants<>+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA constants<>+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA constants<>+0xe8(SB)/8, $0x8cc7020884c87814
+DATA constants<>+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA constants<>+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+DATA bflipMask<>+0x00(SB)/8, $0x0405060700010203
+DATA bflipMask<>+0x08(SB)/8, $0x0c0d0e0f08090a0b
+
+DATA shuf00BA<>+0x00(SB)/8, $0x0b0a090803020100
+DATA shuf00BA<>+0x08(SB)/8, $0xFFFFFFFFFFFFFFFF
+
+DATA shufDC00<>+0x00(SB)/8, $0xFFFFFFFFFFFFFFFF
+DATA shufDC00<>+0x08(SB)/8, $0x0b0a090803020100
+
+GLOBL constants<>(SB), 8, $256
+GLOBL bflipMask<>(SB), (NOPTR+RODATA), $16
+GLOBL shuf00BA<>(SB), (NOPTR+RODATA), $16
+GLOBL shufDC00<>(SB), (NOPTR+RODATA), $16
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_386.go b/vendor/github.com/minio/sha256-simd/sha256block_386.go
new file mode 100644
index 000000000..84b54ae85
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_386.go
@@ -0,0 +1,24 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+func blockArmGo(dig *digest, p []byte)  {}
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_amd64.go b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
new file mode 100644
index 000000000..b6db61e3f
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
@@ -0,0 +1,48 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+func blockArmGo(dig *digest, p []byte) {}
+
+func blockAvxGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockAvx(h[:], p[:], 0, 0, 0, 0)
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockAvx2Go(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockAvx2(h[:], p[:])
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
+
+func blockSsseGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockSsse(h[:], p[:], 0, 0, 0, 0)
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm.go b/vendor/github.com/minio/sha256-simd/sha256block_arm.go
new file mode 100644
index 000000000..d892504aa
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm.go
@@ -0,0 +1,24 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockArmGo(dig *digest, p []byte)  {}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.go b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
new file mode 100644
index 000000000..299cf3366
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
@@ -0,0 +1,36 @@
+//+build !noasm
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+
+//go:noescape
+func blockArm(h []uint32, message []uint8)
+
+func blockArmGo(dig *digest, p []byte) {
+
+	h := []uint32{dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]}
+
+	blockArm(h[:], p[:])
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h[0], h[1], h[2], h[3], h[4],
+		h[5], h[6], h[7]
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.s b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
new file mode 100644
index 000000000..104ce1113
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
@@ -0,0 +1,193 @@
+//+build !noasm !appengine
+
+// ARM64 version of SHA256
+
+//
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+//
+// Based on implementation as found in https://github.com/jocover/sha256-armv8
+//
+// Use github.com/minio/asm2plan9s on this file to assemble ARM instructions to
+// their Plan9 equivalents
+//
+
+TEXT ·blockArm(SB), 7, $0
+	MOVD h+0(FP), R0
+	MOVD message+24(FP), R1
+	MOVD lenmessage+32(FP), R2 // length of message
+	SUBS $64, R2
+	BMI  complete
+
+	// Load constants table pointer
+	MOVD $·constants(SB), R3
+
+	// Cache constants table in registers v16 - v31
+	WORD $0x4cdf2870 // ld1	{v16.4s-v19.4s}, [x3], #64
+	WORD $0x4cdf7800 // ld1	{v0.4s}, [x0], #16
+	WORD $0x4cdf2874 // ld1	{v20.4s-v23.4s}, [x3], #64
+
+	WORD $0x4c407801 // ld1	{v1.4s}, [x0]
+	WORD $0x4cdf2878 // ld1	{v24.4s-v27.4s}, [x3], #64
+	WORD $0xd1004000 // sub	x0, x0, #0x10
+	WORD $0x4cdf287c // ld1	{v28.4s-v31.4s}, [x3], #64
+
+loop:
+	// Main loop
+	WORD $0x4cdf2025 // ld1	{v5.16b-v8.16b}, [x1], #64
+	WORD $0x4ea01c02 // mov	v2.16b, v0.16b
+	WORD $0x4ea11c23 // mov	v3.16b, v1.16b
+	WORD $0x6e2008a5 // rev32	v5.16b, v5.16b
+	WORD $0x6e2008c6 // rev32	v6.16b, v6.16b
+	WORD $0x4eb084a9 // add	v9.4s, v5.4s, v16.4s
+	WORD $0x6e2008e7 // rev32	v7.16b, v7.16b
+	WORD $0x4eb184ca // add	v10.4s, v6.4s, v17.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x6e200908 // rev32	v8.16b, v8.16b
+	WORD $0x4eb284e9 // add	v9.4s, v7.4s, v18.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4eb3850a // add	v10.4s, v8.4s, v19.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4eb484a9 // add	v9.4s, v5.4s, v20.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4eb584ca // add	v10.4s, v6.4s, v21.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4eb684e9 // add	v9.4s, v7.4s, v22.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4eb7850a // add	v10.4s, v8.4s, v23.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4eb884a9 // add	v9.4s, v5.4s, v24.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4eb984ca // add	v10.4s, v6.4s, v25.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e2828c5 // sha256su0	v5.4s, v6.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4eba84e9 // add	v9.4s, v7.4s, v26.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828e6 // sha256su0	v6.4s, v7.4s
+	WORD $0x5e0860e5 // sha256su1	v5.4s, v7.4s, v8.4s
+	WORD $0x4ebb850a // add	v10.4s, v8.4s, v27.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e282907 // sha256su0	v7.4s, v8.4s
+	WORD $0x5e056106 // sha256su1	v6.4s, v8.4s, v5.4s
+	WORD $0x4ebc84a9 // add	v9.4s, v5.4s, v28.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x5e2828a8 // sha256su0	v8.4s, v5.4s
+	WORD $0x5e0660a7 // sha256su1	v7.4s, v5.4s, v6.4s
+	WORD $0x4ebd84ca // add	v10.4s, v6.4s, v29.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x5e0760c8 // sha256su1	v8.4s, v6.4s, v7.4s
+	WORD $0x4ebe84e9 // add	v9.4s, v7.4s, v30.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x4ebf850a // add	v10.4s, v8.4s, v31.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e094062 // sha256h	q2, q3, v9.4s
+	WORD $0x5e095083 // sha256h2	q3, q4, v9.4s
+	WORD $0x4ea21c44 // mov	v4.16b, v2.16b
+	WORD $0x5e0a4062 // sha256h	q2, q3, v10.4s
+	WORD $0x5e0a5083 // sha256h2	q3, q4, v10.4s
+	WORD $0x4ea38421 // add	v1.4s, v1.4s, v3.4s
+	WORD $0x4ea28400 // add	v0.4s, v0.4s, v2.4s
+
+	SUBS $64, R2
+	BPL  loop
+
+	// Store result
+	WORD $0x4c00a800 // st1	{v0.4s, v1.4s}, [x0]
+
+complete:
+	RET
+
+
+// Constants table
+DATA ·constants+0x0(SB)/8, $0x71374491428a2f98
+DATA ·constants+0x8(SB)/8, $0xe9b5dba5b5c0fbcf
+DATA ·constants+0x10(SB)/8, $0x59f111f13956c25b
+DATA ·constants+0x18(SB)/8, $0xab1c5ed5923f82a4
+DATA ·constants+0x20(SB)/8, $0x12835b01d807aa98
+DATA ·constants+0x28(SB)/8, $0x550c7dc3243185be
+DATA ·constants+0x30(SB)/8, $0x80deb1fe72be5d74
+DATA ·constants+0x38(SB)/8, $0xc19bf1749bdc06a7
+DATA ·constants+0x40(SB)/8, $0xefbe4786e49b69c1
+DATA ·constants+0x48(SB)/8, $0x240ca1cc0fc19dc6
+DATA ·constants+0x50(SB)/8, $0x4a7484aa2de92c6f
+DATA ·constants+0x58(SB)/8, $0x76f988da5cb0a9dc
+DATA ·constants+0x60(SB)/8, $0xa831c66d983e5152
+DATA ·constants+0x68(SB)/8, $0xbf597fc7b00327c8
+DATA ·constants+0x70(SB)/8, $0xd5a79147c6e00bf3
+DATA ·constants+0x78(SB)/8, $0x1429296706ca6351
+DATA ·constants+0x80(SB)/8, $0x2e1b213827b70a85
+DATA ·constants+0x88(SB)/8, $0x53380d134d2c6dfc
+DATA ·constants+0x90(SB)/8, $0x766a0abb650a7354
+DATA ·constants+0x98(SB)/8, $0x92722c8581c2c92e
+DATA ·constants+0xa0(SB)/8, $0xa81a664ba2bfe8a1
+DATA ·constants+0xa8(SB)/8, $0xc76c51a3c24b8b70
+DATA ·constants+0xb0(SB)/8, $0xd6990624d192e819
+DATA ·constants+0xb8(SB)/8, $0x106aa070f40e3585
+DATA ·constants+0xc0(SB)/8, $0x1e376c0819a4c116
+DATA ·constants+0xc8(SB)/8, $0x34b0bcb52748774c
+DATA ·constants+0xd0(SB)/8, $0x4ed8aa4a391c0cb3
+DATA ·constants+0xd8(SB)/8, $0x682e6ff35b9cca4f
+DATA ·constants+0xe0(SB)/8, $0x78a5636f748f82ee
+DATA ·constants+0xe8(SB)/8, $0x8cc7020884c87814
+DATA ·constants+0xf0(SB)/8, $0xa4506ceb90befffa
+DATA ·constants+0xf8(SB)/8, $0xc67178f2bef9a3f7
+
+GLOBL ·constants(SB), 8, $256
+
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_noasm.go b/vendor/github.com/minio/sha256-simd/sha256block_noasm.go
new file mode 100644
index 000000000..356ca5367
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_noasm.go
@@ -0,0 +1,136 @@
+//+build !arm64 !amd64 noasm appengine
+
+/*
+ * Minio Cloud Storage, (C) 2016 Minio, Inc.
+ *
+ * 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 sha256
+
+func blockGeneric(dig *digest, p []byte) {
+	var w [64]uint32
+	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
+	for len(p) >= chunk {
+		// Can interlace the computation of w with the
+		// rounds below if needed for speed.
+		for i := 0; i < 16; i++ {
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
+		}
+		for i := 16; i < 64; i++ {
+			v1 := w[i-2]
+			t1 := (v1>>17 | v1<<(32-17)) ^ (v1>>19 | v1<<(32-19)) ^ (v1 >> 10)
+			v2 := w[i-15]
+			t2 := (v2>>7 | v2<<(32-7)) ^ (v2>>18 | v2<<(32-18)) ^ (v2 >> 3)
+			w[i] = t1 + w[i-7] + t2 + w[i-16]
+		}
+
+		a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
+
+		for i := 0; i < 64; i++ {
+			t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
+
+			t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
+
+			h = g
+			g = f
+			f = e
+			e = d + t1
+			d = c
+			c = b
+			b = a
+			a = t1 + t2
+		}
+
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
+		h5 += f
+		h6 += g
+		h7 += h
+
+		p = p[chunk:]
+	}
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}
+
+var _K = []uint32{
+	0x428a2f98,
+	0x71374491,
+	0xb5c0fbcf,
+	0xe9b5dba5,
+	0x3956c25b,
+	0x59f111f1,
+	0x923f82a4,
+	0xab1c5ed5,
+	0xd807aa98,
+	0x12835b01,
+	0x243185be,
+	0x550c7dc3,
+	0x72be5d74,
+	0x80deb1fe,
+	0x9bdc06a7,
+	0xc19bf174,
+	0xe49b69c1,
+	0xefbe4786,
+	0x0fc19dc6,
+	0x240ca1cc,
+	0x2de92c6f,
+	0x4a7484aa,
+	0x5cb0a9dc,
+	0x76f988da,
+	0x983e5152,
+	0xa831c66d,
+	0xb00327c8,
+	0xbf597fc7,
+	0xc6e00bf3,
+	0xd5a79147,
+	0x06ca6351,
+	0x14292967,
+	0x27b70a85,
+	0x2e1b2138,
+	0x4d2c6dfc,
+	0x53380d13,
+	0x650a7354,
+	0x766a0abb,
+	0x81c2c92e,
+	0x92722c85,
+	0xa2bfe8a1,
+	0xa81a664b,
+	0xc24b8b70,
+	0xc76c51a3,
+	0xd192e819,
+	0xd6990624,
+	0xf40e3585,
+	0x106aa070,
+	0x19a4c116,
+	0x1e376c08,
+	0x2748774c,
+	0x34b0bcb5,
+	0x391c0cb3,
+	0x4ed8aa4a,
+	0x5b9cca4f,
+	0x682e6ff3,
+	0x748f82ee,
+	0x78a5636f,
+	0x84c87814,
+	0x8cc70208,
+	0x90befffa,
+	0xa4506ceb,
+	0xbef9a3f7,
+	0xc67178f2,
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_other.go b/vendor/github.com/minio/sha256-simd/sha256block_other.go
new file mode 100644
index 000000000..38e740373
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_other.go
@@ -0,0 +1,23 @@
+// Minio Cloud Storage, (C) 2016 Minio, Inc.
+//
+// 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.
+//
+
+// +build ppc64 ppc64le mips mipsle mips64 mips64le s390x
+
+package sha256
+
+func blockAvx2Go(dig *digest, p []byte) {}
+func blockAvxGo(dig *digest, p []byte)  {}
+func blockSsseGo(dig *digest, p []byte) {}
+func blockArmGo(dig *digest, p []byte)  {}
diff --git a/vendor/github.com/mr-tron/base58/LICENSE b/vendor/github.com/mr-tron/base58/LICENSE
new file mode 100644
index 000000000..cb7829a2c
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/LICENSE
@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2017 Denis Subbotin
+Copyright (c) 2017 Nika Jones
+Copyright (c) 2017 Philip Schlump
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/mr-tron/base58/base58/alphabet.go b/vendor/github.com/mr-tron/base58/base58/alphabet.go
new file mode 100644
index 000000000..a0f887835
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/alphabet.go
@@ -0,0 +1,31 @@
+package base58
+
+// Alphabet is a a b58 alphabet.
+type Alphabet struct {
+	decode [128]int8
+	encode [58]byte
+}
+
+// NewAlphabet creates a new alphabet from the passed string.
+//
+// It panics if the passed string is not 58 bytes long or isn't valid ASCII.
+func NewAlphabet(s string) *Alphabet {
+	if len(s) != 58 {
+		panic("base58 alphabets must be 58 bytes long")
+	}
+	ret := new(Alphabet)
+	copy(ret.encode[:], s)
+	for i := range ret.decode {
+		ret.decode[i] = -1
+	}
+	for i, b := range ret.encode {
+		ret.decode[b] = int8(i)
+	}
+	return ret
+}
+
+// BTCAlphabet is the bitcoin base58 alphabet.
+var BTCAlphabet = NewAlphabet("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+// FlickrAlphabet is the flickr base58 alphabet.
+var FlickrAlphabet = NewAlphabet("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")
diff --git a/vendor/github.com/mr-tron/base58/base58/base58.go b/vendor/github.com/mr-tron/base58/base58/base58.go
new file mode 100644
index 000000000..b8810b7b8
--- /dev/null
+++ b/vendor/github.com/mr-tron/base58/base58/base58.go
@@ -0,0 +1,255 @@
+package base58
+
+import (
+	"fmt"
+	"math/big"
+)
+
+var (
+	bn0  = big.NewInt(0)
+	bn58 = big.NewInt(58)
+)
+
+// Encode encodes the passed bytes into a base58 encoded string.
+func Encode(bin []byte) string {
+	return FastBase58Encoding(bin)
+}
+
+// EncodeAlphabet encodes the passed bytes into a base58 encoded string with the
+// passed alphabet.
+func EncodeAlphabet(bin []byte, alphabet *Alphabet) string {
+	return FastBase58EncodingAlphabet(bin, alphabet)
+}
+
+// FastBase58Encoding encodes the passed bytes into a base58 encoded string.
+func FastBase58Encoding(bin []byte) string {
+	return FastBase58EncodingAlphabet(bin, BTCAlphabet)
+}
+
+// FastBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string with the passed alphabet.
+func FastBase58EncodingAlphabet(bin []byte, alphabet *Alphabet) string {
+	zero := alphabet.encode[0]
+
+	binsz := len(bin)
+	var i, j, zcount, high int
+	var carry uint32
+
+	for zcount < binsz && bin[zcount] == 0 {
+		zcount++
+	}
+
+	size := (binsz-zcount)*138/100 + 1
+	var buf = make([]byte, size)
+
+	high = size - 1
+	for i = zcount; i < binsz; i++ {
+		j = size - 1
+		for carry = uint32(bin[i]); j > high || carry != 0; j-- {
+			carry = carry + 256*uint32(buf[j])
+			buf[j] = byte(carry % 58)
+			carry /= 58
+		}
+		high = j
+	}
+
+	for j = 0; j < size && buf[j] == 0; j++ {
+	}
+
+	var b58 = make([]byte, size-j+zcount)
+
+	if zcount != 0 {
+		for i = 0; i < zcount; i++ {
+			b58[i] = zero
+		}
+	}
+
+	for i = zcount; j < size; i++ {
+		b58[i] = alphabet.encode[buf[j]]
+		j++
+	}
+
+	return string(b58)
+}
+
+// TrivialBase58Encoding encodes the passed bytes into a base58 encoded string
+// (inefficiently).
+func TrivialBase58Encoding(a []byte) string {
+	return TrivialBase58EncodingAlphabet(a, BTCAlphabet)
+}
+
+// TrivialBase58EncodingAlphabet encodes the passed bytes into a base58 encoded
+// string (inefficiently) with the passed alphabet.
+func TrivialBase58EncodingAlphabet(a []byte, alphabet *Alphabet) string {
+	zero := alphabet.encode[0]
+	idx := len(a)*138/100 + 1
+	buf := make([]byte, idx)
+	bn := new(big.Int).SetBytes(a)
+	var mo *big.Int
+	for bn.Cmp(bn0) != 0 {
+		bn, mo = bn.DivMod(bn, bn58, new(big.Int))
+		idx--
+		buf[idx] = alphabet.encode[mo.Int64()]
+	}
+	for i := range a {
+		if a[i] != 0 {
+			break
+		}
+		idx--
+		buf[idx] = zero
+	}
+	return string(buf[idx:])
+}
+
+// Decode decodes the base58 encoded bytes.
+func Decode(str string) ([]byte, error) {
+	return FastBase58Decoding(str)
+}
+
+// DecodeAlphabet decodes the base58 encoded bytes using the given b58 alphabet.
+func DecodeAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	return FastBase58DecodingAlphabet(str, alphabet)
+}
+
+// FastBase58Decoding decodes the base58 encoded bytes.
+func FastBase58Decoding(str string) ([]byte, error) {
+	return FastBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// FastBase58DecodingAlphabet decodes the base58 encoded bytes using the given
+// b58 alphabet.
+func FastBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	if len(str) == 0 {
+		return nil, fmt.Errorf("zero length string")
+	}
+
+	var (
+		t        uint64
+		zmask, c uint32
+		zcount   int
+
+		b58u  = []rune(str)
+		b58sz = len(b58u)
+
+		outisz    = (b58sz + 3) / 4 // check to see if we need to change this buffer size to optimize
+		binu      = make([]byte, (b58sz+3)*3)
+		bytesleft = b58sz % 4
+
+		zero = rune(alphabet.encode[0])
+	)
+
+	if bytesleft > 0 {
+		zmask = (0xffffffff << uint32(bytesleft*8))
+	} else {
+		bytesleft = 4
+	}
+
+	var outi = make([]uint32, outisz)
+
+	for i := 0; i < b58sz && b58u[i] == zero; i++ {
+		zcount++
+	}
+
+	for _, r := range b58u {
+		if r > 127 {
+			return nil, fmt.Errorf("High-bit set on invalid digit")
+		}
+		if alphabet.decode[r] == -1 {
+			return nil, fmt.Errorf("Invalid base58 digit (%q)", r)
+		}
+
+		c = uint32(alphabet.decode[r])
+
+		for j := (outisz - 1); j >= 0; j-- {
+			t = uint64(outi[j])*58 + uint64(c)
+			c = uint32(t>>32) & 0x3f
+			outi[j] = uint32(t & 0xffffffff)
+		}
+
+		if c > 0 {
+			return nil, fmt.Errorf("Output number too big (carry to the next int32)")
+		}
+
+		if outi[0]&zmask != 0 {
+			return nil, fmt.Errorf("Output number too big (last int32 filled too far)")
+		}
+	}
+
+	// the nested for-loop below is the same as the original code:
+	// switch (bytesleft) {
+	// 	case 3:
+	// 		*(binu++) = (outi[0] & 0xff0000) >> 16;
+	// 		//-fallthrough
+	// 	case 2:
+	// 		*(binu++) = (outi[0] & 0xff00) >>  8;
+	// 		//-fallthrough
+	// 	case 1:
+	// 		*(binu++) = (outi[0] & 0xff);
+	// 		++j;
+	// 		//-fallthrough
+	// 	default:
+	// 		break;
+	// }
+	//
+	// for (; j < outisz; ++j)
+	// {
+	// 	*(binu++) = (outi[j] >> 0x18) & 0xff;
+	// 	*(binu++) = (outi[j] >> 0x10) & 0xff;
+	// 	*(binu++) = (outi[j] >>    8) & 0xff;
+	// 	*(binu++) = (outi[j] >>    0) & 0xff;
+	// }
+	var j, cnt int
+	for j, cnt = 0, 0; j < outisz; j++ {
+		for mask := byte(bytesleft-1) * 8; mask <= 0x18; mask, cnt = mask-8, cnt+1 {
+			binu[cnt] = byte(outi[j] >> mask)
+		}
+		if j == 0 {
+			bytesleft = 4 // because it could be less than 4 the first time through
+		}
+	}
+
+	for n, v := range binu {
+		if v > 0 {
+			start := n - zcount
+			if start < 0 {
+				start = 0
+			}
+			return binu[start:cnt], nil
+		}
+	}
+	return binu[:cnt], nil
+}
+
+// TrivialBase58Decoding decodes the base58 encoded bytes (inefficiently).
+func TrivialBase58Decoding(str string) ([]byte, error) {
+	return TrivialBase58DecodingAlphabet(str, BTCAlphabet)
+}
+
+// TrivialBase58DecodingAlphabet decodes the base58 encoded bytes
+// (inefficiently) using the given b58 alphabet.
+func TrivialBase58DecodingAlphabet(str string, alphabet *Alphabet) ([]byte, error) {
+	zero := alphabet.encode[0]
+
+	var zcount int
+	for i := 0; i < len(str) && str[i] == zero; i++ {
+		zcount++
+	}
+	leading := make([]byte, zcount)
+
+	var padChar rune = -1
+	src := []byte(str)
+	j := 0
+	for ; j < len(src) && src[j] == byte(padChar); j++ {
+	}
+
+	n := new(big.Int)
+	for i := range src[j:] {
+		c := alphabet.decode[src[i]]
+		if c == -1 {
+			return nil, fmt.Errorf("illegal base58 data at input index: %d", i)
+		}
+		n.Mul(n, bn58)
+		n.Add(n, big.NewInt(int64(c)))
+	}
+	return append(leading, n.Bytes()...), nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE b/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/dns.go b/vendor/github.com/multiformats/go-multiaddr-dns/dns.go
new file mode 100644
index 000000000..9938ad235
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/dns.go
@@ -0,0 +1,66 @@
+package madns
+
+import (
+	"errors"
+	"fmt"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var Dns4Protocol = ma.Protocol{
+	Code:       54,
+	Size:       ma.LengthPrefixedVarSize,
+	Name:       "dns4",
+	VCode:      ma.CodeToVarint(54),
+	Transcoder: DnsTranscoder,
+}
+var Dns6Protocol = ma.Protocol{
+	Code:       55,
+	Size:       ma.LengthPrefixedVarSize,
+	Name:       "dns6",
+	VCode:      ma.CodeToVarint(55),
+	Transcoder: DnsTranscoder,
+}
+var DnsaddrProtocol = ma.Protocol{
+	Code:       56,
+	Size:       ma.LengthPrefixedVarSize,
+	Name:       "dnsaddr",
+	VCode:      ma.CodeToVarint(56),
+	Transcoder: DnsTranscoder,
+}
+
+func init() {
+	err := ma.AddProtocol(Dns4Protocol)
+	if err != nil {
+		panic(fmt.Errorf("error registering dns4 protocol: %s", err))
+	}
+	err = ma.AddProtocol(Dns6Protocol)
+	if err != nil {
+		panic(fmt.Errorf("error registering dns6 protocol: %s", err))
+	}
+	err = ma.AddProtocol(DnsaddrProtocol)
+	if err != nil {
+		panic(fmt.Errorf("error registering dnsaddr protocol: %s", err))
+	}
+}
+
+var DnsTranscoder = ma.NewTranscoderFromFunctions(dnsStB, dnsBtS)
+
+func dnsStB(s string) ([]byte, error) {
+	size := ma.CodeToVarint(len(s))
+	b := append(size, []byte(s)...)
+	return b, nil
+}
+
+func dnsBtS(b []byte) (string, error) {
+	size, n, err := ma.ReadVarintCode(b)
+	if err != nil {
+		return "", err
+	}
+
+	b = b[n:]
+	if len(b) != size {
+		return "", errors.New("inconsistent lengths")
+	}
+	return string(b), nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go b/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go
new file mode 100644
index 000000000..9c81c2f53
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-dns/resolve.go
@@ -0,0 +1,181 @@
+package madns
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strings"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var ResolvableProtocols = []ma.Protocol{DnsaddrProtocol, Dns4Protocol, Dns6Protocol}
+var DefaultResolver = &Resolver{Backend: net.DefaultResolver}
+
+type backend interface {
+	LookupIPAddr(context.Context, string) ([]net.IPAddr, error)
+	LookupTXT(context.Context, string) ([]string, error)
+}
+
+type Resolver struct {
+	Backend backend
+}
+
+type MockBackend struct {
+	IP  map[string][]net.IPAddr
+	TXT map[string][]string
+}
+
+func (r *MockBackend) LookupIPAddr(ctx context.Context, name string) ([]net.IPAddr, error) {
+	results, ok := r.IP[name]
+	if ok {
+		return results, nil
+	} else {
+		return []net.IPAddr{}, nil
+	}
+}
+
+func (r *MockBackend) LookupTXT(ctx context.Context, name string) ([]string, error) {
+	results, ok := r.TXT[name]
+	if ok {
+		return results, nil
+	} else {
+		return []string{}, nil
+	}
+}
+
+func Matches(maddr ma.Multiaddr) bool {
+	protos := maddr.Protocols()
+	if len(protos) == 0 {
+		return false
+	}
+
+	for _, p := range ResolvableProtocols {
+		if protos[0].Code == p.Code {
+			return true
+		}
+	}
+
+	return false
+}
+
+func Resolve(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+	return DefaultResolver.Resolve(ctx, maddr)
+}
+
+func (r *Resolver) Resolve(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+	if !Matches(maddr) {
+		return []ma.Multiaddr{maddr}, nil
+	}
+
+	protos := maddr.Protocols()
+	if protos[0].Code == Dns4Protocol.Code {
+		return r.resolveDns4(ctx, maddr)
+	}
+	if protos[0].Code == Dns6Protocol.Code {
+		return r.resolveDns6(ctx, maddr)
+	}
+	if protos[0].Code == DnsaddrProtocol.Code {
+		return r.resolveDnsaddr(ctx, maddr)
+	}
+
+	panic("unreachable")
+}
+
+func (r *Resolver) resolveDns4(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+	value, err := maddr.ValueForProtocol(Dns4Protocol.Code)
+	if err != nil {
+		return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+	}
+
+	encap := ma.Split(maddr)[1:]
+
+	result := []ma.Multiaddr{}
+	records, err := r.Backend.LookupIPAddr(ctx, value)
+	if err != nil {
+		return result, err
+	}
+
+	for _, r := range records {
+		ip4 := r.IP.To4()
+		if ip4 == nil {
+			continue
+		}
+		ip4maddr, err := ma.NewMultiaddr("/ip4/" + ip4.String())
+		if err != nil {
+			return result, err
+		}
+		parts := append([]ma.Multiaddr{ip4maddr}, encap...)
+		result = append(result, ma.Join(parts...))
+	}
+	return result, nil
+}
+
+func (r *Resolver) resolveDns6(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+	value, err := maddr.ValueForProtocol(Dns6Protocol.Code)
+	if err != nil {
+		return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+	}
+
+	encap := ma.Split(maddr)[1:]
+
+	result := []ma.Multiaddr{}
+	records, err := r.Backend.LookupIPAddr(ctx, value)
+	if err != nil {
+		return result, err
+	}
+
+	for _, r := range records {
+		if r.IP.To4() != nil {
+			continue
+		}
+		ip6maddr, err := ma.NewMultiaddr("/ip6/" + r.IP.To16().String())
+		if err != nil {
+			return result, err
+		}
+		parts := append([]ma.Multiaddr{ip6maddr}, encap...)
+		result = append(result, ma.Join(parts...))
+	}
+	return result, nil
+}
+
+func (r *Resolver) resolveDnsaddr(ctx context.Context, maddr ma.Multiaddr) ([]ma.Multiaddr, error) {
+	value, err := maddr.ValueForProtocol(DnsaddrProtocol.Code)
+	if err != nil {
+		return nil, fmt.Errorf("error resolving %s: %s", maddr.String(), err)
+	}
+
+	trailer := ma.Split(maddr)[1:]
+
+	result := []ma.Multiaddr{}
+	records, err := r.Backend.LookupTXT(ctx, "_dnsaddr."+value)
+	if err != nil {
+		return result, err
+	}
+
+	for _, r := range records {
+		rv := strings.Split(r, "dnsaddr=")
+		if len(rv) != 2 {
+			continue
+		}
+
+		rmaddr, err := ma.NewMultiaddr(rv[1])
+		if err != nil {
+			return result, err
+		}
+
+		if matchDnsaddr(rmaddr, trailer) {
+			result = append(result, rmaddr)
+		}
+	}
+	return result, nil
+}
+
+// XXX probably insecure
+func matchDnsaddr(maddr ma.Multiaddr, trailer []ma.Multiaddr) bool {
+	parts := ma.Split(maddr)
+	if ma.Join(parts[len(parts)-len(trailer):]...).Equal(ma.Join(trailer...)) {
+		return true
+	}
+	return false
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/LICENSE b/vendor/github.com/multiformats/go-multiaddr-net/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/convert.go b/vendor/github.com/multiformats/go-multiaddr-net/convert.go
new file mode 100644
index 000000000..973820c77
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/convert.go
@@ -0,0 +1,168 @@
+package manet
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
+
+// FromNetAddr converts a net.Addr type to a Multiaddr.
+func FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	return defaultCodecs.FromNetAddr(a)
+}
+
+// FromNetAddr converts a net.Addr to Multiaddress.
+func (cm *CodecMap) FromNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	if a == nil {
+		return nil, fmt.Errorf("nil multiaddr")
+	}
+	p, err := cm.getAddrParser(a.Network())
+	if err != nil {
+		return nil, err
+	}
+
+	return p(a)
+}
+
+// ToNetAddr converts a Multiaddr to a net.Addr
+// Must be ThinWaist. acceptable protocol stacks are:
+// /ip{4,6}/{tcp, udp}
+func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+	return defaultCodecs.ToNetAddr(maddr)
+}
+
+// ToNetAddr converts a Multiaddress to a standard net.Addr.
+func (cm *CodecMap) ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
+	protos := maddr.Protocols()
+	final := protos[len(protos)-1]
+
+	p, err := cm.getMaddrParser(final.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	return p(maddr)
+}
+
+func parseBasicNetMaddr(maddr ma.Multiaddr) (net.Addr, error) {
+	network, host, err := DialArgs(maddr)
+	if err != nil {
+		return nil, err
+	}
+
+	switch network {
+	case "tcp", "tcp4", "tcp6":
+		return net.ResolveTCPAddr(network, host)
+	case "udp", "udp4", "udp6":
+		return net.ResolveUDPAddr(network, host)
+	case "ip", "ip4", "ip6":
+		return net.ResolveIPAddr(network, host)
+	}
+
+	return nil, fmt.Errorf("network not supported: %s", network)
+}
+
+// FromIP converts a net.IP type to a Multiaddr.
+func FromIP(ip net.IP) (ma.Multiaddr, error) {
+	switch {
+	case ip.To4() != nil:
+		return ma.NewMultiaddr("/ip4/" + ip.String())
+	case ip.To16() != nil:
+		return ma.NewMultiaddr("/ip6/" + ip.String())
+	default:
+		return nil, errIncorrectNetAddr
+	}
+}
+
+// DialArgs is a convenience function returning arguments for use in net.Dial
+func DialArgs(m ma.Multiaddr) (string, string, error) {
+	// TODO: find a 'good' way to eliminate the function.
+	// My preference is with a multiaddr.Format(...) function
+	if !IsThinWaist(m) {
+		return "", "", fmt.Errorf("%s is not a 'thin waist' address", m)
+	}
+
+	str := m.String()
+	parts := strings.Split(str, "/")[1:]
+
+	if len(parts) == 2 { // only IP
+		return parts[0], parts[1], nil
+	}
+
+	network := parts[2]
+
+	var host string
+	switch parts[0] {
+	case "ip4":
+		network = network + "4"
+		host = strings.Join([]string{parts[1], parts[3]}, ":")
+	case "ip6":
+		network = network + "6"
+		host = fmt.Sprintf("[%s]:%s", parts[1], parts[3])
+	}
+	return network, host, nil
+}
+
+func parseTCPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	ac, ok := a.(*net.TCPAddr)
+	if !ok {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Get IP Addr
+	ipm, err := FromIP(ac.IP)
+	if err != nil {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Get TCP Addr
+	tcpm, err := ma.NewMultiaddr(fmt.Sprintf("/tcp/%d", ac.Port))
+	if err != nil {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Encapsulate
+	return ipm.Encapsulate(tcpm), nil
+}
+
+func parseUDPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	ac, ok := a.(*net.UDPAddr)
+	if !ok {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Get IP Addr
+	ipm, err := FromIP(ac.IP)
+	if err != nil {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Get UDP Addr
+	udpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d", ac.Port))
+	if err != nil {
+		return nil, errIncorrectNetAddr
+	}
+
+	// Encapsulate
+	return ipm.Encapsulate(udpm), nil
+}
+
+func parseIPNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	ac, ok := a.(*net.IPAddr)
+	if !ok {
+		return nil, errIncorrectNetAddr
+	}
+	return FromIP(ac.IP)
+}
+
+func parseIPPlusNetAddr(a net.Addr) (ma.Multiaddr, error) {
+	ac, ok := a.(*net.IPNet)
+	if !ok {
+		return nil, errIncorrectNetAddr
+	}
+	return FromIP(ac.IP)
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/doc.go b/vendor/github.com/multiformats/go-multiaddr-net/doc.go
new file mode 100644
index 000000000..040ad3f02
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/doc.go
@@ -0,0 +1,5 @@
+// Package manet provides Multiaddr specific versions of common
+// functions in stdlib's net package. This means wrappers of
+// standard net symbols like net.Dial and net.Listen, as well
+// as conversion to/from net.Addr.
+package manet
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/ip.go b/vendor/github.com/multiformats/go-multiaddr-net/ip.go
new file mode 100644
index 000000000..d18895761
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/ip.go
@@ -0,0 +1,87 @@
+package manet
+
+import (
+	"bytes"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// Loopback Addresses
+var (
+	// IP4Loopback is the ip4 loopback multiaddr
+	IP4Loopback = ma.StringCast("/ip4/127.0.0.1")
+
+	// IP6Loopback is the ip6 loopback multiaddr
+	IP6Loopback = ma.StringCast("/ip6/::1")
+
+	// IP6LinkLocalLoopback is the ip6 link-local loopback multiaddr
+	IP6LinkLocalLoopback = ma.StringCast("/ip6/fe80::1")
+)
+
+// Unspecified Addresses (used for )
+var (
+	IP4Unspecified = ma.StringCast("/ip4/0.0.0.0")
+	IP6Unspecified = ma.StringCast("/ip6/::")
+)
+
+// Loopback multiaddr prefixes. Any multiaddr beginning with one of the
+// following byte sequences is considered a loopback multiaddr.
+var loopbackPrefixes = [][]byte{
+	{ma.P_IP4, 127}, // 127.*
+	IP6LinkLocalLoopback.Bytes(),
+	IP6Loopback.Bytes(),
+}
+
+// IsThinWaist returns whether a Multiaddr starts with "Thin Waist" Protocols.
+// This means: /{IP4, IP6}[/{TCP, UDP}]
+func IsThinWaist(m ma.Multiaddr) bool {
+	p := m.Protocols()
+
+	// nothing? not even a waist.
+	if len(p) == 0 {
+		return false
+	}
+
+	if p[0].Code != ma.P_IP4 && p[0].Code != ma.P_IP6 {
+		return false
+	}
+
+	// only IP? still counts.
+	if len(p) == 1 {
+		return true
+	}
+
+	switch p[1].Code {
+	case ma.P_TCP, ma.P_UDP, ma.P_IP4, ma.P_IP6:
+		return true
+	default:
+		return false
+	}
+}
+
+// IsIPLoopback returns whether a Multiaddr is a "Loopback" IP address
+// This means either /ip4/127.*.*.*, /ip6/::1, or /ip6/fe80::1
+func IsIPLoopback(m ma.Multiaddr) bool {
+	b := m.Bytes()
+	for _, prefix := range loopbackPrefixes {
+		if bytes.HasPrefix(b, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+// IsIP6LinkLocal returns if a multiaddress is an IPv6 local link. These
+// addresses are non routable. The prefix is technically
+// fe80::/10, but we test fe80::/16 for simplicity (no need to mask).
+// So far, no hardware interfaces exist long enough to use those 2 bits.
+// Send a PR if there is.
+func IsIP6LinkLocal(m ma.Multiaddr) bool {
+	return bytes.HasPrefix(m.Bytes(), []byte{ma.P_IP6, 0xfe, 0x80})
+}
+
+// IsIPUnspecified returns whether a Multiaddr is am Unspecified IP address
+// This means either /ip4/0.0.0.0 or /ip6/::
+func IsIPUnspecified(m ma.Multiaddr) bool {
+	return IP4Unspecified.Equal(m) || IP6Unspecified.Equal(m)
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/net.go b/vendor/github.com/multiformats/go-multiaddr-net/net.go
new file mode 100644
index 000000000..a6d0e76d5
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/net.go
@@ -0,0 +1,420 @@
+// Package manet provides Multiaddr
+// (https://github.com/multiformats/go-multiaddr) specific versions of common
+// functions in Go's standard `net` package. This means wrappers of standard
+// net symbols like `net.Dial` and `net.Listen`, as well as conversion to
+// and from `net.Addr`.
+package manet
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// Conn is the equivalent of a net.Conn object. It is the
+// result of calling the Dial or Listen functions in this
+// package, with associated local and remote Multiaddrs.
+type Conn interface {
+	net.Conn
+
+	// LocalMultiaddr returns the local Multiaddr associated
+	// with this connection
+	LocalMultiaddr() ma.Multiaddr
+
+	// RemoteMultiaddr returns the remote Multiaddr associated
+	// with this connection
+	RemoteMultiaddr() ma.Multiaddr
+}
+
+type halfOpen interface {
+	net.Conn
+	CloseRead() error
+	CloseWrite() error
+}
+
+func wrap(nconn net.Conn, laddr, raddr ma.Multiaddr) Conn {
+	endpts := maEndpoints{
+		laddr: laddr,
+		raddr: raddr,
+	}
+	// This sucks. However, it's the only way to reliably expose the
+	// underlying methods. This way, users that need access to, e.g.,
+	// CloseRead and CloseWrite, can do so via type assertions.
+	switch nconn := nconn.(type) {
+	case *net.TCPConn:
+		return &struct {
+			*net.TCPConn
+			maEndpoints
+		}{nconn, endpts}
+	case *net.UDPConn:
+		return &struct {
+			*net.UDPConn
+			maEndpoints
+		}{nconn, endpts}
+	case *net.IPConn:
+		return &struct {
+			*net.IPConn
+			maEndpoints
+		}{nconn, endpts}
+	case *net.UnixConn:
+		return &struct {
+			*net.UnixConn
+			maEndpoints
+		}{nconn, endpts}
+	case halfOpen:
+		return &struct {
+			halfOpen
+			maEndpoints
+		}{nconn, endpts}
+	default:
+		return &struct {
+			net.Conn
+			maEndpoints
+		}{nconn, endpts}
+	}
+}
+
+// WrapNetConn wraps a net.Conn object with a Multiaddr friendly Conn.
+//
+// This function does it's best to avoid "hiding" methods exposed by the wrapped
+// type. Guarantees:
+//
+// * If the wrapped connection exposes the "half-open" closer methods
+//   (CloseWrite, CloseRead), these will be available on the wrapped connection
+//   via type assertions.
+// * If the wrapped connection is a UnixConn, IPConn, TCPConn, or UDPConn, all
+//   methods on these wrapped connections will be available via type assertions.
+func WrapNetConn(nconn net.Conn) (Conn, error) {
+	if nconn == nil {
+		return nil, fmt.Errorf("failed to convert nconn.LocalAddr: nil")
+	}
+
+	laddr, err := FromNetAddr(nconn.LocalAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert nconn.LocalAddr: %s", err)
+	}
+
+	raddr, err := FromNetAddr(nconn.RemoteAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert nconn.RemoteAddr: %s", err)
+	}
+
+	return wrap(nconn, laddr, raddr), nil
+}
+
+type maEndpoints struct {
+	laddr ma.Multiaddr
+	raddr ma.Multiaddr
+}
+
+// LocalMultiaddr returns the local address associated with
+// this connection
+func (c *maEndpoints) LocalMultiaddr() ma.Multiaddr {
+	return c.laddr
+}
+
+// RemoteMultiaddr returns the remote address associated with
+// this connection
+func (c *maEndpoints) RemoteMultiaddr() ma.Multiaddr {
+	return c.raddr
+}
+
+// Dialer contains options for connecting to an address. It
+// is effectively the same as net.Dialer, but its LocalAddr
+// and RemoteAddr options are Multiaddrs, instead of net.Addrs.
+type Dialer struct {
+
+	// Dialer is just an embedded net.Dialer, with all its options.
+	net.Dialer
+
+	// LocalAddr is the local address to use when dialing an
+	// address. The address must be of a compatible type for the
+	// network being dialed.
+	// If nil, a local address is automatically chosen.
+	LocalAddr ma.Multiaddr
+}
+
+// Dial connects to a remote address, using the options of the
+// Dialer. Dialer uses an underlying net.Dialer to Dial a
+// net.Conn, then wraps that in a Conn object (with local and
+// remote Multiaddrs).
+func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
+	return d.DialContext(context.Background(), remote)
+}
+
+// DialContext allows to provide a custom context to Dial().
+func (d *Dialer) DialContext(ctx context.Context, remote ma.Multiaddr) (Conn, error) {
+	// if a LocalAddr is specified, use it on the embedded dialer.
+	if d.LocalAddr != nil {
+		// convert our multiaddr to net.Addr friendly
+		naddr, err := ToNetAddr(d.LocalAddr)
+		if err != nil {
+			return nil, err
+		}
+
+		// set the dialer's LocalAddr as naddr
+		d.Dialer.LocalAddr = naddr
+	}
+
+	// get the net.Dial friendly arguments from the remote addr
+	rnet, rnaddr, err := DialArgs(remote)
+	if err != nil {
+		return nil, err
+	}
+
+	// ok, Dial!
+	var nconn net.Conn
+	switch rnet {
+	case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
+		nconn, err = d.Dialer.DialContext(ctx, rnet, rnaddr)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("unrecognized network: %s", rnet)
+	}
+
+	// get local address (pre-specified or assigned within net.Conn)
+	local := d.LocalAddr
+	if local == nil {
+		local, err = FromNetAddr(nconn.LocalAddr())
+		if err != nil {
+			return nil, err
+		}
+	}
+	return wrap(nconn, local, remote), nil
+}
+
+// Dial connects to a remote address. It uses an underlying net.Conn,
+// then wraps it in a Conn object (with local and remote Multiaddrs).
+func Dial(remote ma.Multiaddr) (Conn, error) {
+	return (&Dialer{}).Dial(remote)
+}
+
+// A Listener is a generic network listener for stream-oriented protocols.
+// it uses an embedded net.Listener, overriding net.Listener.Accept to
+// return a Conn and providing Multiaddr.
+type Listener interface {
+	// Accept waits for and returns the next connection to the listener.
+	// Returns a Multiaddr friendly Conn
+	Accept() (Conn, error)
+
+	// Close closes the listener.
+	// Any blocked Accept operations will be unblocked and return errors.
+	Close() error
+
+	// Multiaddr returns the listener's (local) Multiaddr.
+	Multiaddr() ma.Multiaddr
+
+	// Addr returns the net.Listener's network address.
+	Addr() net.Addr
+}
+
+type netListenerAdapter struct {
+	Listener
+}
+
+func (nla *netListenerAdapter) Accept() (net.Conn, error) {
+	return nla.Listener.Accept()
+}
+
+// NetListener turns this Listener into a net.Listener.
+//
+// * Connections returned from Accept implement multiaddr-net Conn.
+// * Calling WrapNetListener on the net.Listener returned by this function will
+//   return the original (underlying) multiaddr-net Listener.
+func NetListener(l Listener) net.Listener {
+	return &netListenerAdapter{l}
+}
+
+// maListener implements Listener
+type maListener struct {
+	net.Listener
+	laddr ma.Multiaddr
+}
+
+// Accept waits for and returns the next connection to the listener.
+// Returns a Multiaddr friendly Conn
+func (l *maListener) Accept() (Conn, error) {
+	nconn, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+
+	raddr, err := FromNetAddr(nconn.RemoteAddr())
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert connn.RemoteAddr: %s", err)
+	}
+
+	return wrap(nconn, l.laddr, raddr), nil
+}
+
+// Multiaddr returns the listener's (local) Multiaddr.
+func (l *maListener) Multiaddr() ma.Multiaddr {
+	return l.laddr
+}
+
+// Addr returns the listener's network address.
+func (l *maListener) Addr() net.Addr {
+	return l.Listener.Addr()
+}
+
+// Listen announces on the local network address laddr.
+// The Multiaddr must be a "ThinWaist" stream-oriented network:
+// ip4/tcp, ip6/tcp, (TODO: unix, unixpacket)
+// See Dial for the syntax of laddr.
+func Listen(laddr ma.Multiaddr) (Listener, error) {
+
+	// get the net.Listen friendly arguments from the remote addr
+	lnet, lnaddr, err := DialArgs(laddr)
+	if err != nil {
+		return nil, err
+	}
+
+	nl, err := net.Listen(lnet, lnaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	// we want to fetch the new multiaddr from the listener, as it may
+	// have resolved to some other value. WrapNetListener does it for us.
+	return WrapNetListener(nl)
+}
+
+// WrapNetListener wraps a net.Listener with a manet.Listener.
+func WrapNetListener(nl net.Listener) (Listener, error) {
+	if nla, ok := nl.(*netListenerAdapter); ok {
+		return nla.Listener, nil
+	}
+
+	laddr, err := FromNetAddr(nl.Addr())
+	if err != nil {
+		return nil, err
+	}
+
+	return &maListener{
+		Listener: nl,
+		laddr:    laddr,
+	}, nil
+}
+
+// A PacketConn is a generic packet oriented network connection which uses an
+// underlying net.PacketConn, wrapped with the locally bound Multiaddr.
+type PacketConn interface {
+	Connection() net.PacketConn
+
+	Multiaddr() ma.Multiaddr
+
+	ReadFrom(b []byte) (int, ma.Multiaddr, error)
+	WriteTo(b []byte, maddr ma.Multiaddr) (int, error)
+
+	Close() error
+}
+
+// maPacketConn implements PacketConn
+type maPacketConn struct {
+	net.PacketConn
+	laddr ma.Multiaddr
+}
+
+// Connection returns the embedded net.PacketConn.
+func (l *maPacketConn) Connection() net.PacketConn {
+	return l.PacketConn
+}
+
+// Multiaddr returns the bound local Multiaddr.
+func (l *maPacketConn) Multiaddr() ma.Multiaddr {
+	return l.laddr
+}
+
+func (l *maPacketConn) ReadFrom(b []byte) (int, ma.Multiaddr, error) {
+	n, addr, err := l.PacketConn.ReadFrom(b)
+	maddr, _ := FromNetAddr(addr)
+	return n, maddr, err
+}
+
+func (l *maPacketConn) WriteTo(b []byte, maddr ma.Multiaddr) (int, error) {
+	addr, err := ToNetAddr(maddr)
+	if err != nil {
+		return 0, err
+	}
+	return l.PacketConn.WriteTo(b, addr)
+}
+
+// ListenPacket announces on the local network address laddr.
+// The Multiaddr must be a packet driven network, like udp4 or udp6.
+// See Dial for the syntax of laddr.
+func ListenPacket(laddr ma.Multiaddr) (PacketConn, error) {
+	lnet, lnaddr, err := DialArgs(laddr)
+	if err != nil {
+		return nil, err
+	}
+
+	pc, err := net.ListenPacket(lnet, lnaddr)
+	if err != nil {
+		return nil, err
+	}
+
+	// We want to fetch the new multiaddr from the listener, as it may
+	// have resolved to some other value. WrapPacketConn does this.
+	return WrapPacketConn(pc)
+}
+
+// WrapPacketConn wraps a net.PacketConn with a manet.PacketConn.
+func WrapPacketConn(pc net.PacketConn) (PacketConn, error) {
+	laddr, err := FromNetAddr(pc.LocalAddr())
+	if err != nil {
+		return nil, err
+	}
+
+	return &maPacketConn{
+		PacketConn: pc,
+		laddr:      laddr,
+	}, nil
+}
+
+// InterfaceMultiaddrs will return the addresses matching net.InterfaceAddrs
+func InterfaceMultiaddrs() ([]ma.Multiaddr, error) {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil, err
+	}
+
+	maddrs := make([]ma.Multiaddr, len(addrs))
+	for i, a := range addrs {
+		maddrs[i], err = FromNetAddr(a)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return maddrs, nil
+}
+
+// AddrMatch returns the Multiaddrs that match the protocol stack on addr
+func AddrMatch(match ma.Multiaddr, addrs []ma.Multiaddr) []ma.Multiaddr {
+
+	// we should match transports entirely.
+	p1s := match.Protocols()
+
+	out := make([]ma.Multiaddr, 0, len(addrs))
+	for _, a := range addrs {
+		p2s := a.Protocols()
+		if len(p1s) != len(p2s) {
+			continue
+		}
+
+		match := true
+		for i, p2 := range p2s {
+			if p1s[i].Code != p2.Code {
+				match = false
+				break
+			}
+		}
+		if match {
+			out = append(out, a)
+		}
+	}
+	return out
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr-net/registry.go b/vendor/github.com/multiformats/go-multiaddr-net/registry.go
new file mode 100644
index 000000000..696a953e1
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr-net/registry.go
@@ -0,0 +1,144 @@
+package manet
+
+import (
+	"fmt"
+	"net"
+	"sync"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// FromNetAddrFunc is a generic function which converts a net.Addr to Multiaddress
+type FromNetAddrFunc func(a net.Addr) (ma.Multiaddr, error)
+
+// ToNetAddrFunc is a generic function which converts a Multiaddress to net.Addr
+type ToNetAddrFunc func(ma ma.Multiaddr) (net.Addr, error)
+
+var defaultCodecs *CodecMap
+
+func init() {
+	defaultCodecs = NewCodecMap()
+	defaultCodecs.RegisterNetCodec(tcpAddrSpec)
+	defaultCodecs.RegisterNetCodec(udpAddrSpec)
+	defaultCodecs.RegisterNetCodec(ip4AddrSpec)
+	defaultCodecs.RegisterNetCodec(ip6AddrSpec)
+	defaultCodecs.RegisterNetCodec(ipnetAddrSpec)
+}
+
+// CodecMap holds a map of NetCodecs indexed by their Protocol ID
+// along with parsers for the addresses they use.
+// It is used to keep a list of supported network address codecs (protocols
+// which addresses can be converted to and from multiaddresses).
+type CodecMap struct {
+	codecs       map[string]*NetCodec
+	addrParsers  map[string]FromNetAddrFunc
+	maddrParsers map[string]ToNetAddrFunc
+	lk           sync.Mutex
+}
+
+// NewCodecMap initializes and returns a CodecMap object.
+func NewCodecMap() *CodecMap {
+	return &CodecMap{
+		codecs:       make(map[string]*NetCodec),
+		addrParsers:  make(map[string]FromNetAddrFunc),
+		maddrParsers: make(map[string]ToNetAddrFunc),
+	}
+}
+
+// NetCodec is used to identify a network codec, that is, a network type for
+// which we are able to translate multiaddresses into standard Go net.Addr
+// and back.
+type NetCodec struct {
+	// NetAddrNetworks is an array of strings that may be returned
+	// by net.Addr.Network() calls on addresses belonging to this type
+	NetAddrNetworks []string
+
+	// ProtocolName is the string value for Multiaddr address keys
+	ProtocolName string
+
+	// ParseNetAddr parses a net.Addr belonging to this type into a multiaddr
+	ParseNetAddr FromNetAddrFunc
+
+	// ConvertMultiaddr converts a multiaddr of this type back into a net.Addr
+	ConvertMultiaddr ToNetAddrFunc
+
+	// Protocol returns the multiaddr protocol struct for this type
+	Protocol ma.Protocol
+}
+
+// RegisterNetCodec adds a new NetCodec to the default codecs.
+func RegisterNetCodec(a *NetCodec) {
+	defaultCodecs.RegisterNetCodec(a)
+}
+
+// RegisterNetCodec adds a new NetCodec to the CodecMap. This function is
+// thread safe.
+func (cm *CodecMap) RegisterNetCodec(a *NetCodec) {
+	cm.lk.Lock()
+	defer cm.lk.Unlock()
+	cm.codecs[a.ProtocolName] = a
+	for _, n := range a.NetAddrNetworks {
+		cm.addrParsers[n] = a.ParseNetAddr
+	}
+
+	cm.maddrParsers[a.ProtocolName] = a.ConvertMultiaddr
+}
+
+var tcpAddrSpec = &NetCodec{
+	ProtocolName:     "tcp",
+	NetAddrNetworks:  []string{"tcp", "tcp4", "tcp6"},
+	ParseNetAddr:     parseTCPNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
+var udpAddrSpec = &NetCodec{
+	ProtocolName:     "udp",
+	NetAddrNetworks:  []string{"udp", "udp4", "udp6"},
+	ParseNetAddr:     parseUDPNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
+var ip4AddrSpec = &NetCodec{
+	ProtocolName:     "ip4",
+	NetAddrNetworks:  []string{"ip4"},
+	ParseNetAddr:     parseIPNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
+var ip6AddrSpec = &NetCodec{
+	ProtocolName:     "ip6",
+	NetAddrNetworks:  []string{"ip6"},
+	ParseNetAddr:     parseIPNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
+var ipnetAddrSpec = &NetCodec{
+	ProtocolName:    "ip+net",
+	NetAddrNetworks: []string{"ip+net"},
+	ParseNetAddr:    parseIPPlusNetAddr,
+	ConvertMultiaddr: func(ma.Multiaddr) (net.Addr, error) {
+		return nil, fmt.Errorf("converting ip+net multiaddr not supported")
+	},
+}
+
+func (cm *CodecMap) getAddrParser(net string) (FromNetAddrFunc, error) {
+	cm.lk.Lock()
+	defer cm.lk.Unlock()
+
+	parser, ok := cm.addrParsers[net]
+	if !ok {
+		return nil, fmt.Errorf("unknown network %v", net)
+	}
+	return parser, nil
+}
+
+func (cm *CodecMap) getMaddrParser(name string) (ToNetAddrFunc, error) {
+	cm.lk.Lock()
+	defer cm.lk.Unlock()
+	p, ok := cm.maddrParsers[name]
+	if !ok {
+		return nil, fmt.Errorf("network not supported: %s", name)
+	}
+
+	return p, nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/LICENSE b/vendor/github.com/multiformats/go-multiaddr/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multiaddr/codec.go b/vendor/github.com/multiformats/go-multiaddr/codec.go
new file mode 100644
index 000000000..29573f22d
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/codec.go
@@ -0,0 +1,182 @@
+package multiaddr
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+)
+
+func stringToBytes(s string) ([]byte, error) {
+
+	// consume trailing slashes
+	s = strings.TrimRight(s, "/")
+
+	b := new(bytes.Buffer)
+	sp := strings.Split(s, "/")
+
+	if sp[0] != "" {
+		return nil, fmt.Errorf("invalid multiaddr, must begin with /")
+	}
+
+	// consume first empty elem
+	sp = sp[1:]
+
+	for len(sp) > 0 {
+		p := ProtocolWithName(sp[0])
+		if p.Code == 0 {
+			return nil, fmt.Errorf("no protocol with name %s", sp[0])
+		}
+		b.Write(CodeToVarint(p.Code))
+		sp = sp[1:]
+
+		if p.Size == 0 { // no length.
+			continue
+		}
+
+		if len(sp) < 1 {
+			return nil, fmt.Errorf("protocol requires address, none given: %s", p.Name)
+		}
+
+		if p.Path {
+			// it's a path protocol (terminal).
+			// consume the rest of the address as the next component.
+			sp = []string{"/" + strings.Join(sp, "/")}
+		}
+
+		if p.Transcoder == nil {
+			return nil, fmt.Errorf("no transcoder for %s protocol", p.Name)
+		}
+		a, err := p.Transcoder.StringToBytes(sp[0])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s: %s %s", p.Name, sp[0], err)
+		}
+		b.Write(a)
+		sp = sp[1:]
+	}
+
+	return b.Bytes(), nil
+}
+
+func validateBytes(b []byte) (err error) {
+	for len(b) > 0 {
+		code, n, err := ReadVarintCode(b)
+		if err != nil {
+			return err
+		}
+
+		b = b[n:]
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			return fmt.Errorf("no protocol with code %d", code)
+		}
+
+		if p.Size == 0 {
+			continue
+		}
+
+		size, err := sizeForAddr(p, b)
+		if err != nil {
+			return err
+		}
+
+		if len(b) < size || size < 0 {
+			return fmt.Errorf("invalid value for size")
+		}
+
+		b = b[size:]
+	}
+
+	return nil
+}
+
+func bytesToString(b []byte) (ret string, err error) {
+	s := ""
+
+	for len(b) > 0 {
+		code, n, err := ReadVarintCode(b)
+		if err != nil {
+			return "", err
+		}
+
+		b = b[n:]
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			return "", fmt.Errorf("no protocol with code %d", code)
+		}
+		s += "/" + p.Name
+
+		if p.Size == 0 {
+			continue
+		}
+
+		size, err := sizeForAddr(p, b)
+		if err != nil {
+			return "", err
+		}
+
+		if len(b) < size || size < 0 {
+			return "", fmt.Errorf("invalid value for size")
+		}
+
+		if p.Transcoder == nil {
+			return "", fmt.Errorf("no transcoder for %s protocol", p.Name)
+		}
+		a, err := p.Transcoder.BytesToString(b[:size])
+		if err != nil {
+			return "", err
+		}
+		if len(a) > 0 {
+			s += "/" + a
+		}
+		b = b[size:]
+	}
+
+	return s, nil
+}
+
+func sizeForAddr(p Protocol, b []byte) (int, error) {
+	switch {
+	case p.Size > 0:
+		return (p.Size / 8), nil
+	case p.Size == 0:
+		return 0, nil
+	case p.Path:
+		size, n, err := ReadVarintCode(b)
+		if err != nil {
+			return 0, err
+		}
+		return size + n, nil
+	default:
+		size, n, err := ReadVarintCode(b)
+		if err != nil {
+			return 0, err
+		}
+		return size + n, nil
+	}
+}
+
+func bytesSplit(b []byte) ([][]byte, error) {
+	var ret [][]byte
+	for len(b) > 0 {
+		code, n, err := ReadVarintCode(b)
+		if err != nil {
+			return nil, err
+		}
+
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			return nil, fmt.Errorf("no protocol with code %d", b[0])
+		}
+
+		size, err := sizeForAddr(p, b[n:])
+		if err != nil {
+			return nil, err
+		}
+
+		length := n + size
+		ret = append(ret, b[:length])
+		b = b[length:]
+	}
+
+	return ret, nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/doc.go b/vendor/github.com/multiformats/go-multiaddr/doc.go
new file mode 100644
index 000000000..d8c37b265
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/doc.go
@@ -0,0 +1,36 @@
+/*
+Package multiaddr provides an implementation of the Multiaddr network
+address format. Multiaddr emphasizes explicitness, self-description, and
+portability. It allows applications to treat addresses as opaque tokens,
+and to avoid making assumptions about the address representation (e.g. length).
+Learn more at https://github.com/multiformats/multiaddr
+
+Basic Use:
+
+  import (
+    "bytes"
+    "strings"
+    ma "github.com/multiformats/go-multiaddr"
+  )
+
+  // construct from a string (err signals parse failure)
+  m1, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/1234")
+
+  // construct from bytes (err signals parse failure)
+  m2, err := ma.NewMultiaddrBytes(m1.Bytes())
+
+  // true
+  strings.Equal(m1.String(), "/ip4/127.0.0.1/udp/1234")
+  strings.Equal(m1.String(), m2.String())
+  bytes.Equal(m1.Bytes(), m2.Bytes())
+  m1.Equal(m2)
+  m2.Equal(m1)
+
+  // tunneling (en/decap)
+  printer, _ := ma.NewMultiaddr("/ip4/192.168.0.13/tcp/80")
+  proxy, _ := ma.NewMultiaddr("/ip4/10.20.30.40/tcp/443")
+  printerOverProxy := proxy.Encapsulate(printer)
+  proxyAgain := printerOverProxy.Decapsulate(printer)
+
+*/
+package multiaddr
diff --git a/vendor/github.com/multiformats/go-multiaddr/interface.go b/vendor/github.com/multiformats/go-multiaddr/interface.go
new file mode 100644
index 000000000..c68e4b483
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/interface.go
@@ -0,0 +1,45 @@
+package multiaddr
+
+/*
+Multiaddr is a cross-protocol, cross-platform format for representing
+internet addresses. It emphasizes explicitness and self-description.
+Learn more here: https://github.com/multiformats/multiaddr
+
+Multiaddrs have both a binary and string representation.
+
+    import ma "github.com/multiformats/go-multiaddr"
+
+    addr, err := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/80")
+    // err non-nil when parsing failed.
+
+*/
+type Multiaddr interface {
+	// Equal returns whether two Multiaddrs are exactly equal
+	Equal(Multiaddr) bool
+
+	// Bytes returns the []byte representation of this Multiaddr
+	Bytes() []byte
+
+	// String returns the string representation of this Multiaddr
+	// (may panic if internal state is corrupted)
+	String() string
+
+	// Protocols returns the list of Protocols this Multiaddr includes
+	// will panic if protocol code incorrect (and bytes accessed incorrectly)
+	Protocols() []Protocol
+
+	// Encapsulate wraps this Multiaddr around another. For example:
+	//
+	//      /ip4/1.2.3.4 encapsulate /tcp/80 = /ip4/1.2.3.4/tcp/80
+	//
+	Encapsulate(Multiaddr) Multiaddr
+
+	// Decapsultate removes a Multiaddr wrapping. For example:
+	//
+	//      /ip4/1.2.3.4/tcp/80 decapsulate /ip4/1.2.3.4 = /tcp/80
+	//
+	Decapsulate(Multiaddr) Multiaddr
+
+	// ValueForProtocol returns the value (if any) following the specified protocol
+	ValueForProtocol(code int) (string, error)
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/multiaddr.go b/vendor/github.com/multiformats/go-multiaddr/multiaddr.go
new file mode 100644
index 000000000..2ab437c45
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/multiaddr.go
@@ -0,0 +1,143 @@
+package multiaddr
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"strings"
+)
+
+// multiaddr is the data structure representing a Multiaddr
+type multiaddr struct {
+	bytes []byte
+}
+
+// NewMultiaddr parses and validates an input string, returning a *Multiaddr
+func NewMultiaddr(s string) (a Multiaddr, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			log.Printf("Panic in NewMultiaddr on input %q: %s", s, e)
+			err = fmt.Errorf("%v", e)
+		}
+	}()
+	b, err := stringToBytes(s)
+	if err != nil {
+		return nil, err
+	}
+	return &multiaddr{bytes: b}, nil
+}
+
+// NewMultiaddrBytes initializes a Multiaddr from a byte representation.
+// It validates it as an input string.
+func NewMultiaddrBytes(b []byte) (a Multiaddr, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			log.Printf("Panic in NewMultiaddrBytes on input %q: %s", b, e)
+			err = fmt.Errorf("%v", e)
+		}
+	}()
+
+	if err := validateBytes(b); err != nil {
+		return nil, err
+	}
+
+	return &multiaddr{bytes: b}, nil
+}
+
+// Equal tests whether two multiaddrs are equal
+func (m *multiaddr) Equal(m2 Multiaddr) bool {
+	return bytes.Equal(m.bytes, m2.Bytes())
+}
+
+// Bytes returns the []byte representation of this Multiaddr
+func (m *multiaddr) Bytes() []byte {
+	// consider returning copy to prevent changing underneath us?
+	cpy := make([]byte, len(m.bytes))
+	copy(cpy, m.bytes)
+	return cpy
+}
+
+// String returns the string representation of a Multiaddr
+func (m *multiaddr) String() string {
+	s, err := bytesToString(m.bytes)
+	if err != nil {
+		panic("multiaddr failed to convert back to string. corrupted?")
+	}
+	return s
+}
+
+// Protocols returns the list of protocols this Multiaddr has.
+// will panic in case we access bytes incorrectly.
+func (m *multiaddr) Protocols() []Protocol {
+	ps := make([]Protocol, 0, 8)
+	b := m.bytes
+	for len(b) > 0 {
+		code, n, err := ReadVarintCode(b)
+		if err != nil {
+			panic(err)
+		}
+
+		p := ProtocolWithCode(code)
+		if p.Code == 0 {
+			// this is a panic (and not returning err) because this should've been
+			// caught on constructing the Multiaddr
+			panic(fmt.Errorf("no protocol with code %d", b[0]))
+		}
+		ps = append(ps, p)
+		b = b[n:]
+
+		size, err := sizeForAddr(p, b)
+		if err != nil {
+			panic(err)
+		}
+
+		b = b[size:]
+	}
+	return ps
+}
+
+// Encapsulate wraps a given Multiaddr, returning the resulting joined Multiaddr
+func (m *multiaddr) Encapsulate(o Multiaddr) Multiaddr {
+	mb := m.bytes
+	ob := o.Bytes()
+
+	b := make([]byte, len(mb)+len(ob))
+	copy(b, mb)
+	copy(b[len(mb):], ob)
+	return &multiaddr{bytes: b}
+}
+
+// Decapsulate unwraps Multiaddr up until the given Multiaddr is found.
+func (m *multiaddr) Decapsulate(o Multiaddr) Multiaddr {
+	s1 := m.String()
+	s2 := o.String()
+	i := strings.LastIndex(s1, s2)
+	if i < 0 {
+		// if multiaddr not contained, returns a copy.
+		cpy := make([]byte, len(m.bytes))
+		copy(cpy, m.bytes)
+		return &multiaddr{bytes: cpy}
+	}
+
+	ma, err := NewMultiaddr(s1[:i])
+	if err != nil {
+		panic("Multiaddr.Decapsulate incorrect byte boundaries.")
+	}
+	return ma
+}
+
+var ErrProtocolNotFound = fmt.Errorf("protocol not found in multiaddr")
+
+func (m *multiaddr) ValueForProtocol(code int) (string, error) {
+	for _, sub := range Split(m) {
+		p := sub.Protocols()[0]
+		if p.Code == code {
+			if p.Size == 0 {
+				return "", nil
+			}
+			return strings.SplitN(sub.String(), "/", 3)[2], nil
+		}
+	}
+
+	return "", ErrProtocolNotFound
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/protocols.go b/vendor/github.com/multiformats/go-multiaddr/protocols.go
new file mode 100644
index 000000000..9f78f9867
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/protocols.go
@@ -0,0 +1,142 @@
+package multiaddr
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+)
+
+// Protocol is a Multiaddr protocol description structure.
+type Protocol struct {
+	Code       int
+	Size       int // a size of -1 indicates a length-prefixed variable size
+	Name       string
+	VCode      []byte
+	Path       bool // indicates a path protocol (eg unix, http)
+	Transcoder Transcoder
+}
+
+// You **MUST** register your multicodecs with
+// https://github.com/multiformats/multicodec before adding them here.
+//
+// TODO: Use a single source of truth for all multicodecs instead of
+// distributing them like this...
+const (
+	P_IP4   = 0x0004
+	P_TCP   = 0x0006
+	P_UDP   = 0x0111
+	P_DCCP  = 0x0021
+	P_IP6   = 0x0029
+	P_QUIC  = 0x01CC
+	P_SCTP  = 0x0084
+	P_UDT   = 0x012D
+	P_UTP   = 0x012E
+	P_UNIX  = 0x0190
+	P_IPFS  = 0x01A5
+	P_HTTP  = 0x01E0
+	P_HTTPS = 0x01BB
+	P_ONION = 0x01BC
+)
+
+// These are special sizes
+const (
+	LengthPrefixedVarSize = -1
+)
+
+// Protocols is the list of multiaddr protocols supported by this module.
+var Protocols = []Protocol{
+	Protocol{P_IP4, 32, "ip4", CodeToVarint(P_IP4), false, TranscoderIP4},
+	Protocol{P_TCP, 16, "tcp", CodeToVarint(P_TCP), false, TranscoderPort},
+	Protocol{P_UDP, 16, "udp", CodeToVarint(P_UDP), false, TranscoderPort},
+	Protocol{P_DCCP, 16, "dccp", CodeToVarint(P_DCCP), false, TranscoderPort},
+	Protocol{P_IP6, 128, "ip6", CodeToVarint(P_IP6), false, TranscoderIP6},
+	// these require varint:
+	Protocol{P_SCTP, 16, "sctp", CodeToVarint(P_SCTP), false, TranscoderPort},
+	Protocol{P_ONION, 96, "onion", CodeToVarint(P_ONION), false, TranscoderOnion},
+	Protocol{P_UTP, 0, "utp", CodeToVarint(P_UTP), false, nil},
+	Protocol{P_UDT, 0, "udt", CodeToVarint(P_UDT), false, nil},
+	Protocol{P_QUIC, 0, "quic", CodeToVarint(P_QUIC), false, nil},
+	Protocol{P_HTTP, 0, "http", CodeToVarint(P_HTTP), false, nil},
+	Protocol{P_HTTPS, 0, "https", CodeToVarint(P_HTTPS), false, nil},
+	Protocol{P_IPFS, LengthPrefixedVarSize, "ipfs", CodeToVarint(P_IPFS), false, TranscoderIPFS},
+	Protocol{P_UNIX, LengthPrefixedVarSize, "unix", CodeToVarint(P_UNIX), true, TranscoderUnix},
+}
+
+func AddProtocol(p Protocol) error {
+	for _, pt := range Protocols {
+		if pt.Code == p.Code {
+			return fmt.Errorf("protocol code %d already taken by %q", p.Code, pt.Name)
+		}
+		if pt.Name == p.Name {
+			return fmt.Errorf("protocol by the name %q already exists", p.Name)
+		}
+	}
+
+	Protocols = append(Protocols, p)
+	return nil
+}
+
+// ProtocolWithName returns the Protocol description with given string name.
+func ProtocolWithName(s string) Protocol {
+	for _, p := range Protocols {
+		if p.Name == s {
+			return p
+		}
+	}
+	return Protocol{}
+}
+
+// ProtocolWithCode returns the Protocol description with given protocol code.
+func ProtocolWithCode(c int) Protocol {
+	for _, p := range Protocols {
+		if p.Code == c {
+			return p
+		}
+	}
+	return Protocol{}
+}
+
+// ProtocolsWithString returns a slice of protocols matching given string.
+func ProtocolsWithString(s string) ([]Protocol, error) {
+	s = strings.Trim(s, "/")
+	sp := strings.Split(s, "/")
+	if len(sp) == 0 {
+		return nil, nil
+	}
+
+	t := make([]Protocol, len(sp))
+	for i, name := range sp {
+		p := ProtocolWithName(name)
+		if p.Code == 0 {
+			return nil, fmt.Errorf("no protocol with name: %s", name)
+		}
+		t[i] = p
+	}
+	return t, nil
+}
+
+// CodeToVarint converts an integer to a varint-encoded []byte
+func CodeToVarint(num int) []byte {
+	buf := make([]byte, (num/7)+1) // varint package is uint64
+	n := binary.PutUvarint(buf, uint64(num))
+	return buf[:n]
+}
+
+// VarintToCode converts a varint-encoded []byte to an integer protocol code
+func VarintToCode(buf []byte) int {
+	num, _, err := ReadVarintCode(buf)
+	if err != nil {
+		panic(err)
+	}
+	return num
+}
+
+// ReadVarintCode reads a varint code from the beginning of buf.
+// returns the code, and the number of bytes read.
+func ReadVarintCode(buf []byte) (int, int, error) {
+	num, n := binary.Uvarint(buf)
+	if n < 0 {
+		return 0, 0, fmt.Errorf("varints larger than uint64 not yet supported")
+	}
+	return int(num), n, nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/transcoders.go b/vendor/github.com/multiformats/go-multiaddr/transcoders.go
new file mode 100644
index 000000000..f6739ed41
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/transcoders.go
@@ -0,0 +1,181 @@
+package multiaddr
+
+import (
+	"encoding/base32"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	mh "github.com/multiformats/go-multihash"
+)
+
+type Transcoder interface {
+	StringToBytes(string) ([]byte, error)
+	BytesToString([]byte) (string, error)
+}
+
+func NewTranscoderFromFunctions(s2b func(string) ([]byte, error),
+	b2s func([]byte) (string, error)) Transcoder {
+
+	return twrp{s2b, b2s}
+}
+
+type twrp struct {
+	strtobyte func(string) ([]byte, error)
+	bytetostr func([]byte) (string, error)
+}
+
+func (t twrp) StringToBytes(s string) ([]byte, error) {
+	return t.strtobyte(s)
+}
+func (t twrp) BytesToString(b []byte) (string, error) {
+	return t.bytetostr(b)
+}
+
+var TranscoderIP4 = NewTranscoderFromFunctions(ip4StB, ipBtS)
+var TranscoderIP6 = NewTranscoderFromFunctions(ip6StB, ipBtS)
+
+func ip4StB(s string) ([]byte, error) {
+	i := net.ParseIP(s).To4()
+	if i == nil {
+		return nil, fmt.Errorf("failed to parse ip4 addr: %s", s)
+	}
+	return i, nil
+}
+
+func ip6StB(s string) ([]byte, error) {
+	i := net.ParseIP(s).To16()
+	if i == nil {
+		return nil, fmt.Errorf("failed to parse ip4 addr: %s", s)
+	}
+	return i, nil
+}
+
+func ipBtS(b []byte) (string, error) {
+	return net.IP(b).String(), nil
+}
+
+var TranscoderPort = NewTranscoderFromFunctions(portStB, portBtS)
+
+func portStB(s string) ([]byte, error) {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse port addr: %s", err)
+	}
+	if i >= 65536 {
+		return nil, fmt.Errorf("failed to parse port addr: %s", "greater than 65536")
+	}
+	b := make([]byte, 2)
+	binary.BigEndian.PutUint16(b, uint16(i))
+	return b, nil
+}
+
+func portBtS(b []byte) (string, error) {
+	i := binary.BigEndian.Uint16(b)
+	return strconv.Itoa(int(i)), nil
+}
+
+var TranscoderOnion = NewTranscoderFromFunctions(onionStB, onionBtS)
+
+func onionStB(s string) ([]byte, error) {
+	addr := strings.Split(s, ":")
+	if len(addr) != 2 {
+		return nil, fmt.Errorf("failed to parse onion addr: %s does not contain a port number.", s)
+	}
+
+	// onion address without the ".onion" substring
+	if len(addr[0]) != 16 {
+		return nil, fmt.Errorf("failed to parse onion addr: %s not a Tor onion address.", s)
+	}
+	onionHostBytes, err := base32.StdEncoding.DecodeString(strings.ToUpper(addr[0]))
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode base32 onion addr: %s %s", s, err)
+	}
+
+	// onion port number
+	i, err := strconv.Atoi(addr[1])
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse onion addr: %s", err)
+	}
+	if i >= 65536 {
+		return nil, fmt.Errorf("failed to parse onion addr: %s", "port greater than 65536")
+	}
+	if i < 1 {
+		return nil, fmt.Errorf("failed to parse onion addr: %s", "port less than 1")
+	}
+
+	onionPortBytes := make([]byte, 2)
+	binary.BigEndian.PutUint16(onionPortBytes, uint16(i))
+	bytes := []byte{}
+	bytes = append(bytes, onionHostBytes...)
+	bytes = append(bytes, onionPortBytes...)
+	return bytes, nil
+}
+
+func onionBtS(b []byte) (string, error) {
+	addr := strings.ToLower(base32.StdEncoding.EncodeToString(b[0:10]))
+	port := binary.BigEndian.Uint16(b[10:12])
+	return addr + ":" + strconv.Itoa(int(port)), nil
+}
+
+var TranscoderIPFS = NewTranscoderFromFunctions(ipfsStB, ipfsBtS)
+
+func ipfsStB(s string) ([]byte, error) {
+	// the address is a varint prefixed multihash string representation
+	m, err := mh.FromB58String(s)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse ipfs addr: %s %s", s, err)
+	}
+	size := CodeToVarint(len(m))
+	b := append(size, m...)
+	return b, nil
+}
+
+func ipfsBtS(b []byte) (string, error) {
+	// the address is a varint-prefixed multihash string representation
+	size, n, err := ReadVarintCode(b)
+	if err != nil {
+		return "", err
+	}
+
+	b = b[n:]
+	if len(b) != size {
+		return "", errors.New("inconsistent lengths")
+	}
+	m, err := mh.Cast(b)
+	if err != nil {
+		return "", err
+	}
+	return m.B58String(), nil
+}
+
+var TranscoderUnix = NewTranscoderFromFunctions(unixStB, unixBtS)
+
+func unixStB(s string) ([]byte, error) {
+	// the address is the whole remaining string, prefixed by a varint len
+	size := CodeToVarint(len(s))
+	b := append(size, []byte(s)...)
+	return b, nil
+}
+
+func unixBtS(b []byte) (string, error) {
+	// the address is a varint len prefixed string
+	size, n, err := ReadVarintCode(b)
+	if err != nil {
+		return "", err
+	}
+
+	b = b[n:]
+	if len(b) != size {
+		return "", errors.New("inconsistent lengths")
+	}
+	if size == 0 {
+		return "", errors.New("invalid length")
+	}
+	s := string(b)
+	s = s[1:] // remove starting slash
+	return s, nil
+}
diff --git a/vendor/github.com/multiformats/go-multiaddr/util.go b/vendor/github.com/multiformats/go-multiaddr/util.go
new file mode 100644
index 000000000..d1b54afbb
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multiaddr/util.go
@@ -0,0 +1,56 @@
+package multiaddr
+
+import "fmt"
+
+// Split returns the sub-address portions of a multiaddr.
+func Split(m Multiaddr) []Multiaddr {
+	split, err := bytesSplit(m.Bytes())
+	if err != nil {
+		panic(fmt.Errorf("invalid multiaddr %s", m.String()))
+	}
+
+	addrs := make([]Multiaddr, len(split))
+	for i, addr := range split {
+		addrs[i] = &multiaddr{bytes: addr}
+	}
+	return addrs
+}
+
+// Join returns a combination of addresses.
+func Join(ms ...Multiaddr) Multiaddr {
+
+	length := 0
+	bs := make([][]byte, len(ms))
+	for i, m := range ms {
+		bs[i] = m.Bytes()
+		length += len(bs[i])
+	}
+
+	bidx := 0
+	b := make([]byte, length)
+	for _, mb := range bs {
+		for i := range mb {
+			b[bidx] = mb[i]
+			bidx++
+		}
+	}
+	return &multiaddr{bytes: b}
+}
+
+// Cast re-casts a byte slice as a multiaddr. will panic if it fails to parse.
+func Cast(b []byte) Multiaddr {
+	_, err := bytesToString(b)
+	if err != nil {
+		panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+	}
+	return &multiaddr{bytes: b}
+}
+
+// StringCast like Cast, but parses a string. Will also panic if it fails to parse.
+func StringCast(s string) Multiaddr {
+	m, err := NewMultiaddr(s)
+	if err != nil {
+		panic(fmt.Errorf("multiaddr failed to parse: %s", err))
+	}
+	return m
+}
diff --git a/vendor/github.com/multiformats/go-multihash/LICENSE b/vendor/github.com/multiformats/go-multihash/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multihash/io.go b/vendor/github.com/multiformats/go-multihash/io.go
new file mode 100644
index 000000000..462901687
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/io.go
@@ -0,0 +1,103 @@
+package multihash
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+	"math"
+)
+
+// Reader is an io.Reader wrapper that exposes a function
+// to read a whole multihash, parse it, and return it.
+type Reader interface {
+	io.Reader
+
+	ReadMultihash() (Multihash, error)
+}
+
+// Writer is an io.Writer wrapper that exposes a function
+// to write a whole multihash.
+type Writer interface {
+	io.Writer
+
+	WriteMultihash(Multihash) error
+}
+
+// NewReader wraps an io.Reader with a multihash.Reader
+func NewReader(r io.Reader) Reader {
+	return &mhReader{r}
+}
+
+// NewWriter wraps an io.Writer with a multihash.Writer
+func NewWriter(w io.Writer) Writer {
+	return &mhWriter{w}
+}
+
+type mhReader struct {
+	r io.Reader
+}
+
+func (r *mhReader) Read(buf []byte) (n int, err error) {
+	return r.r.Read(buf)
+}
+
+func (r *mhReader) ReadByte() (byte, error) {
+	if br, ok := r.r.(io.ByteReader); ok {
+		return br.ReadByte()
+	}
+	var b [1]byte
+	n, err := r.r.Read(b[:])
+	if n == 1 {
+		return b[0], nil
+	}
+	if err == nil {
+		if n != 0 {
+			panic("reader returned an invalid length")
+		}
+		err = io.ErrNoProgress
+	}
+	return 0, err
+}
+
+func (r *mhReader) ReadMultihash() (Multihash, error) {
+	code, err := binary.ReadUvarint(r)
+	if err != nil {
+		return nil, err
+	}
+
+	length, err := binary.ReadUvarint(r)
+	if err != nil {
+		return nil, err
+	}
+	if length > math.MaxInt32 {
+		return nil, errors.New("digest too long, supporting only <= 2^31-1")
+	}
+
+	pre := make([]byte, 2*binary.MaxVarintLen64)
+	spot := pre
+	n := binary.PutUvarint(spot, code)
+	spot = pre[n:]
+	n += binary.PutUvarint(spot, length)
+
+	buf := make([]byte, int(length)+n)
+	copy(buf, pre[:n])
+
+	if _, err := io.ReadFull(r.r, buf[n:]); err != nil {
+		return nil, err
+	}
+
+	return Cast(buf)
+}
+
+type mhWriter struct {
+	w io.Writer
+}
+
+func (w *mhWriter) Write(buf []byte) (n int, err error) {
+	return w.w.Write(buf)
+}
+
+func (w *mhWriter) WriteMultihash(m Multihash) error {
+	_, err := w.w.Write([]byte(m))
+	return err
+}
diff --git a/vendor/github.com/multiformats/go-multihash/multihash.go b/vendor/github.com/multiformats/go-multihash/multihash.go
new file mode 100644
index 000000000..92b4fdab4
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash.go
@@ -0,0 +1,300 @@
+// Package multihash is the Go implementation of
+// https://github.com/multiformats/multihash, or self-describing
+// hashes.
+package multihash
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math"
+
+	b58 "github.com/mr-tron/base58/base58"
+)
+
+// errors
+var (
+	ErrUnknownCode      = errors.New("unknown multihash code")
+	ErrTooShort         = errors.New("multihash too short. must be >= 2 bytes")
+	ErrTooLong          = errors.New("multihash too long. must be < 129 bytes")
+	ErrLenNotSupported  = errors.New("multihash does not yet support digests longer than 127 bytes")
+	ErrInvalidMultihash = errors.New("input isn't valid multihash")
+
+	ErrVarintBufferShort = errors.New("uvarint: buffer too small")
+	ErrVarintTooLong     = errors.New("uvarint: varint too big (max 64bit)")
+)
+
+// ErrInconsistentLen is returned when a decoded multihash has an inconsistent length
+type ErrInconsistentLen struct {
+	dm *DecodedMultihash
+}
+
+func (e ErrInconsistentLen) Error() string {
+	return fmt.Sprintf("multihash length inconsistent: %v", e.dm)
+}
+
+// constants
+const (
+	ID         = 0x00
+	SHA1       = 0x11
+	SHA2_256   = 0x12
+	SHA2_512   = 0x13
+	SHA3_224   = 0x17
+	SHA3_256   = 0x16
+	SHA3_384   = 0x15
+	SHA3_512   = 0x14
+	SHA3       = SHA3_512
+	KECCAK_224 = 0x1A
+	KECCAK_256 = 0x1B
+	KECCAK_384 = 0x1C
+	KECCAK_512 = 0x1D
+
+	SHAKE_128 = 0x18
+	SHAKE_256 = 0x19
+
+	BLAKE2B_MIN = 0xb201
+	BLAKE2B_MAX = 0xb240
+	BLAKE2S_MIN = 0xb241
+	BLAKE2S_MAX = 0xb260
+
+	DBL_SHA2_256 = 0x56
+
+	MURMUR3 = 0x22
+)
+
+func init() {
+	// Add blake2b (64 codes)
+	for c := uint64(BLAKE2B_MIN); c <= BLAKE2B_MAX; c++ {
+		n := c - BLAKE2B_MIN + 1
+		name := fmt.Sprintf("blake2b-%d", n*8)
+		Names[name] = c
+		Codes[c] = name
+		DefaultLengths[c] = int(n)
+	}
+
+	// Add blake2s (32 codes)
+	for c := uint64(BLAKE2S_MIN); c <= BLAKE2S_MAX; c++ {
+		n := c - BLAKE2S_MIN + 1
+		name := fmt.Sprintf("blake2s-%d", n*8)
+		Names[name] = c
+		Codes[c] = name
+		DefaultLengths[c] = int(n)
+	}
+}
+
+// Names maps the name of a hash to the code
+var Names = map[string]uint64{
+	"id":           ID,
+	"sha1":         SHA1,
+	"sha2-256":     SHA2_256,
+	"sha2-512":     SHA2_512,
+	"sha3":         SHA3_512,
+	"sha3-224":     SHA3_224,
+	"sha3-256":     SHA3_256,
+	"sha3-384":     SHA3_384,
+	"sha3-512":     SHA3_512,
+	"dbl-sha2-256": DBL_SHA2_256,
+	"murmur3":      MURMUR3,
+	"keccak-224":   KECCAK_224,
+	"keccak-256":   KECCAK_256,
+	"keccak-384":   KECCAK_384,
+	"keccak-512":   KECCAK_512,
+	"shake-128":    SHAKE_128,
+	"shake-256":    SHAKE_256,
+}
+
+// Codes maps a hash code to it's name
+var Codes = map[uint64]string{
+	ID:           "id",
+	SHA1:         "sha1",
+	SHA2_256:     "sha2-256",
+	SHA2_512:     "sha2-512",
+	SHA3_224:     "sha3-224",
+	SHA3_256:     "sha3-256",
+	SHA3_384:     "sha3-384",
+	SHA3_512:     "sha3-512",
+	DBL_SHA2_256: "dbl-sha2-256",
+	MURMUR3:      "murmur3",
+	KECCAK_224:   "keccak-224",
+	KECCAK_256:   "keccak-256",
+	KECCAK_384:   "keccak-384",
+	KECCAK_512:   "keccak-512",
+	SHAKE_128:    "shake-128",
+	SHAKE_256:    "shake-256",
+}
+
+// DefaultLengths maps a hash code to it's default length
+var DefaultLengths = map[uint64]int{
+	ID:           -1,
+	SHA1:         20,
+	SHA2_256:     32,
+	SHA2_512:     64,
+	SHA3_224:     28,
+	SHA3_256:     32,
+	SHA3_384:     48,
+	SHA3_512:     64,
+	DBL_SHA2_256: 32,
+	KECCAK_224:   28,
+	KECCAK_256:   32,
+	MURMUR3:      4,
+	KECCAK_384:   48,
+	KECCAK_512:   64,
+	SHAKE_128:    32,
+	SHAKE_256:    64,
+}
+
+func uvarint(buf []byte) (uint64, []byte, error) {
+	n, c := binary.Uvarint(buf)
+
+	if c == 0 {
+		return n, buf, ErrVarintBufferShort
+	} else if c < 0 {
+		return n, buf[-c:], ErrVarintTooLong
+	} else {
+		return n, buf[c:], nil
+	}
+}
+
+// DecodedMultihash represents a parsed multihash and allows
+// easy access to the different parts of a multihash.
+type DecodedMultihash struct {
+	Code   uint64
+	Name   string
+	Length int    // Length is just int as it is type of len() opearator
+	Digest []byte // Digest holds the raw multihash bytes
+}
+
+// Multihash is byte slice with the following form:
+// <hash function code><digest size><hash function output>.
+// See the spec for more information.
+type Multihash []byte
+
+// HexString returns the hex-encoded representation of a multihash.
+func (m *Multihash) HexString() string {
+	return hex.EncodeToString([]byte(*m))
+}
+
+// String is an alias to HexString().
+func (m *Multihash) String() string {
+	return m.HexString()
+}
+
+// FromHexString parses a hex-encoded multihash.
+func FromHexString(s string) (Multihash, error) {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return Multihash{}, err
+	}
+
+	return Cast(b)
+}
+
+// B58String returns the B58-encoded representation of a multihash.
+func (m Multihash) B58String() string {
+	return b58.Encode([]byte(m))
+}
+
+// FromB58String parses a B58-encoded multihash.
+func FromB58String(s string) (m Multihash, err error) {
+	b, err := b58.Decode(s)
+	if err != nil {
+		return Multihash{}, ErrInvalidMultihash
+	}
+
+	return Cast(b)
+}
+
+// Cast casts a buffer onto a multihash, and returns an error
+// if it does not work.
+func Cast(buf []byte) (Multihash, error) {
+	dm, err := Decode(buf)
+	if err != nil {
+		return Multihash{}, err
+	}
+
+	if !ValidCode(dm.Code) {
+		return Multihash{}, ErrUnknownCode
+	}
+
+	return Multihash(buf), nil
+}
+
+// Decode parses multihash bytes into a DecodedMultihash.
+func Decode(buf []byte) (*DecodedMultihash, error) {
+
+	if len(buf) < 2 {
+		return nil, ErrTooShort
+	}
+
+	var err error
+	var code, length uint64
+
+	code, buf, err = uvarint(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	length, buf, err = uvarint(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if length > math.MaxInt32 {
+		return nil, errors.New("digest too long, supporting only <= 2^31-1")
+	}
+
+	dm := &DecodedMultihash{
+		Code:   code,
+		Name:   Codes[code],
+		Length: int(length),
+		Digest: buf,
+	}
+
+	if len(dm.Digest) != dm.Length {
+		return nil, ErrInconsistentLen{dm}
+	}
+
+	return dm, nil
+}
+
+// Encode a hash digest along with the specified function code.
+// Note: the length is derived from the length of the digest itself.
+func Encode(buf []byte, code uint64) ([]byte, error) {
+
+	if !ValidCode(code) {
+		return nil, ErrUnknownCode
+	}
+
+	start := make([]byte, 2*binary.MaxVarintLen64)
+	spot := start
+	n := binary.PutUvarint(spot, code)
+	spot = start[n:]
+	n += binary.PutUvarint(spot, uint64(len(buf)))
+
+	return append(start[:n], buf...), nil
+}
+
+// EncodeName is like Encode() but providing a string name
+// instead of a numeric code. See Names for allowed values.
+func EncodeName(buf []byte, name string) ([]byte, error) {
+	return Encode(buf, Names[name])
+}
+
+// ValidCode checks whether a multihash code is valid.
+func ValidCode(code uint64) bool {
+	if AppCode(code) {
+		return true
+	}
+
+	if _, ok := Codes[code]; ok {
+		return true
+	}
+
+	return false
+}
+
+// AppCode checks whether a multihash code is part of the App range.
+func AppCode(code uint64) bool {
+	return code >= 0 && code < 0x10
+}
diff --git a/vendor/github.com/multiformats/go-multihash/multihash/LICENSE b/vendor/github.com/multiformats/go-multihash/multihash/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/multihash/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multihash/sum.go b/vendor/github.com/multiformats/go-multihash/sum.go
new file mode 100644
index 000000000..af3f0798a
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/sum.go
@@ -0,0 +1,215 @@
+package multihash
+
+import (
+	"crypto/sha1"
+	"crypto/sha512"
+	"errors"
+	"fmt"
+
+	keccak "github.com/gxed/hashland/keccakpg"
+	blake2b "github.com/minio/blake2b-simd"
+	sha256 "github.com/minio/sha256-simd"
+	murmur3 "github.com/spaolacci/murmur3"
+	blake2s "golang.org/x/crypto/blake2s"
+	sha3 "golang.org/x/crypto/sha3"
+)
+
+// ErrSumNotSupported is returned when the Sum function code is not implemented
+var ErrSumNotSupported = errors.New("Function not implemented. Complain to lib maintainer.")
+
+// Sum obtains the cryptographic sum of a given buffer. The length parameter
+// indicates the length of the resulting digest and passing a negative value
+// use default length values for the selected hash function.
+func Sum(data []byte, code uint64, length int) (Multihash, error) {
+	m := Multihash{}
+	err := error(nil)
+	if !ValidCode(code) {
+		return m, fmt.Errorf("invalid multihash code %d", code)
+	}
+
+	if length < 0 {
+		var ok bool
+		length, ok = DefaultLengths[code]
+		if !ok {
+			return m, fmt.Errorf("no default length for code %d", code)
+		}
+	}
+
+	var d []byte
+	switch {
+	case isBlake2s(code):
+		olen := code - BLAKE2S_MIN + 1
+		switch olen {
+		case 32:
+			out := blake2s.Sum256(data)
+			d = out[:]
+		default:
+			return nil, fmt.Errorf("unsupported length for blake2s: %d", olen)
+		}
+	case isBlake2b(code):
+		olen := uint8(code - BLAKE2B_MIN + 1)
+		d = sumBlake2b(olen, data)
+	default:
+		switch code {
+		case ID:
+			d, err = sumID(data, length)
+		case SHA1:
+			d = sumSHA1(data)
+		case SHA2_256:
+			d = sumSHA256(data)
+		case SHA2_512:
+			d = sumSHA512(data)
+		case KECCAK_224:
+			d = sumKeccak224(data)
+		case KECCAK_256:
+			d = sumKeccak256(data)
+		case KECCAK_384:
+			d = sumKeccak384(data)
+		case KECCAK_512:
+			d = sumKeccak512(data)
+		case SHA3_224:
+			d = sumSHA3_224(data)
+		case SHA3_256:
+			d = sumSHA3_256(data)
+		case SHA3_384:
+			d = sumSHA3_384(data)
+		case SHA3_512:
+			d = sumSHA3_512(data)
+		case DBL_SHA2_256:
+			d = sumSHA256(sumSHA256(data))
+		case MURMUR3:
+			d, err = sumMURMUR3(data)
+		case SHAKE_128:
+			d = sumSHAKE128(data)
+		case SHAKE_256:
+			d = sumSHAKE256(data)
+		default:
+			return m, ErrSumNotSupported
+		}
+	}
+	if err != nil {
+		return m, err
+	}
+	if length >= 0 {
+		d = d[:length]
+	}
+	return Encode(d, code)
+}
+
+func isBlake2s(code uint64) bool {
+	return code >= BLAKE2S_MIN && code <= BLAKE2S_MAX
+}
+func isBlake2b(code uint64) bool {
+	return code >= BLAKE2B_MIN && code <= BLAKE2B_MAX
+}
+
+func sumBlake2b(size uint8, data []byte) []byte {
+	hasher, err := blake2b.New(&blake2b.Config{Size: size})
+	if err != nil {
+		panic(err)
+	}
+
+	if _, err := hasher.Write(data); err != nil {
+		panic(err)
+	}
+
+	return hasher.Sum(nil)[:]
+}
+
+func sumID(data []byte, length int) ([]byte, error) {
+	if length >= 0 && length != len(data) {
+		return nil, fmt.Errorf("the length of the identity hash (%d) must be equal to the length of the data (%d)",
+			length, len(data))
+
+	}
+	return data, nil
+}
+
+func sumSHA1(data []byte) []byte {
+	a := sha1.Sum(data)
+	return a[0:20]
+}
+
+func sumSHA256(data []byte) []byte {
+	a := sha256.Sum256(data)
+	return a[0:32]
+}
+
+func sumSHA512(data []byte) []byte {
+	a := sha512.Sum512(data)
+	return a[0:64]
+}
+
+func sumKeccak224(data []byte) []byte {
+	h := keccak.New224()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func sumKeccak256(data []byte) []byte {
+	h := keccak.New256()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func sumKeccak384(data []byte) []byte {
+	h := keccak.New384()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func sumKeccak512(data []byte) []byte {
+	h := keccak.New512()
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func sumSHA3(data []byte) ([]byte, error) {
+	h := sha3.New512()
+	if _, err := h.Write(data); err != nil {
+		return nil, err
+	}
+	return h.Sum(nil), nil
+}
+
+func sumSHA3_512(data []byte) []byte {
+	a := sha3.Sum512(data)
+	return a[:]
+}
+
+func sumMURMUR3(data []byte) ([]byte, error) {
+	number := murmur3.Sum32(data)
+	bytes := make([]byte, 4)
+	for i := range bytes {
+		bytes[i] = byte(number & 0xff)
+		number >>= 8
+	}
+	return bytes, nil
+}
+
+func sumSHAKE128(data []byte) []byte {
+	bytes := make([]byte, 32)
+	sha3.ShakeSum128(bytes, data)
+	return bytes
+}
+
+func sumSHAKE256(data []byte) []byte {
+	bytes := make([]byte, 64)
+	sha3.ShakeSum256(bytes, data)
+	return bytes
+}
+
+func sumSHA3_384(data []byte) []byte {
+	a := sha3.Sum384(data)
+	return a[:]
+}
+
+func sumSHA3_256(data []byte) []byte {
+	a := sha3.Sum256(data)
+	return a[:]
+}
+
+func sumSHA3_224(data []byte) []byte {
+	a := sha3.Sum224(data)
+	return a[:]
+}
diff --git a/vendor/github.com/multiformats/go-multihash/test/sharness/bin b/vendor/github.com/multiformats/go-multihash/test/sharness/bin
new file mode 120000
index 000000000..19f285ac7
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multihash/test/sharness/bin
@@ -0,0 +1 @@
+../bin
\ No newline at end of file
diff --git a/vendor/github.com/multiformats/go-multistream/LICENSE b/vendor/github.com/multiformats/go-multistream/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multistream/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/multiformats/go-multistream/client.go b/vendor/github.com/multiformats/go-multistream/client.go
new file mode 100644
index 000000000..eae8dea3b
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multistream/client.go
@@ -0,0 +1,83 @@
+package multistream
+
+import (
+	"errors"
+	"io"
+)
+
+// ErrNotSupported is the error returned when the muxer does not support
+// the protocol specified for the handshake.
+var ErrNotSupported = errors.New("protocol not supported")
+
+// SelectProtoOrFail performs the initial multistream handshake
+// to inform the muxer of the protocol that will be used to communicate
+// on this ReadWriteCloser. It returns an error if, for example,
+// the muxer does not know how to handle this protocol.
+func SelectProtoOrFail(proto string, rwc io.ReadWriteCloser) error {
+	err := handshake(rwc)
+	if err != nil {
+		return err
+	}
+
+	return trySelect(proto, rwc)
+}
+
+// SelectOneOf will perform handshakes with the protocols on the given slice
+// until it finds one which is supported by the muxer.
+func SelectOneOf(protos []string, rwc io.ReadWriteCloser) (string, error) {
+	err := handshake(rwc)
+	if err != nil {
+		return "", err
+	}
+
+	for _, p := range protos {
+		err := trySelect(p, rwc)
+		switch err {
+		case nil:
+			return p, nil
+		case ErrNotSupported:
+		default:
+			return "", err
+		}
+	}
+	return "", ErrNotSupported
+}
+
+func handshake(rwc io.ReadWriteCloser) error {
+	tok, err := ReadNextToken(rwc)
+	if err != nil {
+		return err
+	}
+
+	if tok != ProtocolID {
+		return errors.New("received mismatch in protocol id")
+	}
+
+	err = delimWrite(rwc, []byte(ProtocolID))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func trySelect(proto string, rwc io.ReadWriteCloser) error {
+	err := delimWrite(rwc, []byte(proto))
+	if err != nil {
+		return err
+	}
+
+	tok, err := ReadNextToken(rwc)
+	if err != nil {
+		return err
+	}
+
+	switch tok {
+	case proto:
+		return nil
+	case "na":
+		return ErrNotSupported
+	default:
+		return errors.New("unrecognized response: " + tok)
+	}
+}
diff --git a/vendor/github.com/multiformats/go-multistream/lazyClient.go b/vendor/github.com/multiformats/go-multistream/lazyClient.go
new file mode 100644
index 000000000..311e2cbc9
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multistream/lazyClient.go
@@ -0,0 +1,142 @@
+package multistream
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"sync"
+)
+
+// Multistream represents in essense a ReadWriteCloser, or a single
+// communication wire which supports multiple streams on it. Each
+// stream is identified by a protocol tag.
+type Multistream interface {
+	io.ReadWriteCloser
+}
+
+// NewMSSelect returns a new Multistream which is able to perform
+// protocol selection with a MultistreamMuxer.
+func NewMSSelect(c io.ReadWriteCloser, proto string) Multistream {
+	return &lazyClientConn{
+		protos: []string{ProtocolID, proto},
+		con:    c,
+	}
+}
+
+// NewMultistream returns a multistream for the given protocol. This will not
+// perform any protocol selection. If you are using a MultistreamMuxer, use
+// NewMSSelect.
+func NewMultistream(c io.ReadWriteCloser, proto string) Multistream {
+	return &lazyClientConn{
+		protos: []string{proto},
+		con:    c,
+	}
+}
+
+// lazyClientConn is a ReadWriteCloser adapter that lazily negotiates a protocol
+// using multistream-select on first use.
+//
+// It *does not* block writes waiting for the other end to respond. Instead, it
+// simply assumes the negotiation went successfully and starts writing data.
+// See: https://github.com/multiformats/go-multistream/issues/20
+type lazyClientConn struct {
+	// Used to ensure we only trigger the write half of the handshake once.
+	rhandshakeOnce sync.Once
+	rerr           error
+
+	// Used to ensure we only trigger the read half of the handshake once.
+	whandshakeOnce sync.Once
+	werr           error
+
+	// The sequence of protocols to negotiate.
+	protos []string
+
+	// The inner connection.
+	con io.ReadWriteCloser
+}
+
+// Read reads data from the io.ReadWriteCloser.
+//
+// If the protocol hasn't yet been negotiated, this method triggers the write
+// half of the handshake and then waits for the read half to complete.
+//
+// It returns an error if the read half of the handshake fails.
+func (l *lazyClientConn) Read(b []byte) (int, error) {
+	l.rhandshakeOnce.Do(func() {
+		go l.whandshakeOnce.Do(l.doWriteHandshake)
+		l.doReadHandshake()
+	})
+	if l.rerr != nil {
+		return 0, l.rerr
+	}
+	if len(b) == 0 {
+		return 0, nil
+	}
+
+	return l.con.Read(b)
+}
+
+func (l *lazyClientConn) doReadHandshake() {
+	for _, proto := range l.protos {
+		// read protocol
+		tok, err := ReadNextToken(l.con)
+		if err != nil {
+			l.rerr = err
+			return
+		}
+
+		if tok != proto {
+			l.rerr = fmt.Errorf("protocol mismatch in lazy handshake ( %s != %s )", tok, proto)
+			return
+		}
+	}
+}
+
+func (l *lazyClientConn) doWriteHandshake() {
+	l.doWriteHandshakeWithData(nil)
+}
+
+// Perform the write handshake but *also* write some extra data.
+func (l *lazyClientConn) doWriteHandshakeWithData(extra []byte) int {
+	buf := bufio.NewWriter(l.con)
+	for _, proto := range l.protos {
+		l.werr = delimWrite(buf, []byte(proto))
+		if l.werr != nil {
+			return 0
+		}
+	}
+
+	n := 0
+	if len(extra) > 0 {
+		n, l.werr = buf.Write(extra)
+		if l.werr != nil {
+			return n
+		}
+	}
+	l.werr = buf.Flush()
+	return n
+}
+
+// Write writes the given buffer to the underlying connection.
+//
+// If the protocol has not yet been negotiated, write waits for the write half
+// of the handshake to complete triggers (but does not wait for) the read half.
+//
+// Write *also* ignores errors from the read half of the handshake (in case the
+// stream is actually write only).
+func (l *lazyClientConn) Write(b []byte) (int, error) {
+	n := 0
+	l.whandshakeOnce.Do(func() {
+		go l.rhandshakeOnce.Do(l.doReadHandshake)
+		n = l.doWriteHandshakeWithData(b)
+	})
+	if l.werr != nil || n > 0 {
+		return n, l.werr
+	}
+	return l.con.Write(b)
+}
+
+// Close closes the underlying io.ReadWriteCloser
+func (l *lazyClientConn) Close() error {
+	return l.con.Close()
+}
diff --git a/vendor/github.com/multiformats/go-multistream/lazyServer.go b/vendor/github.com/multiformats/go-multistream/lazyServer.go
new file mode 100644
index 000000000..d7501facc
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multistream/lazyServer.go
@@ -0,0 +1,37 @@
+package multistream
+
+import (
+	"io"
+	"sync"
+)
+
+// lazyServerConn is an io.ReadWriteCloser adapter used for negotiating inbound
+// streams (see NegotiateLazy).
+//
+// This is "lazy" because it doesn't wait for the write half to succeed before
+// allowing us to read from the stream.
+type lazyServerConn struct {
+	waitForHandshake sync.Once
+	werr             error
+
+	con io.ReadWriteCloser
+}
+
+func (l *lazyServerConn) Write(b []byte) (int, error) {
+	l.waitForHandshake.Do(func() { panic("didn't initiate handshake") })
+	if l.werr != nil {
+		return 0, l.werr
+	}
+	return l.con.Write(b)
+}
+
+func (l *lazyServerConn) Read(b []byte) (int, error) {
+	if len(b) == 0 {
+		return 0, nil
+	}
+	return l.con.Read(b)
+}
+
+func (l *lazyServerConn) Close() error {
+	return l.con.Close()
+}
diff --git a/vendor/github.com/multiformats/go-multistream/multistream.go b/vendor/github.com/multiformats/go-multistream/multistream.go
new file mode 100644
index 000000000..f61b24ead
--- /dev/null
+++ b/vendor/github.com/multiformats/go-multistream/multistream.go
@@ -0,0 +1,440 @@
+// Package multistream implements a simple stream router for the
+// multistream-select protocoli. The protocol is defined at
+// https://github.com/multiformats/multistream-select
+package multistream
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"sync"
+)
+
+// ErrTooLarge is an error to signal that an incoming message was too large
+var ErrTooLarge = errors.New("incoming message was too large")
+
+// ProtocolID identifies the multistream protocol itself and makes sure
+// the multistream muxers on both sides of a channel can work with each other.
+const ProtocolID = "/multistream/1.0.0"
+
+// HandlerFunc is a user-provided function used by the MultistreamMuxer to
+// handle a protocol/stream.
+type HandlerFunc func(protocol string, rwc io.ReadWriteCloser) error
+
+// Handler is a wrapper to HandlerFunc which attaches a name (protocol) and a
+// match function which can optionally be used to select a handler by other
+// means than the name.
+type Handler struct {
+	MatchFunc func(string) bool
+	Handle    HandlerFunc
+	AddName   string
+}
+
+// MultistreamMuxer is a muxer for multistream. Depending on the stream
+// protocol tag it will select the right handler and hand the stream off to it.
+type MultistreamMuxer struct {
+	handlerlock sync.Mutex
+	handlers    []Handler
+}
+
+// NewMultistreamMuxer creates a muxer.
+func NewMultistreamMuxer() *MultistreamMuxer {
+	return new(MultistreamMuxer)
+}
+
+func writeUvarint(w io.Writer, i uint64) error {
+	varintbuf := make([]byte, 16)
+	n := binary.PutUvarint(varintbuf, i)
+	_, err := w.Write(varintbuf[:n])
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func delimWriteBuffered(w io.Writer, mes []byte) error {
+	bw := bufio.NewWriter(w)
+	err := delimWrite(bw, mes)
+	if err != nil {
+		return err
+	}
+
+	return bw.Flush()
+}
+
+func delimWrite(w io.Writer, mes []byte) error {
+	err := writeUvarint(w, uint64(len(mes)+1))
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(mes)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write([]byte{'\n'})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Ls is a Multistream muxer command which returns the list of handler names
+// available on a muxer.
+func Ls(rw io.ReadWriter) ([]string, error) {
+	err := delimWriteBuffered(rw, []byte("ls"))
+	if err != nil {
+		return nil, err
+	}
+
+	n, err := binary.ReadUvarint(&byteReader{rw})
+	if err != nil {
+		return nil, err
+	}
+
+	var out []string
+	for i := uint64(0); i < n; i++ {
+		val, err := lpReadBuf(rw)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, string(val))
+	}
+
+	return out, nil
+}
+
+func fulltextMatch(s string) func(string) bool {
+	return func(a string) bool {
+		return a == s
+	}
+}
+
+// AddHandler attaches a new protocol handler to the muxer.
+func (msm *MultistreamMuxer) AddHandler(protocol string, handler HandlerFunc) {
+	msm.AddHandlerWithFunc(protocol, fulltextMatch(protocol), handler)
+}
+
+// AddHandlerWithFunc attaches a new protocol handler to the muxer with a match.
+// If the match function returns true for a given protocol tag, the protocol
+// will be selected even if the handler name and protocol tags are different.
+func (msm *MultistreamMuxer) AddHandlerWithFunc(protocol string, match func(string) bool, handler HandlerFunc) {
+	msm.handlerlock.Lock()
+	msm.removeHandler(protocol)
+	msm.handlers = append(msm.handlers, Handler{
+		MatchFunc: match,
+		Handle:    handler,
+		AddName:   protocol,
+	})
+	msm.handlerlock.Unlock()
+}
+
+// RemoveHandler removes the handler with the given name from the muxer.
+func (msm *MultistreamMuxer) RemoveHandler(protocol string) {
+	msm.handlerlock.Lock()
+	defer msm.handlerlock.Unlock()
+
+	msm.removeHandler(protocol)
+}
+
+func (msm *MultistreamMuxer) removeHandler(protocol string) {
+	for i, h := range msm.handlers {
+		if h.AddName == protocol {
+			msm.handlers = append(msm.handlers[:i], msm.handlers[i+1:]...)
+			return
+		}
+	}
+}
+
+// Protocols returns the list of handler-names added to this this muxer.
+func (msm *MultistreamMuxer) Protocols() []string {
+	var out []string
+	msm.handlerlock.Lock()
+	for _, h := range msm.handlers {
+		out = append(out, h.AddName)
+	}
+	msm.handlerlock.Unlock()
+	return out
+}
+
+// ErrIncorrectVersion is an error reported when the muxer protocol negotiation
+// fails because of a ProtocolID mismatch.
+var ErrIncorrectVersion = errors.New("client connected with incorrect version")
+
+func (msm *MultistreamMuxer) findHandler(proto string) *Handler {
+	msm.handlerlock.Lock()
+	defer msm.handlerlock.Unlock()
+
+	for _, h := range msm.handlers {
+		if h.MatchFunc(proto) {
+			return &h
+		}
+	}
+
+	return nil
+}
+
+// NegotiateLazy performs protocol selection and returns
+// a multistream, the protocol used, the handler and an error. It is lazy
+// because the write-handshake is performed on a subroutine, allowing this
+// to return before that handshake is completed.
+func (msm *MultistreamMuxer) NegotiateLazy(rwc io.ReadWriteCloser) (Multistream, string, HandlerFunc, error) {
+	pval := make(chan string, 1)
+	writeErr := make(chan error, 1)
+	defer close(pval)
+
+	lzc := &lazyServerConn{
+		con: rwc,
+	}
+
+	started := make(chan struct{})
+	go lzc.waitForHandshake.Do(func() {
+		close(started)
+
+		defer close(writeErr)
+
+		if err := delimWriteBuffered(rwc, []byte(ProtocolID)); err != nil {
+			lzc.werr = err
+			writeErr <- err
+			return
+		}
+
+		for proto := range pval {
+			if err := delimWriteBuffered(rwc, []byte(proto)); err != nil {
+				lzc.werr = err
+				writeErr <- err
+				return
+			}
+		}
+	})
+	<-started
+
+	line, err := ReadNextToken(rwc)
+	if err != nil {
+		return nil, "", nil, err
+	}
+
+	if line != ProtocolID {
+		rwc.Close()
+		return nil, "", nil, ErrIncorrectVersion
+	}
+
+loop:
+	for {
+		// Now read and respond to commands until they send a valid protocol id
+		tok, err := ReadNextToken(rwc)
+		if err != nil {
+			rwc.Close()
+			return nil, "", nil, err
+		}
+
+		switch tok {
+		case "ls":
+			select {
+			case pval <- "ls":
+			case err := <-writeErr:
+				rwc.Close()
+				return nil, "", nil, err
+			}
+		default:
+			h := msm.findHandler(tok)
+			if h == nil {
+				select {
+				case pval <- "na":
+				case err := <-writeErr:
+					rwc.Close()
+					return nil, "", nil, err
+				}
+				continue loop
+			}
+
+			select {
+			case pval <- tok:
+			case <-writeErr:
+				// explicitly ignore this error. It will be returned to any
+				// writers and if we don't plan on writing anything, we still
+				// want to complete the handshake
+			}
+
+			// hand off processing to the sub-protocol handler
+			return lzc, tok, h.Handle, nil
+		}
+	}
+}
+
+// Negotiate performs protocol selection and returns the protocol name and
+// the matching handler function for it (or an error).
+func (msm *MultistreamMuxer) Negotiate(rwc io.ReadWriteCloser) (string, HandlerFunc, error) {
+	// Send our protocol ID
+	err := delimWriteBuffered(rwc, []byte(ProtocolID))
+	if err != nil {
+		return "", nil, err
+	}
+
+	line, err := ReadNextToken(rwc)
+	if err != nil {
+		return "", nil, err
+	}
+
+	if line != ProtocolID {
+		rwc.Close()
+		return "", nil, ErrIncorrectVersion
+	}
+
+loop:
+	for {
+		// Now read and respond to commands until they send a valid protocol id
+		tok, err := ReadNextToken(rwc)
+		if err != nil {
+			return "", nil, err
+		}
+
+		switch tok {
+		case "ls":
+			err := msm.Ls(rwc)
+			if err != nil {
+				return "", nil, err
+			}
+		default:
+			h := msm.findHandler(tok)
+			if h == nil {
+				err := delimWriteBuffered(rwc, []byte("na"))
+				if err != nil {
+					return "", nil, err
+				}
+				continue loop
+			}
+
+			err := delimWriteBuffered(rwc, []byte(tok))
+			if err != nil {
+				return "", nil, err
+			}
+
+			// hand off processing to the sub-protocol handler
+			return tok, h.Handle, nil
+		}
+	}
+
+}
+
+// Ls implements the "ls" command which writes the list of
+// supported protocols to the given Writer.
+func (msm *MultistreamMuxer) Ls(w io.Writer) error {
+	buf := new(bytes.Buffer)
+	msm.handlerlock.Lock()
+	err := writeUvarint(buf, uint64(len(msm.handlers)))
+	if err != nil {
+		return err
+	}
+
+	for _, h := range msm.handlers {
+		err := delimWrite(buf, []byte(h.AddName))
+		if err != nil {
+			msm.handlerlock.Unlock()
+			return err
+		}
+	}
+	msm.handlerlock.Unlock()
+	ll := make([]byte, 16)
+	nw := binary.PutUvarint(ll, uint64(buf.Len()))
+
+	r := io.MultiReader(bytes.NewReader(ll[:nw]), buf)
+
+	_, err = io.Copy(w, r)
+	return err
+}
+
+// Handle performs protocol negotiation on a ReadWriteCloser
+// (i.e. a connection). It will find a matching handler for the
+// incoming protocol and pass the ReadWriteCloser to it.
+func (msm *MultistreamMuxer) Handle(rwc io.ReadWriteCloser) error {
+	p, h, err := msm.Negotiate(rwc)
+	if err != nil {
+		return err
+	}
+	return h(p, rwc)
+}
+
+// ReadNextToken extracts a token from a ReadWriter. It is used during
+// protocol negotiation and returns a string.
+func ReadNextToken(rw io.ReadWriter) (string, error) {
+	tok, err := ReadNextTokenBytes(rw)
+	if err != nil {
+		return "", err
+	}
+
+	return string(tok), nil
+}
+
+// ReadNextTokenBytes extracts a token from a ReadWriter. It is used
+// during protocol negotiation and returns a byte slice.
+func ReadNextTokenBytes(rw io.ReadWriter) ([]byte, error) {
+	data, err := lpReadBuf(rw)
+	switch err {
+	case nil:
+		return data, nil
+	case ErrTooLarge:
+		err := delimWriteBuffered(rw, []byte("messages over 64k are not allowed"))
+		if err != nil {
+			return nil, err
+		}
+		return nil, ErrTooLarge
+	default:
+		return nil, err
+	}
+}
+
+func lpReadBuf(r io.Reader) ([]byte, error) {
+	br, ok := r.(io.ByteReader)
+	if !ok {
+		br = &byteReader{r}
+	}
+
+	length, err := binary.ReadUvarint(br)
+	if err != nil {
+		return nil, err
+	}
+
+	if length > 64*1024 {
+		return nil, ErrTooLarge
+	}
+
+	buf := make([]byte, length)
+	_, err = io.ReadFull(r, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(buf) == 0 || buf[length-1] != '\n' {
+		return nil, errors.New("message did not have trailing newline")
+	}
+
+	// slice off the trailing newline
+	buf = buf[:length-1]
+
+	return buf, nil
+
+}
+
+// byteReader implements the ByteReader interface that ReadUVarint requires
+type byteReader struct {
+	io.Reader
+}
+
+func (br *byteReader) ReadByte() (byte, error) {
+	var b [1]byte
+	n, err := br.Read(b[:])
+	if n == 1 {
+		return b[0], nil
+	}
+	if err == nil {
+		if n != 0 {
+			panic("read more bytes than buffer size")
+		}
+		err = io.ErrNoProgress
+	}
+	return 0, err
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/LICENSE b/vendor/github.com/opentracing/opentracing-go/LICENSE
new file mode 100644
index 000000000..148509a40
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 The OpenTracing Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/opentracing/opentracing-go/ext/tags.go b/vendor/github.com/opentracing/opentracing-go/ext/tags.go
new file mode 100644
index 000000000..c67ab5eef
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/ext/tags.go
@@ -0,0 +1,198 @@
+package ext
+
+import opentracing "github.com/opentracing/opentracing-go"
+
+// These constants define common tag names recommended for better portability across
+// tracing systems and languages/platforms.
+//
+// The tag names are defined as typed strings, so that in addition to the usual use
+//
+//     span.setTag(TagName, value)
+//
+// they also support value type validation via this additional syntax:
+//
+//    TagName.Set(span, value)
+//
+var (
+	//////////////////////////////////////////////////////////////////////
+	// SpanKind (client/server or producer/consumer)
+	//////////////////////////////////////////////////////////////////////
+
+	// SpanKind hints at relationship between spans, e.g. client/server
+	SpanKind = spanKindTagName("span.kind")
+
+	// SpanKindRPCClient marks a span representing the client-side of an RPC
+	// or other remote call
+	SpanKindRPCClientEnum = SpanKindEnum("client")
+	SpanKindRPCClient     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCClientEnum}
+
+	// SpanKindRPCServer marks a span representing the server-side of an RPC
+	// or other remote call
+	SpanKindRPCServerEnum = SpanKindEnum("server")
+	SpanKindRPCServer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCServerEnum}
+
+	// SpanKindProducer marks a span representing the producer-side of a
+	// message bus
+	SpanKindProducerEnum = SpanKindEnum("producer")
+	SpanKindProducer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindProducerEnum}
+
+	// SpanKindConsumer marks a span representing the consumer-side of a
+	// message bus
+	SpanKindConsumerEnum = SpanKindEnum("consumer")
+	SpanKindConsumer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindConsumerEnum}
+
+	//////////////////////////////////////////////////////////////////////
+	// Component name
+	//////////////////////////////////////////////////////////////////////
+
+	// Component is a low-cardinality identifier of the module, library,
+	// or package that is generating a span.
+	Component = stringTagName("component")
+
+	//////////////////////////////////////////////////////////////////////
+	// Sampling hint
+	//////////////////////////////////////////////////////////////////////
+
+	// SamplingPriority determines the priority of sampling this Span.
+	SamplingPriority = uint16TagName("sampling.priority")
+
+	//////////////////////////////////////////////////////////////////////
+	// Peer tags. These tags can be emitted by either client-side of
+	// server-side to describe the other side/service in a peer-to-peer
+	// communications, like an RPC call.
+	//////////////////////////////////////////////////////////////////////
+
+	// PeerService records the service name of the peer.
+	PeerService = stringTagName("peer.service")
+
+	// PeerAddress records the address name of the peer. This may be a "ip:port",
+	// a bare "hostname", a FQDN or even a database DSN substring
+	// like "mysql://username@127.0.0.1:3306/dbname"
+	PeerAddress = stringTagName("peer.address")
+
+	// PeerHostname records the host name of the peer
+	PeerHostname = stringTagName("peer.hostname")
+
+	// PeerHostIPv4 records IP v4 host address of the peer
+	PeerHostIPv4 = uint32TagName("peer.ipv4")
+
+	// PeerHostIPv6 records IP v6 host address of the peer
+	PeerHostIPv6 = stringTagName("peer.ipv6")
+
+	// PeerPort records port number of the peer
+	PeerPort = uint16TagName("peer.port")
+
+	//////////////////////////////////////////////////////////////////////
+	// HTTP Tags
+	//////////////////////////////////////////////////////////////////////
+
+	// HTTPUrl should be the URL of the request being handled in this segment
+	// of the trace, in standard URI format. The protocol is optional.
+	HTTPUrl = stringTagName("http.url")
+
+	// HTTPMethod is the HTTP method of the request, and is case-insensitive.
+	HTTPMethod = stringTagName("http.method")
+
+	// HTTPStatusCode is the numeric HTTP status code (200, 404, etc) of the
+	// HTTP response.
+	HTTPStatusCode = uint16TagName("http.status_code")
+
+	//////////////////////////////////////////////////////////////////////
+	// DB Tags
+	//////////////////////////////////////////////////////////////////////
+
+	// DBInstance is database instance name.
+	DBInstance = stringTagName("db.instance")
+
+	// DBStatement is a database statement for the given database type.
+	// It can be a query or a prepared statement (i.e., before substitution).
+	DBStatement = stringTagName("db.statement")
+
+	// DBType is a database type. For any SQL database, "sql".
+	// For others, the lower-case database category, e.g. "redis"
+	DBType = stringTagName("db.type")
+
+	// DBUser is a username for accessing database.
+	DBUser = stringTagName("db.user")
+
+	//////////////////////////////////////////////////////////////////////
+	// Message Bus Tag
+	//////////////////////////////////////////////////////////////////////
+
+	// MessageBusDestination is an address at which messages can be exchanged
+	MessageBusDestination = stringTagName("message_bus.destination")
+
+	//////////////////////////////////////////////////////////////////////
+	// Error Tag
+	//////////////////////////////////////////////////////////////////////
+
+	// Error indicates that operation represented by the span resulted in an error.
+	Error = boolTagName("error")
+)
+
+// ---
+
+// SpanKindEnum represents common span types
+type SpanKindEnum string
+
+type spanKindTagName string
+
+// Set adds a string tag to the `span`
+func (tag spanKindTagName) Set(span opentracing.Span, value SpanKindEnum) {
+	span.SetTag(string(tag), value)
+}
+
+type rpcServerOption struct {
+	clientContext opentracing.SpanContext
+}
+
+func (r rpcServerOption) Apply(o *opentracing.StartSpanOptions) {
+	if r.clientContext != nil {
+		opentracing.ChildOf(r.clientContext).Apply(o)
+	}
+	SpanKindRPCServer.Apply(o)
+}
+
+// RPCServerOption returns a StartSpanOption appropriate for an RPC server span
+// with `client` representing the metadata for the remote peer Span if available.
+// In case client == nil, due to the client not being instrumented, this RPC
+// server span will be a root span.
+func RPCServerOption(client opentracing.SpanContext) opentracing.StartSpanOption {
+	return rpcServerOption{client}
+}
+
+// ---
+
+type stringTagName string
+
+// Set adds a string tag to the `span`
+func (tag stringTagName) Set(span opentracing.Span, value string) {
+	span.SetTag(string(tag), value)
+}
+
+// ---
+
+type uint32TagName string
+
+// Set adds a uint32 tag to the `span`
+func (tag uint32TagName) Set(span opentracing.Span, value uint32) {
+	span.SetTag(string(tag), value)
+}
+
+// ---
+
+type uint16TagName string
+
+// Set adds a uint16 tag to the `span`
+func (tag uint16TagName) Set(span opentracing.Span, value uint16) {
+	span.SetTag(string(tag), value)
+}
+
+// ---
+
+type boolTagName string
+
+// Add adds a bool tag to the `span`
+func (tag boolTagName) Set(span opentracing.Span, value bool) {
+	span.SetTag(string(tag), value)
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/globaltracer.go b/vendor/github.com/opentracing/opentracing-go/globaltracer.go
new file mode 100644
index 000000000..8c8e793ff
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/globaltracer.go
@@ -0,0 +1,32 @@
+package opentracing
+
+var (
+	globalTracer Tracer = NoopTracer{}
+)
+
+// SetGlobalTracer sets the [singleton] opentracing.Tracer returned by
+// GlobalTracer(). Those who use GlobalTracer (rather than directly manage an
+// opentracing.Tracer instance) should call SetGlobalTracer as early as
+// possible in main(), prior to calling the `StartSpan` global func below.
+// Prior to calling `SetGlobalTracer`, any Spans started via the `StartSpan`
+// (etc) globals are noops.
+func SetGlobalTracer(tracer Tracer) {
+	globalTracer = tracer
+}
+
+// GlobalTracer returns the global singleton `Tracer` implementation.
+// Before `SetGlobalTracer()` is called, the `GlobalTracer()` is a noop
+// implementation that drops all data handed to it.
+func GlobalTracer() Tracer {
+	return globalTracer
+}
+
+// StartSpan defers to `Tracer.StartSpan`. See `GlobalTracer()`.
+func StartSpan(operationName string, opts ...StartSpanOption) Span {
+	return globalTracer.StartSpan(operationName, opts...)
+}
+
+// InitGlobalTracer is deprecated. Please use SetGlobalTracer.
+func InitGlobalTracer(tracer Tracer) {
+	SetGlobalTracer(tracer)
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/gocontext.go b/vendor/github.com/opentracing/opentracing-go/gocontext.go
new file mode 100644
index 000000000..222a65202
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/gocontext.go
@@ -0,0 +1,57 @@
+package opentracing
+
+import "golang.org/x/net/context"
+
+type contextKey struct{}
+
+var activeSpanKey = contextKey{}
+
+// ContextWithSpan returns a new `context.Context` that holds a reference to
+// `span`'s SpanContext.
+func ContextWithSpan(ctx context.Context, span Span) context.Context {
+	return context.WithValue(ctx, activeSpanKey, span)
+}
+
+// SpanFromContext returns the `Span` previously associated with `ctx`, or
+// `nil` if no such `Span` could be found.
+//
+// NOTE: context.Context != SpanContext: the former is Go's intra-process
+// context propagation mechanism, and the latter houses OpenTracing's per-Span
+// identity and baggage information.
+func SpanFromContext(ctx context.Context) Span {
+	val := ctx.Value(activeSpanKey)
+	if sp, ok := val.(Span); ok {
+		return sp
+	}
+	return nil
+}
+
+// StartSpanFromContext starts and returns a Span with `operationName`, using
+// any Span found within `ctx` as a ChildOfRef. If no such parent could be
+// found, StartSpanFromContext creates a root (parentless) Span.
+//
+// The second return value is a context.Context object built around the
+// returned Span.
+//
+// Example usage:
+//
+//    SomeFunction(ctx context.Context, ...) {
+//        sp, ctx := opentracing.StartSpanFromContext(ctx, "SomeFunction")
+//        defer sp.Finish()
+//        ...
+//    }
+func StartSpanFromContext(ctx context.Context, operationName string, opts ...StartSpanOption) (Span, context.Context) {
+	return startSpanFromContextWithTracer(ctx, GlobalTracer(), operationName, opts...)
+}
+
+// startSpanFromContextWithTracer is factored out for testing purposes.
+func startSpanFromContextWithTracer(ctx context.Context, tracer Tracer, operationName string, opts ...StartSpanOption) (Span, context.Context) {
+	var span Span
+	if parentSpan := SpanFromContext(ctx); parentSpan != nil {
+		opts = append(opts, ChildOf(parentSpan.Context()))
+		span = tracer.StartSpan(operationName, opts...)
+	} else {
+		span = tracer.StartSpan(operationName, opts...)
+	}
+	return span, ContextWithSpan(ctx, span)
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/log/field.go b/vendor/github.com/opentracing/opentracing-go/log/field.go
new file mode 100644
index 000000000..d2cd39a16
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/log/field.go
@@ -0,0 +1,245 @@
+package log
+
+import (
+	"fmt"
+	"math"
+)
+
+type fieldType int
+
+const (
+	stringType fieldType = iota
+	boolType
+	intType
+	int32Type
+	uint32Type
+	int64Type
+	uint64Type
+	float32Type
+	float64Type
+	errorType
+	objectType
+	lazyLoggerType
+)
+
+// Field instances are constructed via LogBool, LogString, and so on.
+// Tracing implementations may then handle them via the Field.Marshal
+// method.
+//
+// "heavily influenced by" (i.e., partially stolen from)
+// https://github.com/uber-go/zap
+type Field struct {
+	key          string
+	fieldType    fieldType
+	numericVal   int64
+	stringVal    string
+	interfaceVal interface{}
+}
+
+// String adds a string-valued key:value pair to a Span.LogFields() record
+func String(key, val string) Field {
+	return Field{
+		key:       key,
+		fieldType: stringType,
+		stringVal: val,
+	}
+}
+
+// Bool adds a bool-valued key:value pair to a Span.LogFields() record
+func Bool(key string, val bool) Field {
+	var numericVal int64
+	if val {
+		numericVal = 1
+	}
+	return Field{
+		key:        key,
+		fieldType:  boolType,
+		numericVal: numericVal,
+	}
+}
+
+// Int adds an int-valued key:value pair to a Span.LogFields() record
+func Int(key string, val int) Field {
+	return Field{
+		key:        key,
+		fieldType:  intType,
+		numericVal: int64(val),
+	}
+}
+
+// Int32 adds an int32-valued key:value pair to a Span.LogFields() record
+func Int32(key string, val int32) Field {
+	return Field{
+		key:        key,
+		fieldType:  int32Type,
+		numericVal: int64(val),
+	}
+}
+
+// Int64 adds an int64-valued key:value pair to a Span.LogFields() record
+func Int64(key string, val int64) Field {
+	return Field{
+		key:        key,
+		fieldType:  int64Type,
+		numericVal: val,
+	}
+}
+
+// Uint32 adds a uint32-valued key:value pair to a Span.LogFields() record
+func Uint32(key string, val uint32) Field {
+	return Field{
+		key:        key,
+		fieldType:  uint32Type,
+		numericVal: int64(val),
+	}
+}
+
+// Uint64 adds a uint64-valued key:value pair to a Span.LogFields() record
+func Uint64(key string, val uint64) Field {
+	return Field{
+		key:        key,
+		fieldType:  uint64Type,
+		numericVal: int64(val),
+	}
+}
+
+// Float32 adds a float32-valued key:value pair to a Span.LogFields() record
+func Float32(key string, val float32) Field {
+	return Field{
+		key:        key,
+		fieldType:  float32Type,
+		numericVal: int64(math.Float32bits(val)),
+	}
+}
+
+// Float64 adds a float64-valued key:value pair to a Span.LogFields() record
+func Float64(key string, val float64) Field {
+	return Field{
+		key:        key,
+		fieldType:  float64Type,
+		numericVal: int64(math.Float64bits(val)),
+	}
+}
+
+// Error adds an error with the key "error" to a Span.LogFields() record
+func Error(err error) Field {
+	return Field{
+		key:          "error",
+		fieldType:    errorType,
+		interfaceVal: err,
+	}
+}
+
+// Object adds an object-valued key:value pair to a Span.LogFields() record
+func Object(key string, obj interface{}) Field {
+	return Field{
+		key:          key,
+		fieldType:    objectType,
+		interfaceVal: obj,
+	}
+}
+
+// LazyLogger allows for user-defined, late-bound logging of arbitrary data
+type LazyLogger func(fv Encoder)
+
+// Lazy adds a LazyLogger to a Span.LogFields() record; the tracing
+// implementation will call the LazyLogger function at an indefinite time in
+// the future (after Lazy() returns).
+func Lazy(ll LazyLogger) Field {
+	return Field{
+		fieldType:    lazyLoggerType,
+		interfaceVal: ll,
+	}
+}
+
+// Encoder allows access to the contents of a Field (via a call to
+// Field.Marshal).
+//
+// Tracer implementations typically provide an implementation of Encoder;
+// OpenTracing callers typically do not need to concern themselves with it.
+type Encoder interface {
+	EmitString(key, value string)
+	EmitBool(key string, value bool)
+	EmitInt(key string, value int)
+	EmitInt32(key string, value int32)
+	EmitInt64(key string, value int64)
+	EmitUint32(key string, value uint32)
+	EmitUint64(key string, value uint64)
+	EmitFloat32(key string, value float32)
+	EmitFloat64(key string, value float64)
+	EmitObject(key string, value interface{})
+	EmitLazyLogger(value LazyLogger)
+}
+
+// Marshal passes a Field instance through to the appropriate
+// field-type-specific method of an Encoder.
+func (lf Field) Marshal(visitor Encoder) {
+	switch lf.fieldType {
+	case stringType:
+		visitor.EmitString(lf.key, lf.stringVal)
+	case boolType:
+		visitor.EmitBool(lf.key, lf.numericVal != 0)
+	case intType:
+		visitor.EmitInt(lf.key, int(lf.numericVal))
+	case int32Type:
+		visitor.EmitInt32(lf.key, int32(lf.numericVal))
+	case int64Type:
+		visitor.EmitInt64(lf.key, int64(lf.numericVal))
+	case uint32Type:
+		visitor.EmitUint32(lf.key, uint32(lf.numericVal))
+	case uint64Type:
+		visitor.EmitUint64(lf.key, uint64(lf.numericVal))
+	case float32Type:
+		visitor.EmitFloat32(lf.key, math.Float32frombits(uint32(lf.numericVal)))
+	case float64Type:
+		visitor.EmitFloat64(lf.key, math.Float64frombits(uint64(lf.numericVal)))
+	case errorType:
+		if err, ok := lf.interfaceVal.(error); ok {
+			visitor.EmitString(lf.key, err.Error())
+		} else {
+			visitor.EmitString(lf.key, "<nil>")
+		}
+	case objectType:
+		visitor.EmitObject(lf.key, lf.interfaceVal)
+	case lazyLoggerType:
+		visitor.EmitLazyLogger(lf.interfaceVal.(LazyLogger))
+	}
+}
+
+// Key returns the field's key.
+func (lf Field) Key() string {
+	return lf.key
+}
+
+// Value returns the field's value as interface{}.
+func (lf Field) Value() interface{} {
+	switch lf.fieldType {
+	case stringType:
+		return lf.stringVal
+	case boolType:
+		return lf.numericVal != 0
+	case intType:
+		return int(lf.numericVal)
+	case int32Type:
+		return int32(lf.numericVal)
+	case int64Type:
+		return int64(lf.numericVal)
+	case uint32Type:
+		return uint32(lf.numericVal)
+	case uint64Type:
+		return uint64(lf.numericVal)
+	case float32Type:
+		return math.Float32frombits(uint32(lf.numericVal))
+	case float64Type:
+		return math.Float64frombits(uint64(lf.numericVal))
+	case errorType, objectType, lazyLoggerType:
+		return lf.interfaceVal
+	default:
+		return nil
+	}
+}
+
+// String returns a string representation of the key and value.
+func (lf Field) String() string {
+	return fmt.Sprint(lf.key, ":", lf.Value())
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/log/util.go b/vendor/github.com/opentracing/opentracing-go/log/util.go
new file mode 100644
index 000000000..3832feb5c
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/log/util.go
@@ -0,0 +1,54 @@
+package log
+
+import "fmt"
+
+// InterleavedKVToFields converts keyValues a la Span.LogKV() to a Field slice
+// a la Span.LogFields().
+func InterleavedKVToFields(keyValues ...interface{}) ([]Field, error) {
+	if len(keyValues)%2 != 0 {
+		return nil, fmt.Errorf("non-even keyValues len: %d", len(keyValues))
+	}
+	fields := make([]Field, len(keyValues)/2)
+	for i := 0; i*2 < len(keyValues); i++ {
+		key, ok := keyValues[i*2].(string)
+		if !ok {
+			return nil, fmt.Errorf(
+				"non-string key (pair #%d): %T",
+				i, keyValues[i*2])
+		}
+		switch typedVal := keyValues[i*2+1].(type) {
+		case bool:
+			fields[i] = Bool(key, typedVal)
+		case string:
+			fields[i] = String(key, typedVal)
+		case int:
+			fields[i] = Int(key, typedVal)
+		case int8:
+			fields[i] = Int32(key, int32(typedVal))
+		case int16:
+			fields[i] = Int32(key, int32(typedVal))
+		case int32:
+			fields[i] = Int32(key, typedVal)
+		case int64:
+			fields[i] = Int64(key, typedVal)
+		case uint:
+			fields[i] = Uint64(key, uint64(typedVal))
+		case uint64:
+			fields[i] = Uint64(key, typedVal)
+		case uint8:
+			fields[i] = Uint32(key, uint32(typedVal))
+		case uint16:
+			fields[i] = Uint32(key, uint32(typedVal))
+		case uint32:
+			fields[i] = Uint32(key, typedVal)
+		case float32:
+			fields[i] = Float32(key, typedVal)
+		case float64:
+			fields[i] = Float64(key, typedVal)
+		default:
+			// When in doubt, coerce to a string
+			fields[i] = String(key, fmt.Sprint(typedVal))
+		}
+	}
+	return fields, nil
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/noop.go b/vendor/github.com/opentracing/opentracing-go/noop.go
new file mode 100644
index 000000000..0d32f692c
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/noop.go
@@ -0,0 +1,64 @@
+package opentracing
+
+import "github.com/opentracing/opentracing-go/log"
+
+// A NoopTracer is a trivial, minimum overhead implementation of Tracer
+// for which all operations are no-ops.
+//
+// The primary use of this implementation is in libraries, such as RPC
+// frameworks, that make tracing an optional feature controlled by the
+// end user. A no-op implementation allows said libraries to use it
+// as the default Tracer and to write instrumentation that does
+// not need to keep checking if the tracer instance is nil.
+//
+// For the same reason, the NoopTracer is the default "global" tracer
+// (see GlobalTracer and SetGlobalTracer functions).
+//
+// WARNING: NoopTracer does not support baggage propagation.
+type NoopTracer struct{}
+
+type noopSpan struct{}
+type noopSpanContext struct{}
+
+var (
+	defaultNoopSpanContext = noopSpanContext{}
+	defaultNoopSpan        = noopSpan{}
+	defaultNoopTracer      = NoopTracer{}
+)
+
+const (
+	emptyString = ""
+)
+
+// noopSpanContext:
+func (n noopSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {}
+
+// noopSpan:
+func (n noopSpan) Context() SpanContext                                  { return defaultNoopSpanContext }
+func (n noopSpan) SetBaggageItem(key, val string) Span                   { return defaultNoopSpan }
+func (n noopSpan) BaggageItem(key string) string                         { return emptyString }
+func (n noopSpan) SetTag(key string, value interface{}) Span             { return n }
+func (n noopSpan) LogFields(fields ...log.Field)                         {}
+func (n noopSpan) LogKV(keyVals ...interface{})                          {}
+func (n noopSpan) Finish()                                               {}
+func (n noopSpan) FinishWithOptions(opts FinishOptions)                  {}
+func (n noopSpan) SetOperationName(operationName string) Span            { return n }
+func (n noopSpan) Tracer() Tracer                                        { return defaultNoopTracer }
+func (n noopSpan) LogEvent(event string)                                 {}
+func (n noopSpan) LogEventWithPayload(event string, payload interface{}) {}
+func (n noopSpan) Log(data LogData)                                      {}
+
+// StartSpan belongs to the Tracer interface.
+func (n NoopTracer) StartSpan(operationName string, opts ...StartSpanOption) Span {
+	return defaultNoopSpan
+}
+
+// Inject belongs to the Tracer interface.
+func (n NoopTracer) Inject(sp SpanContext, format interface{}, carrier interface{}) error {
+	return nil
+}
+
+// Extract belongs to the Tracer interface.
+func (n NoopTracer) Extract(format interface{}, carrier interface{}) (SpanContext, error) {
+	return nil, ErrSpanContextNotFound
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/propagation.go b/vendor/github.com/opentracing/opentracing-go/propagation.go
new file mode 100644
index 000000000..9583fc53a
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/propagation.go
@@ -0,0 +1,176 @@
+package opentracing
+
+import (
+	"errors"
+	"net/http"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// CORE PROPAGATION INTERFACES:
+///////////////////////////////////////////////////////////////////////////////
+
+var (
+	// ErrUnsupportedFormat occurs when the `format` passed to Tracer.Inject() or
+	// Tracer.Extract() is not recognized by the Tracer implementation.
+	ErrUnsupportedFormat = errors.New("opentracing: Unknown or unsupported Inject/Extract format")
+
+	// ErrSpanContextNotFound occurs when the `carrier` passed to
+	// Tracer.Extract() is valid and uncorrupted but has insufficient
+	// information to extract a SpanContext.
+	ErrSpanContextNotFound = errors.New("opentracing: SpanContext not found in Extract carrier")
+
+	// ErrInvalidSpanContext errors occur when Tracer.Inject() is asked to
+	// operate on a SpanContext which it is not prepared to handle (for
+	// example, since it was created by a different tracer implementation).
+	ErrInvalidSpanContext = errors.New("opentracing: SpanContext type incompatible with tracer")
+
+	// ErrInvalidCarrier errors occur when Tracer.Inject() or Tracer.Extract()
+	// implementations expect a different type of `carrier` than they are
+	// given.
+	ErrInvalidCarrier = errors.New("opentracing: Invalid Inject/Extract carrier")
+
+	// ErrSpanContextCorrupted occurs when the `carrier` passed to
+	// Tracer.Extract() is of the expected type but is corrupted.
+	ErrSpanContextCorrupted = errors.New("opentracing: SpanContext data corrupted in Extract carrier")
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// BUILTIN PROPAGATION FORMATS:
+///////////////////////////////////////////////////////////////////////////////
+
+// BuiltinFormat is used to demarcate the values within package `opentracing`
+// that are intended for use with the Tracer.Inject() and Tracer.Extract()
+// methods.
+type BuiltinFormat byte
+
+const (
+	// Binary represents SpanContexts as opaque binary data.
+	//
+	// For Tracer.Inject(): the carrier must be an `io.Writer`.
+	//
+	// For Tracer.Extract(): the carrier must be an `io.Reader`.
+	Binary BuiltinFormat = iota
+
+	// TextMap represents SpanContexts as key:value string pairs.
+	//
+	// Unlike HTTPHeaders, the TextMap format does not restrict the key or
+	// value character sets in any way.
+	//
+	// For Tracer.Inject(): the carrier must be a `TextMapWriter`.
+	//
+	// For Tracer.Extract(): the carrier must be a `TextMapReader`.
+	TextMap
+
+	// HTTPHeaders represents SpanContexts as HTTP header string pairs.
+	//
+	// Unlike TextMap, the HTTPHeaders format requires that the keys and values
+	// be valid as HTTP headers as-is (i.e., character casing may be unstable
+	// and special characters are disallowed in keys, values should be
+	// URL-escaped, etc).
+	//
+	// For Tracer.Inject(): the carrier must be a `TextMapWriter`.
+	//
+	// For Tracer.Extract(): the carrier must be a `TextMapReader`.
+	//
+	// See HTTPHeaderCarrier for an implementation of both TextMapWriter
+	// and TextMapReader that defers to an http.Header instance for storage.
+	// For example, Inject():
+	//
+	//    carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
+	//    err := span.Tracer().Inject(
+	//        span, opentracing.HTTPHeaders, carrier)
+	//
+	// Or Extract():
+	//
+	//    carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
+	//    span, err := tracer.Extract(
+	//        opentracing.HTTPHeaders, carrier)
+	//
+	HTTPHeaders
+)
+
+// TextMapWriter is the Inject() carrier for the TextMap builtin format. With
+// it, the caller can encode a SpanContext for propagation as entries in a map
+// of unicode strings.
+type TextMapWriter interface {
+	// Set a key:value pair to the carrier. Multiple calls to Set() for the
+	// same key leads to undefined behavior.
+	//
+	// NOTE: The backing store for the TextMapWriter may contain data unrelated
+	// to SpanContext. As such, Inject() and Extract() implementations that
+	// call the TextMapWriter and TextMapReader interfaces must agree on a
+	// prefix or other convention to distinguish their own key:value pairs.
+	Set(key, val string)
+}
+
+// TextMapReader is the Extract() carrier for the TextMap builtin format. With it,
+// the caller can decode a propagated SpanContext as entries in a map of
+// unicode strings.
+type TextMapReader interface {
+	// ForeachKey returns TextMap contents via repeated calls to the `handler`
+	// function. If any call to `handler` returns a non-nil error, ForeachKey
+	// terminates and returns that error.
+	//
+	// NOTE: The backing store for the TextMapReader may contain data unrelated
+	// to SpanContext. As such, Inject() and Extract() implementations that
+	// call the TextMapWriter and TextMapReader interfaces must agree on a
+	// prefix or other convention to distinguish their own key:value pairs.
+	//
+	// The "foreach" callback pattern reduces unnecessary copying in some cases
+	// and also allows implementations to hold locks while the map is read.
+	ForeachKey(handler func(key, val string) error) error
+}
+
+// TextMapCarrier allows the use of regular map[string]string
+// as both TextMapWriter and TextMapReader.
+type TextMapCarrier map[string]string
+
+// ForeachKey conforms to the TextMapReader interface.
+func (c TextMapCarrier) ForeachKey(handler func(key, val string) error) error {
+	for k, v := range c {
+		if err := handler(k, v); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Set implements Set() of opentracing.TextMapWriter
+func (c TextMapCarrier) Set(key, val string) {
+	c[key] = val
+}
+
+// HTTPHeadersCarrier satisfies both TextMapWriter and TextMapReader.
+//
+// Example usage for server side:
+//
+//     carrier := opentracing.HttpHeadersCarrier(httpReq.Header)
+//     spanContext, err := tracer.Extract(opentracing.HttpHeaders, carrier)
+//
+// Example usage for client side:
+//
+//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
+//     err := tracer.Inject(
+//         span.Context(),
+//         opentracing.HttpHeaders,
+//         carrier)
+//
+type HTTPHeadersCarrier http.Header
+
+// Set conforms to the TextMapWriter interface.
+func (c HTTPHeadersCarrier) Set(key, val string) {
+	h := http.Header(c)
+	h.Add(key, val)
+}
+
+// ForeachKey conforms to the TextMapReader interface.
+func (c HTTPHeadersCarrier) ForeachKey(handler func(key, val string) error) error {
+	for k, vals := range c {
+		for _, v := range vals {
+			if err := handler(k, v); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/span.go b/vendor/github.com/opentracing/opentracing-go/span.go
new file mode 100644
index 000000000..f6c3234ac
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/span.go
@@ -0,0 +1,185 @@
+package opentracing
+
+import (
+	"time"
+
+	"github.com/opentracing/opentracing-go/log"
+)
+
+// SpanContext represents Span state that must propagate to descendant Spans and across process
+// boundaries (e.g., a <trace_id, span_id, sampled> tuple).
+type SpanContext interface {
+	// ForeachBaggageItem grants access to all baggage items stored in the
+	// SpanContext.
+	// The handler function will be called for each baggage key/value pair.
+	// The ordering of items is not guaranteed.
+	//
+	// The bool return value indicates if the handler wants to continue iterating
+	// through the rest of the baggage items; for example if the handler is trying to
+	// find some baggage item by pattern matching the name, it can return false
+	// as soon as the item is found to stop further iterations.
+	ForeachBaggageItem(handler func(k, v string) bool)
+}
+
+// Span represents an active, un-finished span in the OpenTracing system.
+//
+// Spans are created by the Tracer interface.
+type Span interface {
+	// Sets the end timestamp and finalizes Span state.
+	//
+	// With the exception of calls to Context() (which are always allowed),
+	// Finish() must be the last call made to any span instance, and to do
+	// otherwise leads to undefined behavior.
+	Finish()
+	// FinishWithOptions is like Finish() but with explicit control over
+	// timestamps and log data.
+	FinishWithOptions(opts FinishOptions)
+
+	// Context() yields the SpanContext for this Span. Note that the return
+	// value of Context() is still valid after a call to Span.Finish(), as is
+	// a call to Span.Context() after a call to Span.Finish().
+	Context() SpanContext
+
+	// Sets or changes the operation name.
+	SetOperationName(operationName string) Span
+
+	// Adds a tag to the span.
+	//
+	// If there is a pre-existing tag set for `key`, it is overwritten.
+	//
+	// Tag values can be numeric types, strings, or bools. The behavior of
+	// other tag value types is undefined at the OpenTracing level. If a
+	// tracing system does not know how to handle a particular value type, it
+	// may ignore the tag, but shall not panic.
+	SetTag(key string, value interface{}) Span
+
+	// LogFields is an efficient and type-checked way to record key:value
+	// logging data about a Span, though the programming interface is a little
+	// more verbose than LogKV(). Here's an example:
+	//
+	//    span.LogFields(
+	//        log.String("event", "soft error"),
+	//        log.String("type", "cache timeout"),
+	//        log.Int("waited.millis", 1500))
+	//
+	// Also see Span.FinishWithOptions() and FinishOptions.BulkLogData.
+	LogFields(fields ...log.Field)
+
+	// LogKV is a concise, readable way to record key:value logging data about
+	// a Span, though unfortunately this also makes it less efficient and less
+	// type-safe than LogFields(). Here's an example:
+	//
+	//    span.LogKV(
+	//        "event", "soft error",
+	//        "type", "cache timeout",
+	//        "waited.millis", 1500)
+	//
+	// For LogKV (as opposed to LogFields()), the parameters must appear as
+	// key-value pairs, like
+	//
+	//    span.LogKV(key1, val1, key2, val2, key3, val3, ...)
+	//
+	// The keys must all be strings. The values may be strings, numeric types,
+	// bools, Go error instances, or arbitrary structs.
+	//
+	// (Note to implementors: consider the log.InterleavedKVToFields() helper)
+	LogKV(alternatingKeyValues ...interface{})
+
+	// SetBaggageItem sets a key:value pair on this Span and its SpanContext
+	// that also propagates to descendants of this Span.
+	//
+	// SetBaggageItem() enables powerful functionality given a full-stack
+	// opentracing integration (e.g., arbitrary application data from a mobile
+	// app can make it, transparently, all the way into the depths of a storage
+	// system), and with it some powerful costs: use this feature with care.
+	//
+	// IMPORTANT NOTE #1: SetBaggageItem() will only propagate baggage items to
+	// *future* causal descendants of the associated Span.
+	//
+	// IMPORTANT NOTE #2: Use this thoughtfully and with care. Every key and
+	// value is copied into every local *and remote* child of the associated
+	// Span, and that can add up to a lot of network and cpu overhead.
+	//
+	// Returns a reference to this Span for chaining.
+	SetBaggageItem(restrictedKey, value string) Span
+
+	// Gets the value for a baggage item given its key. Returns the empty string
+	// if the value isn't found in this Span.
+	BaggageItem(restrictedKey string) string
+
+	// Provides access to the Tracer that created this Span.
+	Tracer() Tracer
+
+	// Deprecated: use LogFields or LogKV
+	LogEvent(event string)
+	// Deprecated: use LogFields or LogKV
+	LogEventWithPayload(event string, payload interface{})
+	// Deprecated: use LogFields or LogKV
+	Log(data LogData)
+}
+
+// LogRecord is data associated with a single Span log. Every LogRecord
+// instance must specify at least one Field.
+type LogRecord struct {
+	Timestamp time.Time
+	Fields    []log.Field
+}
+
+// FinishOptions allows Span.FinishWithOptions callers to override the finish
+// timestamp and provide log data via a bulk interface.
+type FinishOptions struct {
+	// FinishTime overrides the Span's finish time, or implicitly becomes
+	// time.Now() if FinishTime.IsZero().
+	//
+	// FinishTime must resolve to a timestamp that's >= the Span's StartTime
+	// (per StartSpanOptions).
+	FinishTime time.Time
+
+	// LogRecords allows the caller to specify the contents of many LogFields()
+	// calls with a single slice. May be nil.
+	//
+	// None of the LogRecord.Timestamp values may be .IsZero() (i.e., they must
+	// be set explicitly). Also, they must be >= the Span's start timestamp and
+	// <= the FinishTime (or time.Now() if FinishTime.IsZero()). Otherwise the
+	// behavior of FinishWithOptions() is undefined.
+	//
+	// If specified, the caller hands off ownership of LogRecords at
+	// FinishWithOptions() invocation time.
+	//
+	// If specified, the (deprecated) BulkLogData must be nil or empty.
+	LogRecords []LogRecord
+
+	// BulkLogData is DEPRECATED.
+	BulkLogData []LogData
+}
+
+// LogData is DEPRECATED
+type LogData struct {
+	Timestamp time.Time
+	Event     string
+	Payload   interface{}
+}
+
+// ToLogRecord converts a deprecated LogData to a non-deprecated LogRecord
+func (ld *LogData) ToLogRecord() LogRecord {
+	var literalTimestamp time.Time
+	if ld.Timestamp.IsZero() {
+		literalTimestamp = time.Now()
+	} else {
+		literalTimestamp = ld.Timestamp
+	}
+	rval := LogRecord{
+		Timestamp: literalTimestamp,
+	}
+	if ld.Payload == nil {
+		rval.Fields = []log.Field{
+			log.String("event", ld.Event),
+		}
+	} else {
+		rval.Fields = []log.Field{
+			log.String("event", ld.Event),
+			log.Object("payload", ld.Payload),
+		}
+	}
+	return rval
+}
diff --git a/vendor/github.com/opentracing/opentracing-go/tracer.go b/vendor/github.com/opentracing/opentracing-go/tracer.go
new file mode 100644
index 000000000..fd77c1df3
--- /dev/null
+++ b/vendor/github.com/opentracing/opentracing-go/tracer.go
@@ -0,0 +1,305 @@
+package opentracing
+
+import "time"
+
+// Tracer is a simple, thin interface for Span creation and SpanContext
+// propagation.
+type Tracer interface {
+
+	// Create, start, and return a new Span with the given `operationName` and
+	// incorporate the given StartSpanOption `opts`. (Note that `opts` borrows
+	// from the "functional options" pattern, per
+	// http://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis)
+	//
+	// A Span with no SpanReference options (e.g., opentracing.ChildOf() or
+	// opentracing.FollowsFrom()) becomes the root of its own trace.
+	//
+	// Examples:
+	//
+	//     var tracer opentracing.Tracer = ...
+	//
+	//     // The root-span case:
+	//     sp := tracer.StartSpan("GetFeed")
+	//
+	//     // The vanilla child span case:
+	//     sp := tracer.StartSpan(
+	//         "GetFeed",
+	//         opentracing.ChildOf(parentSpan.Context()))
+	//
+	//     // All the bells and whistles:
+	//     sp := tracer.StartSpan(
+	//         "GetFeed",
+	//         opentracing.ChildOf(parentSpan.Context()),
+	//         opentracing.Tag("user_agent", loggedReq.UserAgent),
+	//         opentracing.StartTime(loggedReq.Timestamp),
+	//     )
+	//
+	StartSpan(operationName string, opts ...StartSpanOption) Span
+
+	// Inject() takes the `sm` SpanContext instance and injects it for
+	// propagation within `carrier`. The actual type of `carrier` depends on
+	// the value of `format`.
+	//
+	// OpenTracing defines a common set of `format` values (see BuiltinFormat),
+	// and each has an expected carrier type.
+	//
+	// Other packages may declare their own `format` values, much like the keys
+	// used by `context.Context` (see
+	// https://godoc.org/golang.org/x/net/context#WithValue).
+	//
+	// Example usage (sans error handling):
+	//
+	//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
+	//     err := tracer.Inject(
+	//         span.Context(),
+	//         opentracing.HTTPHeaders,
+	//         carrier)
+	//
+	// NOTE: All opentracing.Tracer implementations MUST support all
+	// BuiltinFormats.
+	//
+	// Implementations may return opentracing.ErrUnsupportedFormat if `format`
+	// is not supported by (or not known by) the implementation.
+	//
+	// Implementations may return opentracing.ErrInvalidCarrier or any other
+	// implementation-specific error if the format is supported but injection
+	// fails anyway.
+	//
+	// See Tracer.Extract().
+	Inject(sm SpanContext, format interface{}, carrier interface{}) error
+
+	// Extract() returns a SpanContext instance given `format` and `carrier`.
+	//
+	// OpenTracing defines a common set of `format` values (see BuiltinFormat),
+	// and each has an expected carrier type.
+	//
+	// Other packages may declare their own `format` values, much like the keys
+	// used by `context.Context` (see
+	// https://godoc.org/golang.org/x/net/context#WithValue).
+	//
+	// Example usage (with StartSpan):
+	//
+	//
+	//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
+	//     clientContext, err := tracer.Extract(opentracing.HTTPHeaders, carrier)
+	//
+	//     // ... assuming the ultimate goal here is to resume the trace with a
+	//     // server-side Span:
+	//     var serverSpan opentracing.Span
+	//     if err == nil {
+	//         span = tracer.StartSpan(
+	//             rpcMethodName, ext.RPCServerOption(clientContext))
+	//     } else {
+	//         span = tracer.StartSpan(rpcMethodName)
+	//     }
+	//
+	//
+	// NOTE: All opentracing.Tracer implementations MUST support all
+	// BuiltinFormats.
+	//
+	// Return values:
+	//  - A successful Extract returns a SpanContext instance and a nil error
+	//  - If there was simply no SpanContext to extract in `carrier`, Extract()
+	//    returns (nil, opentracing.ErrSpanContextNotFound)
+	//  - If `format` is unsupported or unrecognized, Extract() returns (nil,
+	//    opentracing.ErrUnsupportedFormat)
+	//  - If there are more fundamental problems with the `carrier` object,
+	//    Extract() may return opentracing.ErrInvalidCarrier,
+	//    opentracing.ErrSpanContextCorrupted, or implementation-specific
+	//    errors.
+	//
+	// See Tracer.Inject().
+	Extract(format interface{}, carrier interface{}) (SpanContext, error)
+}
+
+// StartSpanOptions allows Tracer.StartSpan() callers and implementors a
+// mechanism to override the start timestamp, specify Span References, and make
+// a single Tag or multiple Tags available at Span start time.
+//
+// StartSpan() callers should look at the StartSpanOption interface and
+// implementations available in this package.
+//
+// Tracer implementations can convert a slice of `StartSpanOption` instances
+// into a `StartSpanOptions` struct like so:
+//
+//     func StartSpan(opName string, opts ...opentracing.StartSpanOption) {
+//         sso := opentracing.StartSpanOptions{}
+//         for _, o := range opts {
+//             o.Apply(&sso)
+//         }
+//         ...
+//     }
+//
+type StartSpanOptions struct {
+	// Zero or more causal references to other Spans (via their SpanContext).
+	// If empty, start a "root" Span (i.e., start a new trace).
+	References []SpanReference
+
+	// StartTime overrides the Span's start time, or implicitly becomes
+	// time.Now() if StartTime.IsZero().
+	StartTime time.Time
+
+	// Tags may have zero or more entries; the restrictions on map values are
+	// identical to those for Span.SetTag(). May be nil.
+	//
+	// If specified, the caller hands off ownership of Tags at
+	// StartSpan() invocation time.
+	Tags map[string]interface{}
+}
+
+// StartSpanOption instances (zero or more) may be passed to Tracer.StartSpan.
+//
+// StartSpanOption borrows from the "functional options" pattern, per
+// http://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis
+type StartSpanOption interface {
+	Apply(*StartSpanOptions)
+}
+
+// SpanReferenceType is an enum type describing different categories of
+// relationships between two Spans. If Span-2 refers to Span-1, the
+// SpanReferenceType describes Span-1 from Span-2's perspective. For example,
+// ChildOfRef means that Span-1 created Span-2.
+//
+// NOTE: Span-1 and Span-2 do *not* necessarily depend on each other for
+// completion; e.g., Span-2 may be part of a background job enqueued by Span-1,
+// or Span-2 may be sitting in a distributed queue behind Span-1.
+type SpanReferenceType int
+
+const (
+	// ChildOfRef refers to a parent Span that caused *and* somehow depends
+	// upon the new child Span. Often (but not always), the parent Span cannot
+	// finish until the child Span does.
+	//
+	// An timing diagram for a ChildOfRef that's blocked on the new Span:
+	//
+	//     [-Parent Span---------]
+	//          [-Child Span----]
+	//
+	// See http://opentracing.io/spec/
+	//
+	// See opentracing.ChildOf()
+	ChildOfRef SpanReferenceType = iota
+
+	// FollowsFromRef refers to a parent Span that does not depend in any way
+	// on the result of the new child Span. For instance, one might use
+	// FollowsFromRefs to describe pipeline stages separated by queues,
+	// or a fire-and-forget cache insert at the tail end of a web request.
+	//
+	// A FollowsFromRef Span is part of the same logical trace as the new Span:
+	// i.e., the new Span is somehow caused by the work of its FollowsFromRef.
+	//
+	// All of the following could be valid timing diagrams for children that
+	// "FollowFrom" a parent.
+	//
+	//     [-Parent Span-]  [-Child Span-]
+	//
+	//
+	//     [-Parent Span--]
+	//      [-Child Span-]
+	//
+	//
+	//     [-Parent Span-]
+	//                 [-Child Span-]
+	//
+	// See http://opentracing.io/spec/
+	//
+	// See opentracing.FollowsFrom()
+	FollowsFromRef
+)
+
+// SpanReference is a StartSpanOption that pairs a SpanReferenceType and a
+// referenced SpanContext. See the SpanReferenceType documentation for
+// supported relationships.  If SpanReference is created with
+// ReferencedContext==nil, it has no effect. Thus it allows for a more concise
+// syntax for starting spans:
+//
+//     sc, _ := tracer.Extract(someFormat, someCarrier)
+//     span := tracer.StartSpan("operation", opentracing.ChildOf(sc))
+//
+// The `ChildOf(sc)` option above will not panic if sc == nil, it will just
+// not add the parent span reference to the options.
+type SpanReference struct {
+	Type              SpanReferenceType
+	ReferencedContext SpanContext
+}
+
+// Apply satisfies the StartSpanOption interface.
+func (r SpanReference) Apply(o *StartSpanOptions) {
+	if r.ReferencedContext != nil {
+		o.References = append(o.References, r)
+	}
+}
+
+// ChildOf returns a StartSpanOption pointing to a dependent parent span.
+// If sc == nil, the option has no effect.
+//
+// See ChildOfRef, SpanReference
+func ChildOf(sc SpanContext) SpanReference {
+	return SpanReference{
+		Type:              ChildOfRef,
+		ReferencedContext: sc,
+	}
+}
+
+// FollowsFrom returns a StartSpanOption pointing to a parent Span that caused
+// the child Span but does not directly depend on its result in any way.
+// If sc == nil, the option has no effect.
+//
+// See FollowsFromRef, SpanReference
+func FollowsFrom(sc SpanContext) SpanReference {
+	return SpanReference{
+		Type:              FollowsFromRef,
+		ReferencedContext: sc,
+	}
+}
+
+// StartTime is a StartSpanOption that sets an explicit start timestamp for the
+// new Span.
+type StartTime time.Time
+
+// Apply satisfies the StartSpanOption interface.
+func (t StartTime) Apply(o *StartSpanOptions) {
+	o.StartTime = time.Time(t)
+}
+
+// Tags are a generic map from an arbitrary string key to an opaque value type.
+// The underlying tracing system is responsible for interpreting and
+// serializing the values.
+type Tags map[string]interface{}
+
+// Apply satisfies the StartSpanOption interface.
+func (t Tags) Apply(o *StartSpanOptions) {
+	if o.Tags == nil {
+		o.Tags = make(map[string]interface{})
+	}
+	for k, v := range t {
+		o.Tags[k] = v
+	}
+}
+
+// Tag may be passed as a StartSpanOption to add a tag to new spans,
+// or its Set method may be used to apply the tag to an existing Span,
+// for example:
+//
+// tracer.StartSpan("opName", Tag{"Key", value})
+//
+//   or
+//
+// Tag{"key", value}.Set(span)
+type Tag struct {
+	Key   string
+	Value interface{}
+}
+
+// Apply satisfies the StartSpanOption interface.
+func (t Tag) Apply(o *StartSpanOptions) {
+	if o.Tags == nil {
+		o.Tags = make(map[string]interface{})
+	}
+	o.Tags[t.Key] = t.Value
+}
+
+// Set applies the tag to an existing Span.
+func (t Tag) Set(s Span) {
+	s.SetTag(t.Key, t.Value)
+}
diff --git a/vendor/github.com/satori/go.uuid/LICENSE b/vendor/github.com/satori/go.uuid/LICENSE
new file mode 100644
index 000000000..926d54987
--- /dev/null
+++ b/vendor/github.com/satori/go.uuid/LICENSE
@@ -0,0 +1,20 @@
+Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/satori/go.uuid/codec.go b/vendor/github.com/satori/go.uuid/codec.go
new file mode 100644
index 000000000..656892c53
--- /dev/null
+++ b/vendor/github.com/satori/go.uuid/codec.go
@@ -0,0 +1,206 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+)
+
+// FromBytes returns UUID converted from raw byte slice input.
+// It will return error if the slice isn't 16 bytes long.
+func FromBytes(input []byte) (u UUID, err error) {
+	err = u.UnmarshalBinary(input)
+	return
+}
+
+// FromBytesOrNil returns UUID converted from raw byte slice input.
+// Same behavior as FromBytes, but returns a Nil UUID on error.
+func FromBytesOrNil(input []byte) UUID {
+	uuid, err := FromBytes(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// FromString returns UUID parsed from string input.
+// Input is expected in a form accepted by UnmarshalText.
+func FromString(input string) (u UUID, err error) {
+	err = u.UnmarshalText([]byte(input))
+	return
+}
+
+// FromStringOrNil returns UUID parsed from string input.
+// Same behavior as FromString, but returns a Nil UUID on error.
+func FromStringOrNil(input string) UUID {
+	uuid, err := FromString(input)
+	if err != nil {
+		return Nil
+	}
+	return uuid
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The encoding is the same as returned by String.
+func (u UUID) MarshalText() (text []byte, err error) {
+	text = []byte(u.String())
+	return
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// Following formats are supported:
+//   "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+//   "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+//   "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+//   "6ba7b8109dad11d180b400c04fd430c8"
+// ABNF for supported UUID text representation follows:
+//   uuid := canonical | hashlike | braced | urn
+//   plain := canonical | hashlike
+//   canonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct
+//   hashlike := 12hexoct
+//   braced := '{' plain '}'
+//   urn := URN ':' UUID-NID ':' plain
+//   URN := 'urn'
+//   UUID-NID := 'uuid'
+//   12hexoct := 6hexoct 6hexoct
+//   6hexoct := 4hexoct 2hexoct
+//   4hexoct := 2hexoct 2hexoct
+//   2hexoct := hexoct hexoct
+//   hexoct := hexdig hexdig
+//   hexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
+//             'a' | 'b' | 'c' | 'd' | 'e' | 'f' |
+//             'A' | 'B' | 'C' | 'D' | 'E' | 'F'
+func (u *UUID) UnmarshalText(text []byte) (err error) {
+	switch len(text) {
+	case 32:
+		return u.decodeHashLike(text)
+	case 36:
+		return u.decodeCanonical(text)
+	case 38:
+		return u.decodeBraced(text)
+	case 41:
+		fallthrough
+	case 45:
+		return u.decodeURN(text)
+	default:
+		return fmt.Errorf("uuid: incorrect UUID length: %s", text)
+	}
+}
+
+// decodeCanonical decodes UUID string in format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
+func (u *UUID) decodeCanonical(t []byte) (err error) {
+	if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
+		return fmt.Errorf("uuid: incorrect UUID format %s", t)
+	}
+
+	src := t[:]
+	dst := u[:]
+
+	for i, byteGroup := range byteGroups {
+		if i > 0 {
+			src = src[1:] // skip dash
+		}
+		_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
+		if err != nil {
+			return
+		}
+		src = src[byteGroup:]
+		dst = dst[byteGroup/2:]
+	}
+
+	return
+}
+
+// decodeHashLike decodes UUID string in format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeHashLike(t []byte) (err error) {
+	src := t[:]
+	dst := u[:]
+
+	if _, err = hex.Decode(dst, src); err != nil {
+		return err
+	}
+	return
+}
+
+// decodeBraced decodes UUID string in format
+// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" or in format
+// "{6ba7b8109dad11d180b400c04fd430c8}".
+func (u *UUID) decodeBraced(t []byte) (err error) {
+	l := len(t)
+
+	if t[0] != '{' || t[l-1] != '}' {
+		return fmt.Errorf("uuid: incorrect UUID format %s", t)
+	}
+
+	return u.decodePlain(t[1 : l-1])
+}
+
+// decodeURN decodes UUID string in format
+// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in format
+// "urn:uuid:6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeURN(t []byte) (err error) {
+	total := len(t)
+
+	urn_uuid_prefix := t[:9]
+
+	if !bytes.Equal(urn_uuid_prefix, urnPrefix) {
+		return fmt.Errorf("uuid: incorrect UUID format: %s", t)
+	}
+
+	return u.decodePlain(t[9:total])
+}
+
+// decodePlain decodes UUID string in canonical format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodePlain(t []byte) (err error) {
+	switch len(t) {
+	case 32:
+		return u.decodeHashLike(t)
+	case 36:
+		return u.decodeCanonical(t)
+	default:
+		return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
+	}
+}
+
+// MarshalBinary implements the encoding.BinaryMarshaler interface.
+func (u UUID) MarshalBinary() (data []byte, err error) {
+	data = u.Bytes()
+	return
+}
+
+// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
+// It will return error if the slice isn't 16 bytes long.
+func (u *UUID) UnmarshalBinary(data []byte) (err error) {
+	if len(data) != Size {
+		err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
+		return
+	}
+	copy(u[:], data)
+
+	return
+}
diff --git a/vendor/github.com/satori/go.uuid/generator.go b/vendor/github.com/satori/go.uuid/generator.go
new file mode 100644
index 000000000..499dc35fb
--- /dev/null
+++ b/vendor/github.com/satori/go.uuid/generator.go
@@ -0,0 +1,265 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding/binary"
+	"fmt"
+	"hash"
+	"io"
+	"net"
+	"os"
+	"sync"
+	"time"
+)
+
+// Difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
+const epochStart = 122192928000000000
+
+type epochFunc func() time.Time
+type hwAddrFunc func() (net.HardwareAddr, error)
+
+var (
+	global = newRFC4122Generator()
+
+	posixUID = uint32(os.Getuid())
+	posixGID = uint32(os.Getgid())
+)
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func NewV1() (UUID, error) {
+	return global.NewV1()
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func NewV2(domain byte) (UUID, error) {
+	return global.NewV2(domain)
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func NewV3(ns UUID, name string) UUID {
+	return global.NewV3(ns, name)
+}
+
+// NewV4 returns random generated UUID.
+func NewV4() (UUID, error) {
+	return global.NewV4()
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func NewV5(ns UUID, name string) UUID {
+	return global.NewV5(ns, name)
+}
+
+// Generator provides interface for generating UUIDs.
+type Generator interface {
+	NewV1() (UUID, error)
+	NewV2(domain byte) (UUID, error)
+	NewV3(ns UUID, name string) UUID
+	NewV4() (UUID, error)
+	NewV5(ns UUID, name string) UUID
+}
+
+// Default generator implementation.
+type rfc4122Generator struct {
+	clockSequenceOnce sync.Once
+	hardwareAddrOnce  sync.Once
+	storageMutex      sync.Mutex
+
+	rand io.Reader
+
+	epochFunc     epochFunc
+	hwAddrFunc    hwAddrFunc
+	lastTime      uint64
+	clockSequence uint16
+	hardwareAddr  [6]byte
+}
+
+func newRFC4122Generator() Generator {
+	return &rfc4122Generator{
+		epochFunc:  time.Now,
+		hwAddrFunc: defaultHWAddrFunc,
+		rand:       rand.Reader,
+	}
+}
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func (g *rfc4122Generator) NewV1() (UUID, error) {
+	u := UUID{}
+
+	timeNow, clockSeq, err := g.getClockSequence()
+	if err != nil {
+		return Nil, err
+	}
+	binary.BigEndian.PutUint32(u[0:], uint32(timeNow))
+	binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+	binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+	binary.BigEndian.PutUint16(u[8:], clockSeq)
+
+	hardwareAddr, err := g.getHardwareAddr()
+	if err != nil {
+		return Nil, err
+	}
+	copy(u[10:], hardwareAddr)
+
+	u.SetVersion(V1)
+	u.SetVariant(VariantRFC4122)
+
+	return u, nil
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func (g *rfc4122Generator) NewV2(domain byte) (UUID, error) {
+	u, err := g.NewV1()
+	if err != nil {
+		return Nil, err
+	}
+
+	switch domain {
+	case DomainPerson:
+		binary.BigEndian.PutUint32(u[:], posixUID)
+	case DomainGroup:
+		binary.BigEndian.PutUint32(u[:], posixGID)
+	}
+
+	u[9] = domain
+
+	u.SetVersion(V2)
+	u.SetVariant(VariantRFC4122)
+
+	return u, nil
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func (g *rfc4122Generator) NewV3(ns UUID, name string) UUID {
+	u := newFromHash(md5.New(), ns, name)
+	u.SetVersion(V3)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// NewV4 returns random generated UUID.
+func (g *rfc4122Generator) NewV4() (UUID, error) {
+	u := UUID{}
+	if _, err := g.rand.Read(u[:]); err != nil {
+		return Nil, err
+	}
+	u.SetVersion(V4)
+	u.SetVariant(VariantRFC4122)
+
+	return u, nil
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func (g *rfc4122Generator) NewV5(ns UUID, name string) UUID {
+	u := newFromHash(sha1.New(), ns, name)
+	u.SetVersion(V5)
+	u.SetVariant(VariantRFC4122)
+
+	return u
+}
+
+// Returns epoch and clock sequence.
+func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
+	var err error
+	g.clockSequenceOnce.Do(func() {
+		buf := make([]byte, 2)
+		if _, err = g.rand.Read(buf); err != nil {
+			return
+		}
+		g.clockSequence = binary.BigEndian.Uint16(buf)
+	})
+	if err != nil {
+		return 0, 0, err
+	}
+
+	g.storageMutex.Lock()
+	defer g.storageMutex.Unlock()
+
+	timeNow := g.getEpoch()
+	// Clock didn't change since last UUID generation.
+	// Should increase clock sequence.
+	if timeNow <= g.lastTime {
+		g.clockSequence++
+	}
+	g.lastTime = timeNow
+
+	return timeNow, g.clockSequence, nil
+}
+
+// Returns hardware address.
+func (g *rfc4122Generator) getHardwareAddr() ([]byte, error) {
+	var err error
+	g.hardwareAddrOnce.Do(func() {
+		if hwAddr, err := g.hwAddrFunc(); err == nil {
+			copy(g.hardwareAddr[:], hwAddr)
+			return
+		}
+
+		// Initialize hardwareAddr randomly in case
+		// of real network interfaces absence.
+		if _, err = g.rand.Read(g.hardwareAddr[:]); err != nil {
+			return
+		}
+		// Set multicast bit as recommended by RFC 4122
+		g.hardwareAddr[0] |= 0x01
+	})
+	if err != nil {
+		return []byte{}, err
+	}
+	return g.hardwareAddr[:], nil
+}
+
+// Returns difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and current time.
+func (g *rfc4122Generator) getEpoch() uint64 {
+	return epochStart + uint64(g.epochFunc().UnixNano()/100)
+}
+
+// Returns UUID based on hashing of namespace UUID and name.
+func newFromHash(h hash.Hash, ns UUID, name string) UUID {
+	u := UUID{}
+	h.Write(ns[:])
+	h.Write([]byte(name))
+	copy(u[:], h.Sum(nil))
+
+	return u
+}
+
+// Returns hardware address.
+func defaultHWAddrFunc() (net.HardwareAddr, error) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return []byte{}, err
+	}
+	for _, iface := range ifaces {
+		if len(iface.HardwareAddr) >= 6 {
+			return iface.HardwareAddr, nil
+		}
+	}
+	return []byte{}, fmt.Errorf("uuid: no HW address found")
+}
diff --git a/vendor/github.com/satori/go.uuid/sql.go b/vendor/github.com/satori/go.uuid/sql.go
new file mode 100644
index 000000000..56759d390
--- /dev/null
+++ b/vendor/github.com/satori/go.uuid/sql.go
@@ -0,0 +1,78 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+	"database/sql/driver"
+	"fmt"
+)
+
+// Value implements the driver.Valuer interface.
+func (u UUID) Value() (driver.Value, error) {
+	return u.String(), nil
+}
+
+// Scan implements the sql.Scanner interface.
+// A 16-byte slice is handled by UnmarshalBinary, while
+// a longer byte slice or a string is handled by UnmarshalText.
+func (u *UUID) Scan(src interface{}) error {
+	switch src := src.(type) {
+	case []byte:
+		if len(src) == Size {
+			return u.UnmarshalBinary(src)
+		}
+		return u.UnmarshalText(src)
+
+	case string:
+		return u.UnmarshalText([]byte(src))
+	}
+
+	return fmt.Errorf("uuid: cannot convert %T to UUID", src)
+}
+
+// NullUUID can be used with the standard sql package to represent a
+// UUID value that can be NULL in the database
+type NullUUID struct {
+	UUID  UUID
+	Valid bool
+}
+
+// Value implements the driver.Valuer interface.
+func (u NullUUID) Value() (driver.Value, error) {
+	if !u.Valid {
+		return nil, nil
+	}
+	// Delegate to UUID Value function
+	return u.UUID.Value()
+}
+
+// Scan implements the sql.Scanner interface.
+func (u *NullUUID) Scan(src interface{}) error {
+	if src == nil {
+		u.UUID, u.Valid = Nil, false
+		return nil
+	}
+
+	// Delegate to UUID Scan function
+	u.Valid = true
+	return u.UUID.Scan(src)
+}
diff --git a/vendor/github.com/satori/go.uuid/uuid.go b/vendor/github.com/satori/go.uuid/uuid.go
new file mode 100644
index 000000000..a2b8e2ca2
--- /dev/null
+++ b/vendor/github.com/satori/go.uuid/uuid.go
@@ -0,0 +1,161 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Package uuid provides implementation of Universally Unique Identifier (UUID).
+// Supported versions are 1, 3, 4 and 5 (as specified in RFC 4122) and
+// version 2 (as specified in DCE 1.1).
+package uuid
+
+import (
+	"bytes"
+	"encoding/hex"
+)
+
+// Size of a UUID in bytes.
+const Size = 16
+
+// UUID representation compliant with specification
+// described in RFC 4122.
+type UUID [Size]byte
+
+// UUID versions
+const (
+	_ byte = iota
+	V1
+	V2
+	V3
+	V4
+	V5
+)
+
+// UUID layout variants.
+const (
+	VariantNCS byte = iota
+	VariantRFC4122
+	VariantMicrosoft
+	VariantFuture
+)
+
+// UUID DCE domains.
+const (
+	DomainPerson = iota
+	DomainGroup
+	DomainOrg
+)
+
+// String parse helpers.
+var (
+	urnPrefix  = []byte("urn:uuid:")
+	byteGroups = []int{8, 4, 4, 4, 12}
+)
+
+// Nil is special form of UUID that is specified to have all
+// 128 bits set to zero.
+var Nil = UUID{}
+
+// Predefined namespace UUIDs.
+var (
+	NamespaceDNS  = Must(FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceURL  = Must(FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceOID  = Must(FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
+	NamespaceX500 = Must(FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
+)
+
+// Equal returns true if u1 and u2 equals, otherwise returns false.
+func Equal(u1 UUID, u2 UUID) bool {
+	return bytes.Equal(u1[:], u2[:])
+}
+
+// Version returns algorithm version used to generate UUID.
+func (u UUID) Version() byte {
+	return u[6] >> 4
+}
+
+// Variant returns UUID layout variant.
+func (u UUID) Variant() byte {
+	switch {
+	case (u[8] >> 7) == 0x00:
+		return VariantNCS
+	case (u[8] >> 6) == 0x02:
+		return VariantRFC4122
+	case (u[8] >> 5) == 0x06:
+		return VariantMicrosoft
+	case (u[8] >> 5) == 0x07:
+		fallthrough
+	default:
+		return VariantFuture
+	}
+}
+
+// Bytes returns bytes slice representation of UUID.
+func (u UUID) Bytes() []byte {
+	return u[:]
+}
+
+// Returns canonical string representation of UUID:
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (u UUID) String() string {
+	buf := make([]byte, 36)
+
+	hex.Encode(buf[0:8], u[0:4])
+	buf[8] = '-'
+	hex.Encode(buf[9:13], u[4:6])
+	buf[13] = '-'
+	hex.Encode(buf[14:18], u[6:8])
+	buf[18] = '-'
+	hex.Encode(buf[19:23], u[8:10])
+	buf[23] = '-'
+	hex.Encode(buf[24:], u[10:])
+
+	return string(buf)
+}
+
+// SetVersion sets version bits.
+func (u *UUID) SetVersion(v byte) {
+	u[6] = (u[6] & 0x0f) | (v << 4)
+}
+
+// SetVariant sets variant bits.
+func (u *UUID) SetVariant(v byte) {
+	switch v {
+	case VariantNCS:
+		u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
+	case VariantRFC4122:
+		u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
+	case VariantMicrosoft:
+		u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
+	case VariantFuture:
+		fallthrough
+	default:
+		u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
+	}
+}
+
+// Must is a helper that wraps a call to a function returning (UUID, error)
+// and panics if the error is non-nil. It is intended for use in variable
+// initializations such as
+//	var packageUUID = uuid.Must(uuid.FromString("123e4567-e89b-12d3-a456-426655440000"));
+func Must(u UUID, err error) UUID {
+	if err != nil {
+		panic(err)
+	}
+	return u
+}
diff --git a/vendor/github.com/spaolacci/murmur3/LICENSE b/vendor/github.com/spaolacci/murmur3/LICENSE
new file mode 100644
index 000000000..2a46fd750
--- /dev/null
+++ b/vendor/github.com/spaolacci/murmur3/LICENSE
@@ -0,0 +1,24 @@
+Copyright 2013, Sébastien Paolacci.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the library nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/spaolacci/murmur3/murmur.go b/vendor/github.com/spaolacci/murmur3/murmur.go
new file mode 100644
index 000000000..1252cf73a
--- /dev/null
+++ b/vendor/github.com/spaolacci/murmur3/murmur.go
@@ -0,0 +1,64 @@
+// Copyright 2013, Sébastien Paolacci. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package murmur3 implements Austin Appleby's non-cryptographic MurmurHash3.
+
+ Reference implementation:
+    http://code.google.com/p/smhasher/wiki/MurmurHash3
+
+ History, characteristics and (legacy) perfs:
+    https://sites.google.com/site/murmurhash/
+    https://sites.google.com/site/murmurhash/statistics
+*/
+package murmur3
+
+type bmixer interface {
+	bmix(p []byte) (tail []byte)
+	Size() (n int)
+	reset()
+}
+
+type digest struct {
+	clen int      // Digested input cumulative length.
+	tail []byte   // 0 to Size()-1 bytes view of `buf'.
+	buf  [16]byte // Expected (but not required) to be Size() large.
+	seed uint32   // Seed for initializing the hash.
+	bmixer
+}
+
+func (d *digest) BlockSize() int { return 1 }
+
+func (d *digest) Write(p []byte) (n int, err error) {
+	n = len(p)
+	d.clen += n
+
+	if len(d.tail) > 0 {
+		// Stick back pending bytes.
+		nfree := d.Size() - len(d.tail) // nfree ∈ [1, d.Size()-1].
+		if nfree < len(p) {
+			// One full block can be formed.
+			block := append(d.tail, p[:nfree]...)
+			p = p[nfree:]
+			_ = d.bmix(block) // No tail.
+		} else {
+			// Tail's buf is large enough to prevent reallocs.
+			p = append(d.tail, p...)
+		}
+	}
+
+	d.tail = d.bmix(p)
+
+	// Keep own copy of the 0 to Size()-1 pending bytes.
+	nn := copy(d.buf[:], d.tail)
+	d.tail = d.buf[:nn]
+
+	return n, nil
+}
+
+func (d *digest) Reset() {
+	d.clen = 0
+	d.tail = nil
+	d.bmixer.reset()
+}
diff --git a/vendor/github.com/spaolacci/murmur3/murmur128.go b/vendor/github.com/spaolacci/murmur3/murmur128.go
new file mode 100644
index 000000000..a4b618b5f
--- /dev/null
+++ b/vendor/github.com/spaolacci/murmur3/murmur128.go
@@ -0,0 +1,203 @@
+package murmur3
+
+import (
+	//"encoding/binary"
+	"hash"
+	"unsafe"
+)
+
+const (
+	c1_128 = 0x87c37b91114253d5
+	c2_128 = 0x4cf5ad432745937f
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash = new(digest128)
+	_ Hash128   = new(digest128)
+	_ bmixer    = new(digest128)
+)
+
+// Hash128 represents a 128-bit hasher
+// Hack: the standard api doesn't define any Hash128 interface.
+type Hash128 interface {
+	hash.Hash
+	Sum128() (uint64, uint64)
+}
+
+// digest128 represents a partial evaluation of a 128 bites hash.
+type digest128 struct {
+	digest
+	h1 uint64 // Unfinalized running hash part 1.
+	h2 uint64 // Unfinalized running hash part 2.
+}
+
+// New128 returns a 128-bit hasher
+func New128() Hash128 { return New128WithSeed(0) }
+
+// New128WithSeed returns a 128-bit hasher set with explicit seed value
+func New128WithSeed(seed uint32) Hash128 {
+	d := new(digest128)
+	d.seed = seed
+	d.bmixer = d
+	d.Reset()
+	return d
+}
+
+func (d *digest128) Size() int { return 16 }
+
+func (d *digest128) reset() { d.h1, d.h2 = uint64(d.seed), uint64(d.seed) }
+
+func (d *digest128) Sum(b []byte) []byte {
+	h1, h2 := d.Sum128()
+	return append(b,
+		byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+		byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1),
+
+		byte(h2>>56), byte(h2>>48), byte(h2>>40), byte(h2>>32),
+		byte(h2>>24), byte(h2>>16), byte(h2>>8), byte(h2),
+	)
+}
+
+func (d *digest128) bmix(p []byte) (tail []byte) {
+	h1, h2 := d.h1, d.h2
+
+	nblocks := len(p) / 16
+	for i := 0; i < nblocks; i++ {
+		t := (*[2]uint64)(unsafe.Pointer(&p[i*16]))
+		k1, k2 := t[0], t[1]
+
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+
+		h1 = (h1 << 27) | (h1 >> 37) // rotl64(h1, 27)
+		h1 += h2
+		h1 = h1*5 + 0x52dce729
+
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+
+		h2 = (h2 << 31) | (h2 >> 33) // rotl64(h2, 31)
+		h2 += h1
+		h2 = h2*5 + 0x38495ab5
+	}
+	d.h1, d.h2 = h1, h2
+	return p[nblocks*d.Size():]
+}
+
+func (d *digest128) Sum128() (h1, h2 uint64) {
+
+	h1, h2 = d.h1, d.h2
+
+	var k1, k2 uint64
+	switch len(d.tail) & 15 {
+	case 15:
+		k2 ^= uint64(d.tail[14]) << 48
+		fallthrough
+	case 14:
+		k2 ^= uint64(d.tail[13]) << 40
+		fallthrough
+	case 13:
+		k2 ^= uint64(d.tail[12]) << 32
+		fallthrough
+	case 12:
+		k2 ^= uint64(d.tail[11]) << 24
+		fallthrough
+	case 11:
+		k2 ^= uint64(d.tail[10]) << 16
+		fallthrough
+	case 10:
+		k2 ^= uint64(d.tail[9]) << 8
+		fallthrough
+	case 9:
+		k2 ^= uint64(d.tail[8]) << 0
+
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+
+		fallthrough
+
+	case 8:
+		k1 ^= uint64(d.tail[7]) << 56
+		fallthrough
+	case 7:
+		k1 ^= uint64(d.tail[6]) << 48
+		fallthrough
+	case 6:
+		k1 ^= uint64(d.tail[5]) << 40
+		fallthrough
+	case 5:
+		k1 ^= uint64(d.tail[4]) << 32
+		fallthrough
+	case 4:
+		k1 ^= uint64(d.tail[3]) << 24
+		fallthrough
+	case 3:
+		k1 ^= uint64(d.tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint64(d.tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint64(d.tail[0]) << 0
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+	}
+
+	h1 ^= uint64(d.clen)
+	h2 ^= uint64(d.clen)
+
+	h1 += h2
+	h2 += h1
+
+	h1 = fmix64(h1)
+	h2 = fmix64(h2)
+
+	h1 += h2
+	h2 += h1
+
+	return h1, h2
+}
+
+func fmix64(k uint64) uint64 {
+	k ^= k >> 33
+	k *= 0xff51afd7ed558ccd
+	k ^= k >> 33
+	k *= 0xc4ceb9fe1a85ec53
+	k ^= k >> 33
+	return k
+}
+
+/*
+func rotl64(x uint64, r byte) uint64 {
+	return (x << r) | (x >> (64 - r))
+}
+*/
+
+// Sum128 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New128()
+//     hasher.Write(data)
+//     return hasher.Sum128()
+func Sum128(data []byte) (h1 uint64, h2 uint64) { return Sum128WithSeed(data, 0) }
+
+// Sum128WithSeed returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New128WithSeed(seed)
+//     hasher.Write(data)
+//     return hasher.Sum128()
+func Sum128WithSeed(data []byte, seed uint32) (h1 uint64, h2 uint64) {
+	d := &digest128{h1: uint64(seed), h2: uint64(seed)}
+	d.seed = seed
+	d.tail = d.bmix(data)
+	d.clen = len(data)
+	return d.Sum128()
+}
diff --git a/vendor/github.com/spaolacci/murmur3/murmur32.go b/vendor/github.com/spaolacci/murmur3/murmur32.go
new file mode 100644
index 000000000..e32c99511
--- /dev/null
+++ b/vendor/github.com/spaolacci/murmur3/murmur32.go
@@ -0,0 +1,167 @@
+package murmur3
+
+// http://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/hash/Murmur3_32HashFunction.java
+
+import (
+	"hash"
+	"unsafe"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash   = new(digest32)
+	_ hash.Hash32 = new(digest32)
+	_ bmixer      = new(digest32)
+)
+
+const (
+	c1_32 uint32 = 0xcc9e2d51
+	c2_32 uint32 = 0x1b873593
+)
+
+// digest32 represents a partial evaluation of a 32 bites hash.
+type digest32 struct {
+	digest
+	h1 uint32 // Unfinalized running hash.
+}
+
+// New32 returns new 32-bit hasher
+func New32() hash.Hash32 { return New32WithSeed(0) }
+
+// New32WithSeed returns new 32-bit hasher set with explicit seed value
+func New32WithSeed(seed uint32) hash.Hash32 {
+	d := new(digest32)
+	d.seed = seed
+	d.bmixer = d
+	d.Reset()
+	return d
+}
+
+func (d *digest32) Size() int { return 4 }
+
+func (d *digest32) reset() { d.h1 = d.seed }
+
+func (d *digest32) Sum(b []byte) []byte {
+	h := d.Sum32()
+	return append(b, byte(h>>24), byte(h>>16), byte(h>>8), byte(h))
+}
+
+// Digest as many blocks as possible.
+func (d *digest32) bmix(p []byte) (tail []byte) {
+	h1 := d.h1
+
+	nblocks := len(p) / 4
+	for i := 0; i < nblocks; i++ {
+		k1 := *(*uint32)(unsafe.Pointer(&p[i*4]))
+
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+
+		h1 ^= k1
+		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = h1*4 + h1 + 0xe6546b64
+	}
+	d.h1 = h1
+	return p[nblocks*d.Size():]
+}
+
+func (d *digest32) Sum32() (h1 uint32) {
+
+	h1 = d.h1
+
+	var k1 uint32
+	switch len(d.tail) & 3 {
+	case 3:
+		k1 ^= uint32(d.tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint32(d.tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint32(d.tail[0])
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+		h1 ^= k1
+	}
+
+	h1 ^= uint32(d.clen)
+
+	h1 ^= h1 >> 16
+	h1 *= 0x85ebca6b
+	h1 ^= h1 >> 13
+	h1 *= 0xc2b2ae35
+	h1 ^= h1 >> 16
+
+	return h1
+}
+
+/*
+func rotl32(x uint32, r byte) uint32 {
+	return (x << r) | (x >> (32 - r))
+}
+*/
+
+// Sum32 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New32()
+//     hasher.Write(data)
+//     return hasher.Sum32()
+func Sum32(data []byte) uint32 { return Sum32WithSeed(data, 0) }
+
+// Sum32WithSeed returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New32WithSeed(seed)
+//     hasher.Write(data)
+//     return hasher.Sum32()
+func Sum32WithSeed(data []byte, seed uint32) uint32 {
+
+	h1 := seed
+
+	nblocks := len(data) / 4
+	var p uintptr
+	if len(data) > 0 {
+		p = uintptr(unsafe.Pointer(&data[0]))
+	}
+	p1 := p + uintptr(4*nblocks)
+	for ; p < p1; p += 4 {
+		k1 := *(*uint32)(unsafe.Pointer(p))
+
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+
+		h1 ^= k1
+		h1 = (h1 << 13) | (h1 >> 19) // rotl32(h1, 13)
+		h1 = h1*4 + h1 + 0xe6546b64
+	}
+
+	tail := data[nblocks*4:]
+
+	var k1 uint32
+	switch len(tail) & 3 {
+	case 3:
+		k1 ^= uint32(tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint32(tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint32(tail[0])
+		k1 *= c1_32
+		k1 = (k1 << 15) | (k1 >> 17) // rotl32(k1, 15)
+		k1 *= c2_32
+		h1 ^= k1
+	}
+
+	h1 ^= uint32(len(data))
+
+	h1 ^= h1 >> 16
+	h1 *= 0x85ebca6b
+	h1 ^= h1 >> 13
+	h1 *= 0xc2b2ae35
+	h1 ^= h1 >> 16
+
+	return h1
+}
diff --git a/vendor/github.com/spaolacci/murmur3/murmur64.go b/vendor/github.com/spaolacci/murmur3/murmur64.go
new file mode 100644
index 000000000..65a410ae0
--- /dev/null
+++ b/vendor/github.com/spaolacci/murmur3/murmur64.go
@@ -0,0 +1,57 @@
+package murmur3
+
+import (
+	"hash"
+)
+
+// Make sure interfaces are correctly implemented.
+var (
+	_ hash.Hash   = new(digest64)
+	_ hash.Hash64 = new(digest64)
+	_ bmixer      = new(digest64)
+)
+
+// digest64 is half a digest128.
+type digest64 digest128
+
+// New64 returns a 64-bit hasher
+func New64() hash.Hash64 { return New64WithSeed(0) }
+
+// New64WithSeed returns a 64-bit hasher set with explicit seed value
+func New64WithSeed(seed uint32) hash.Hash64 {
+	d := (*digest64)(New128WithSeed(seed).(*digest128))
+	return d
+}
+
+func (d *digest64) Sum(b []byte) []byte {
+	h1 := d.Sum64()
+	return append(b,
+		byte(h1>>56), byte(h1>>48), byte(h1>>40), byte(h1>>32),
+		byte(h1>>24), byte(h1>>16), byte(h1>>8), byte(h1))
+}
+
+func (d *digest64) Sum64() uint64 {
+	h1, _ := (*digest128)(d).Sum128()
+	return h1
+}
+
+// Sum64 returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New64()
+//     hasher.Write(data)
+//     return hasher.Sum64()
+func Sum64(data []byte) uint64 { return Sum64WithSeed(data, 0) }
+
+// Sum64WithSeed returns the MurmurHash3 sum of data. It is equivalent to the
+// following sequence (without the extra burden and the extra allocation):
+//     hasher := New64WithSeed(seed)
+//     hasher.Write(data)
+//     return hasher.Sum64()
+func Sum64WithSeed(data []byte, seed uint32) uint64 {
+	d := &digest128{h1: uint64(seed), h2: uint64(seed)}
+	d.seed = seed
+	d.tail = d.bmix(data)
+	d.clen = len(data)
+	h1, _ := d.Sum128()
+	return h1
+}
diff --git a/vendor/github.com/status-im/go-multiaddr-ethv4/protocol.go b/vendor/github.com/status-im/go-multiaddr-ethv4/protocol.go
new file mode 100644
index 000000000..232586e3b
--- /dev/null
+++ b/vendor/github.com/status-im/go-multiaddr-ethv4/protocol.go
@@ -0,0 +1,57 @@
+package ethv4
+
+import (
+	"crypto/ecdsa"
+	"errors"
+
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+	mh "github.com/multiformats/go-multihash"
+)
+
+const (
+	P_ETHv4 = 0x01EA
+)
+
+func init() {
+	if err := ma.AddProtocol(ma.Protocol{P_ETHv4, 39 * 8, "ethv4", ma.CodeToVarint(P_ETHv4), false, TranscoderETHv4}); err != nil {
+		panic(err)
+	}
+}
+
+var TranscoderETHv4 = ma.NewTranscoderFromFunctions(ethv4StB, ethv4BtS)
+
+func ethv4StB(s string) ([]byte, error) {
+	id, err := mh.FromB58String(s)
+	if err != nil {
+		return nil, err
+	}
+	return id, err
+}
+
+func ethv4BtS(b []byte) (string, error) {
+	id, err := mh.Cast(b)
+	if err != nil {
+		return "", err
+	}
+	return id.B58String(), err
+}
+
+// PeerIDToNodeID casts peer.ID (b58 encoded string) to discover.NodeID
+func PeerIDToNodeID(pid string) (n discover.NodeID, err error) {
+	nodeid, err := peer.IDB58Decode(pid)
+	if err != nil {
+		return n, err
+	}
+	pubkey, err := nodeid.ExtractPublicKey()
+	if err != nil {
+		return n, err
+	}
+	seckey, ok := pubkey.(*crypto.Secp256k1PublicKey)
+	if !ok {
+		return n, errors.New("public key is not on the secp256k1 curve")
+	}
+	return discover.PubkeyID((*ecdsa.PublicKey)(seckey)), nil
+}
diff --git a/vendor/github.com/status-im/rendezvous/client.go b/vendor/github.com/status-im/rendezvous/client.go
new file mode 100644
index 000000000..272ed15be
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/client.go
@@ -0,0 +1,136 @@
+package rendezvous
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/ethereum/go-ethereum/rlp"
+	libp2p "github.com/libp2p/go-libp2p"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	host "github.com/libp2p/go-libp2p-host"
+	peer "github.com/libp2p/go-libp2p-peer"
+	ma "github.com/multiformats/go-multiaddr"
+	ethv4 "github.com/status-im/go-multiaddr-ethv4"
+	"github.com/status-im/rendezvous/protocol"
+)
+
+var logger = log.New("package", "rendezvous/client")
+
+func NewTemporary() (c Client, err error) {
+	priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, rand.Reader)
+	if err != nil {
+		return Client{}, err
+	}
+	return New(priv)
+}
+
+func New(identity crypto.PrivKey) (c Client, err error) {
+	opts := []libp2p.Option{
+		libp2p.Identity(identity),
+	}
+	h, err := libp2p.New(context.Background(), opts...)
+	if err != nil {
+		return c, err
+	}
+	return Client{
+		identity: identity,
+		h:        h,
+	}, nil
+}
+
+type Client struct {
+	laddr    ma.Multiaddr
+	identity crypto.PrivKey
+
+	h host.Host
+}
+
+func (c Client) Register(ctx context.Context, srv ma.Multiaddr, topic string, record enr.Record) error {
+	s, err := c.newStream(ctx, srv)
+	if err != nil {
+		return err
+	}
+	defer s.Close()
+	if err = rlp.Encode(s, protocol.REGISTER); err != nil {
+		return err
+	}
+	if err = rlp.Encode(s, protocol.Register{Topic: topic, Record: record, TTL: uint64(5 * time.Second)}); err != nil {
+		return err
+	}
+	rs := rlp.NewStream(s, 0)
+	typ, err := rs.Uint()
+	if err != nil {
+		return err
+	}
+	if protocol.MessageType(typ) != protocol.REGISTER_RESPONSE {
+		return fmt.Errorf("expected %v as response, but got %v", protocol.REGISTER_RESPONSE, typ)
+	}
+	var val protocol.RegisterResponse
+	if err = rs.Decode(&val); err != nil {
+		return err
+	}
+	logger.Debug("received response to register", "status", val.Status, "message", val.Message)
+	if val.Status != protocol.OK {
+		return fmt.Errorf("register failed. status code %v", val.Status)
+	}
+	return nil
+}
+
+func (c Client) Discover(ctx context.Context, srv ma.Multiaddr, topic string, limit int) (rst []enr.Record, err error) {
+	s, err := c.newStream(ctx, srv)
+	if err != nil {
+		return
+	}
+	defer s.Close()
+	if err = rlp.Encode(s, protocol.DISCOVER); err != nil {
+		return
+	}
+	if err = rlp.Encode(s, protocol.Discover{Topic: topic, Limit: uint(limit)}); err != nil {
+		return
+	}
+	rs := rlp.NewStream(s, 0)
+	typ, err := rs.Uint()
+	if err != nil {
+		return nil, err
+	}
+	if protocol.MessageType(typ) != protocol.DISCOVER_RESPONSE {
+		return nil, fmt.Errorf("expected %v as response, but got %v", protocol.REGISTER_RESPONSE, typ)
+	}
+	var val protocol.DiscoverResponse
+	if err = rs.Decode(&val); err != nil {
+		return
+	}
+	if val.Status != protocol.OK {
+		return nil, fmt.Errorf("discover request failed. status code %v", val.Status)
+	}
+	logger.Debug("received response to discover request", "status", val.Status, "records lth", len(val.Records))
+	return val.Records, nil
+}
+
+func (c Client) newStream(ctx context.Context, srv ma.Multiaddr) (rw io.ReadWriteCloser, err error) {
+	pid, err := srv.ValueForProtocol(ethv4.P_ETHv4)
+	if err != nil {
+		return
+	}
+	peerid, err := peer.IDB58Decode(pid)
+	if err != nil {
+		return
+	}
+	// TODO there must be a better interface
+	targetPeerAddr, err := ma.NewMultiaddr(fmt.Sprintf("/ethv4/%s", pid))
+	if err != nil {
+		return
+	}
+	targetAddr := srv.Decapsulate(targetPeerAddr)
+	c.h.Peerstore().AddAddr(peerid, targetAddr, 5*time.Second)
+	s, err := c.h.NewStream(ctx, peerid, "/rend/0.1.0")
+	if err != nil {
+		return nil, err
+	}
+	return InstrumenetedStream{s}, nil
+}
diff --git a/vendor/github.com/status-im/rendezvous/protocol/protocol.go b/vendor/github.com/status-im/rendezvous/protocol/protocol.go
new file mode 100644
index 000000000..20560c7fd
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/protocol/protocol.go
@@ -0,0 +1,48 @@
+package protocol
+
+import (
+	"github.com/ethereum/go-ethereum/p2p/enr"
+)
+
+type ResponseStatus uint
+type MessageType uint64
+
+const (
+	VERSION = "/rend/0.1.0"
+
+	REGISTER MessageType = iota
+	REGISTER_RESPONSE
+	DISCOVER
+	DISCOVER_RESPONSE
+
+	OK                  ResponseStatus = 0
+	E_INVALID_NAMESPACE ResponseStatus = 100
+	E_INVALID_ENR       ResponseStatus = 101
+	E_INVALID_TTL       ResponseStatus = 102
+	E_INVALID_LIMIT     ResponseStatus = 103
+	E_INVALID_CONTENT   ResponseStatus = 104
+	E_NOT_AUTHORIZED    ResponseStatus = 200
+	E_INTERNAL_ERROR    ResponseStatus = 300
+)
+
+type Register struct {
+	Topic  string
+	Record enr.Record
+	TTL    uint64
+}
+
+type RegisterResponse struct {
+	Status  ResponseStatus
+	Message string
+}
+
+type Discover struct {
+	Limit uint
+	Topic string
+}
+
+type DiscoverResponse struct {
+	Status  ResponseStatus
+	Message string
+	Records []enr.Record
+}
diff --git a/vendor/github.com/status-im/rendezvous/server/cleaner.go b/vendor/github.com/status-im/rendezvous/server/cleaner.go
new file mode 100644
index 000000000..9dd6e0b43
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/server/cleaner.go
@@ -0,0 +1,72 @@
+package server
+
+import (
+	"container/heap"
+	"sync"
+	"time"
+)
+
+// definitely rename
+// Rewrite cleaner to operate on a leveldb directly
+// if it is impossible to query on topic+timestamp(big endian) for purging
+// store an additional key
+func NewCleaner() *Cleaner {
+	return &Cleaner{
+		heap:      []string{},
+		deadlines: map[string]time.Time{},
+	}
+}
+
+type Cleaner struct {
+	mu        sync.RWMutex
+	heap      []string
+	deadlines map[string]time.Time
+}
+
+func (c *Cleaner) Id(index int) string {
+	return c.heap[index]
+}
+
+func (c *Cleaner) Len() int {
+	return len(c.heap)
+}
+
+func (c *Cleaner) Less(i, j int) bool {
+	return c.deadlines[c.Id(i)].Before(c.deadlines[c.Id(j)])
+}
+
+func (c *Cleaner) Swap(i, j int) {
+	c.heap[i], c.heap[j] = c.heap[j], c.heap[i]
+}
+
+func (c *Cleaner) Push(record interface{}) {
+	c.heap = append(c.heap, record.(string))
+}
+
+func (c *Cleaner) Pop() interface{} {
+	old := c.heap
+	n := len(old)
+	x := old[n-1]
+	c.heap = old[0 : n-1]
+	delete(c.deadlines, x)
+	return x
+}
+
+func (c *Cleaner) Add(deadline time.Time, key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.deadlines[key] = deadline
+	heap.Push(c, key)
+}
+
+func (c *Cleaner) PopOneSince(now time.Time) (rst string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if len(c.heap) == 0 {
+		return
+	}
+	if now.After(c.deadlines[c.heap[0]]) {
+		return heap.Pop(c).(string)
+	}
+	return
+}
diff --git a/vendor/github.com/status-im/rendezvous/server/server.go b/vendor/github.com/status-im/rendezvous/server/server.go
new file mode 100644
index 000000000..e3213ed22
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/server/server.go
@@ -0,0 +1,223 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+	libp2p "github.com/libp2p/go-libp2p"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	host "github.com/libp2p/go-libp2p-host"
+	net "github.com/libp2p/go-libp2p-net"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/status-im/rendezvous/protocol"
+)
+
+var logger = log.New("package", "rendezvous/server")
+
+const (
+	longestTTL          = 20 * time.Second
+	cleanerPeriod       = 2 * time.Second
+	maxLimit       uint = 10
+	maxTopicLength      = 50
+)
+
+// NewServer creates instance of the server.
+func NewServer(laddr ma.Multiaddr, identity crypto.PrivKey, s Storage) *Server {
+	srv := Server{
+		laddr:         laddr,
+		identity:      identity,
+		storage:       s,
+		cleaner:       NewCleaner(),
+		writeTimeout:  10 * time.Second,
+		readTimeout:   10 * time.Second,
+		cleanerPeriod: cleanerPeriod,
+	}
+	return &srv
+}
+
+// Server provides rendezbous service over libp2p stream.
+type Server struct {
+	laddr    ma.Multiaddr
+	identity crypto.PrivKey
+
+	writeTimeout time.Duration
+	readTimeout  time.Duration
+
+	storage       Storage
+	cleaner       *Cleaner
+	cleanerPeriod time.Duration
+
+	h    host.Host
+	addr ma.Multiaddr
+
+	wg   sync.WaitGroup
+	quit chan struct{}
+}
+
+// Addr returns full server multiaddr (identity included).
+func (srv *Server) Addr() ma.Multiaddr {
+	return srv.addr
+}
+
+// Start creates listener.
+func (srv *Server) Start() error {
+	if err := srv.startListener(); err != nil {
+		return err
+	}
+	if err := srv.startCleaner(); err != nil {
+		return err
+	}
+	// once server is restarted all cleaner info is lost. so we need to rebuild it
+	return srv.storage.IterateAllKeys(func(key RecordsKey, ttl time.Time) error {
+		srv.cleaner.Add(ttl, key.String())
+		return nil
+	})
+}
+
+func (srv *Server) startCleaner() error {
+	srv.quit = make(chan struct{})
+	srv.wg.Add(1)
+	go func() {
+		for {
+			select {
+			case <-time.After(srv.cleanerPeriod):
+				srv.purgeOutdated()
+			case <-srv.quit:
+				srv.wg.Done()
+				return
+			}
+		}
+	}()
+	return nil
+}
+
+func (srv *Server) startListener() error {
+	opts := []libp2p.Option{
+		libp2p.ListenAddrStrings(srv.laddr.String()),
+		libp2p.Identity(srv.identity),
+	}
+	h, err := libp2p.New(context.Background(), opts...)
+	if err != nil {
+		return err
+	}
+	srv.h = h
+	srv.h.SetStreamHandler(protocol.VERSION, func(s net.Stream) {
+		defer s.Close()
+		rs := rlp.NewStream(s, 0)
+		s.SetReadDeadline(time.Now().Add(srv.readTimeout))
+		typ, err := rs.Uint()
+		if err != nil {
+			logger.Error("error reading message type", "error", err)
+			return
+		}
+		s.SetReadDeadline(time.Now().Add(srv.readTimeout))
+		resptype, resp, err := srv.msgParser(protocol.MessageType(typ), rs)
+		if err != nil {
+			logger.Error("error parsing message", "error", err)
+			return
+		}
+		s.SetWriteDeadline(time.Now().Add(srv.writeTimeout))
+		if err = rlp.Encode(s, resptype); err != nil {
+			logger.Error("error writing response", "type", resptype, "error", err)
+			return
+		}
+		s.SetWriteDeadline(time.Now().Add(srv.writeTimeout))
+		if err = rlp.Encode(s, resp); err != nil {
+			logger.Error("error encoding response", "resp", resp, "error", err)
+		}
+	})
+	addr, err := ma.NewMultiaddr(fmt.Sprintf("/ethv4/%s", h.ID().Pretty()))
+	if err != nil {
+		return err
+	}
+	srv.addr = srv.laddr.Encapsulate(addr)
+	logger.Info("server started", "address", srv.laddr.Encapsulate(addr))
+	return nil
+}
+
+// Stop closes listener and waits till all helper goroutines are stopped.
+func (srv *Server) Stop() {
+	if srv.quit == nil {
+		return
+	}
+	select {
+	case <-srv.quit:
+		return
+	default:
+	}
+	close(srv.quit)
+	srv.wg.Wait()
+	if srv.h != nil {
+		srv.h.Close()
+	}
+}
+
+func (srv *Server) purgeOutdated() {
+	key := srv.cleaner.PopOneSince(time.Now())
+	if len(key) == 0 {
+		return
+	}
+	if err := srv.storage.RemoveByKey(key); err != nil {
+		logger.Error("error removing key from storage", "key", key, "error", err)
+	}
+}
+
+// Decoder is a decoder!
+type Decoder interface {
+	Decode(val interface{}) error
+}
+
+func (srv *Server) msgParser(typ protocol.MessageType, d Decoder) (resptype protocol.MessageType, resp interface{}, err error) {
+	switch typ {
+	case protocol.REGISTER:
+		var msg protocol.Register
+		resptype = protocol.REGISTER_RESPONSE
+		if err = d.Decode(&msg); err != nil {
+			return resptype, protocol.RegisterResponse{Status: protocol.E_INVALID_CONTENT}, nil
+		}
+		resp, err = srv.register(msg)
+		return resptype, resp, err
+	case protocol.DISCOVER:
+		var msg protocol.Discover
+		resptype = protocol.DISCOVER_RESPONSE
+		if err = d.Decode(&msg); err != nil {
+			return resptype, protocol.DiscoverResponse{Status: protocol.E_INVALID_CONTENT}, nil
+		}
+		limit := msg.Limit
+		if msg.Limit > maxLimit {
+			limit = maxLimit
+		}
+		records, err := srv.storage.GetRandom(msg.Topic, limit)
+		if err != nil {
+			return resptype, protocol.DiscoverResponse{Status: protocol.E_INTERNAL_ERROR}, err
+		}
+		return resptype, protocol.DiscoverResponse{Status: protocol.OK, Records: records}, nil
+	default:
+		// don't send the response
+		return 0, nil, errors.New("unknown request type")
+	}
+}
+
+func (srv *Server) register(msg protocol.Register) (protocol.RegisterResponse, error) {
+	if len(msg.Topic) == 0 || len(msg.Topic) > maxTopicLength {
+		return protocol.RegisterResponse{Status: protocol.E_INVALID_NAMESPACE}, nil
+	}
+	if time.Duration(msg.TTL) > longestTTL {
+		return protocol.RegisterResponse{Status: protocol.E_INVALID_TTL}, nil
+	}
+	if !msg.Record.Signed() {
+		return protocol.RegisterResponse{Status: protocol.E_INVALID_ENR}, nil
+	}
+	ttl := time.Now().Add(time.Duration(msg.TTL))
+	key, err := srv.storage.Add(msg.Topic, msg.Record, ttl)
+	if err != nil {
+		return protocol.RegisterResponse{Status: protocol.E_INTERNAL_ERROR}, err
+	}
+	srv.cleaner.Add(ttl, key)
+	return protocol.RegisterResponse{Status: protocol.OK}, nil
+}
diff --git a/vendor/github.com/status-im/rendezvous/server/storage.go b/vendor/github.com/status-im/rendezvous/server/storage.go
new file mode 100644
index 000000000..ea3f30ce4
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/server/storage.go
@@ -0,0 +1,118 @@
+package server
+
+import (
+	"bytes"
+	"crypto/rand"
+	"time"
+
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+const (
+	RecordsPrefix byte = 1 + iota
+)
+
+type StorageRecord struct {
+	ENR  enr.Record
+	Time time.Time
+}
+
+type RecordsKey []byte
+
+func NewRecordsKey(topic string, record enr.Record) RecordsKey {
+	key := make(RecordsKey, 1+len([]byte(topic))+len(record.NodeAddr()))
+	key[0] = RecordsPrefix
+	copy(key[1:], []byte(topic))
+	copy(key[1+len([]byte(topic)):], record.NodeAddr())
+	return key
+}
+
+func (k RecordsKey) SamePrefix(prefix []byte) bool {
+	return bytes.Equal(k[:len(prefix)], prefix)
+}
+
+func (k RecordsKey) String() string {
+	return string(k)
+}
+
+// NewStorage creates instance of the storage.
+func NewStorage(db *leveldb.DB) Storage {
+	return Storage{db: db}
+}
+
+// Storage manages records.
+type Storage struct {
+	db *leveldb.DB
+}
+
+// Add stores record using specified topic.
+func (s Storage) Add(topic string, record enr.Record, t time.Time) (string, error) {
+	key := NewRecordsKey(topic, record)
+	stored := StorageRecord{
+		ENR:  record,
+		Time: t,
+	}
+	data, err := rlp.EncodeToBytes(stored)
+	if err != nil {
+		return "", err
+	}
+	return key.String(), s.db.Put(key, data, nil)
+}
+
+// RemoveBykey removes record from storage.
+func (s *Storage) RemoveByKey(key string) error {
+	return s.db.Delete([]byte(key), nil)
+}
+
+func (s *Storage) IterateAllKeys(iterator func(key RecordsKey, ttl time.Time) error) error {
+	iter := s.db.NewIterator(util.BytesPrefix([]byte{RecordsPrefix}), nil)
+	defer iter.Release()
+	for iter.Next() {
+		var stored StorageRecord
+		if err := rlp.DecodeBytes(iter.Value(), &stored); err != nil {
+			return err
+		}
+		if err := iterator(RecordsKey(iter.Key()), stored.Time); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetRandom reads random records for specified topic up to specified limit.
+func (s *Storage) GetRandom(topic string, limit uint) (rst []enr.Record, err error) {
+	prefixlen := 1 + len([]byte(topic))
+	key := make(RecordsKey, prefixlen+32)
+	key[0] = RecordsPrefix
+	copy(key[1:], []byte(topic))
+
+	iter := s.db.NewIterator(util.BytesPrefix(key[:prefixlen]), nil)
+	defer iter.Release()
+	uids := map[string]struct{}{}
+	// it might be too much cause we do crypto/rand.Read. requires profiling
+	for i := uint(0); i < limit*limit && len(rst) < int(limit); i++ {
+		if _, err := rand.Read(key[prefixlen:]); err != nil {
+			return nil, err
+		}
+		iter.Seek(key)
+		for _, f := range []func() bool{iter.Prev, iter.Next} {
+			if f() && key.SamePrefix(iter.Key()[:prefixlen]) {
+				var stored StorageRecord
+				if err = rlp.DecodeBytes(iter.Value(), &stored); err != nil {
+					return nil, err
+				}
+				k := iter.Key()
+				if _, exist := uids[string(k)]; exist {
+					continue
+				}
+				uids[string(k)] = struct{}{}
+				rst = append(rst, stored.ENR)
+				break
+			}
+		}
+	}
+	return rst, nil
+}
diff --git a/vendor/github.com/status-im/rendezvous/stream.go b/vendor/github.com/status-im/rendezvous/stream.go
new file mode 100644
index 000000000..a14bed55e
--- /dev/null
+++ b/vendor/github.com/status-im/rendezvous/stream.go
@@ -0,0 +1,32 @@
+package rendezvous
+
+import (
+	"github.com/ethereum/go-ethereum/metrics"
+	inet "github.com/libp2p/go-libp2p-net"
+)
+
+var (
+	ingressTrafficMeter = metrics.NewRegisteredMeter("rendezvous/InboundTraffic", nil)
+	egressTrafficMeter  = metrics.NewRegisteredMeter("rendezvous/OutboundTraffic", nil)
+)
+
+// InstrumenetedStream implements read writer interface and collects metrics.
+type InstrumenetedStream struct {
+	s inet.Stream
+}
+
+func (si InstrumenetedStream) Write(p []byte) (int, error) {
+	n, err := si.s.Write(p)
+	egressTrafficMeter.Mark(int64(n))
+	return n, err
+}
+
+func (si InstrumenetedStream) Read(p []byte) (int, error) {
+	n, err := si.s.Read(p)
+	ingressTrafficMeter.Mark(int64(n))
+	return n, err
+}
+
+func (si InstrumenetedStream) Close() error {
+	return si.s.Close()
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/CONTRIBUTORS b/vendor/github.com/whyrusleeping/go-logging/CONTRIBUTORS
new file mode 100644
index 000000000..958416ef1
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/CONTRIBUTORS
@@ -0,0 +1,5 @@
+Alec Thomas <alec@swapoff.org>
+Guilhem Lettron <guilhem.lettron@optiflows.com>
+Ivan Daniluk <ivan.daniluk@gmail.com>
+Nimi Wariboko Jr <nimi@channelmeter.com>
+Róbert Selvek <robert.selvek@gmail.com>
diff --git a/vendor/github.com/whyrusleeping/go-logging/LICENSE b/vendor/github.com/whyrusleeping/go-logging/LICENSE
new file mode 100644
index 000000000..f1f6cfcef
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2013 Örjan Persson. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/whyrusleeping/go-logging/backend.go b/vendor/github.com/whyrusleeping/go-logging/backend.go
new file mode 100644
index 000000000..6cd589cab
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/backend.go
@@ -0,0 +1,39 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+// defaultBackend is the backend used for all logging calls.
+var defaultBackend LeveledBackend
+
+// Backend is the interface which a log backend need to implement to be able to
+// be used as a logging backend.
+type Backend interface {
+	Log(Level, int, *Record) error
+}
+
+// Set backend replaces the backend currently set with the given new logging
+// backend.
+func SetBackend(backends ...Backend) LeveledBackend {
+	var backend Backend
+	if len(backends) == 1 {
+		backend = backends[0]
+	} else {
+		backend = MultiLogger(backends...)
+	}
+
+	defaultBackend = AddModuleLevel(backend)
+	return defaultBackend
+}
+
+// SetLevel sets the logging level for the specified module. The module
+// corresponds to the string specified in GetLogger.
+func SetLevel(level Level, module string) {
+	defaultBackend.SetLevel(level, module)
+}
+
+// GetLevel returns the logging level for the specified module.
+func GetLevel(module string) Level {
+	return defaultBackend.GetLevel(module)
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/format.go b/vendor/github.com/whyrusleeping/go-logging/format.go
new file mode 100644
index 000000000..99b1ddb72
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/format.go
@@ -0,0 +1,368 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+// TODO see Formatter interface in fmt/print.go
+// TODO try text/template, maybe it have enough performance
+// TODO other template systems?
+// TODO make it possible to specify formats per backend?
+type fmtVerb int
+
+const (
+	fmtVerbTime fmtVerb = iota
+	fmtVerbLevel
+	fmtVerbId
+	fmtVerbPid
+	fmtVerbProgram
+	fmtVerbModule
+	fmtVerbMessage
+	fmtVerbLongfile
+	fmtVerbShortfile
+	fmtVerbLongpkg
+	fmtVerbShortpkg
+	fmtVerbLongfunc
+	fmtVerbShortfunc
+	fmtVerbLevelColor
+
+	// Keep last, there are no match for these below.
+	fmtVerbUnknown
+	fmtVerbStatic
+)
+
+var fmtVerbs = []string{
+	"time",
+	"level",
+	"id",
+	"pid",
+	"program",
+	"module",
+	"message",
+	"longfile",
+	"shortfile",
+	"longpkg",
+	"shortpkg",
+	"longfunc",
+	"shortfunc",
+	"color",
+}
+
+const rfc3339Milli = "2006-01-02T15:04:05.999Z07:00"
+
+var defaultVerbsLayout = []string{
+	rfc3339Milli,
+	"s",
+	"d",
+	"d",
+	"s",
+	"s",
+	"s",
+	"s",
+	"s",
+	"s",
+	"s",
+	"s",
+	"s",
+	"",
+}
+
+var (
+	pid     = os.Getpid()
+	program = filepath.Base(os.Args[0])
+)
+
+func getFmtVerbByName(name string) fmtVerb {
+	for i, verb := range fmtVerbs {
+		if name == verb {
+			return fmtVerb(i)
+		}
+	}
+	return fmtVerbUnknown
+}
+
+// Formatter is the required interface for a custom log record formatter.
+type Formatter interface {
+	Format(calldepth int, r *Record, w io.Writer) error
+}
+
+// formatter is used by all backends unless otherwise overriden.
+var formatter struct {
+	sync.RWMutex
+	def Formatter
+}
+
+func getFormatter() Formatter {
+	formatter.RLock()
+	defer formatter.RUnlock()
+	return formatter.def
+}
+
+var (
+	// DefaultFormatter is the default formatter used and is only the message.
+	DefaultFormatter Formatter = MustStringFormatter("%{message}")
+
+	// Glog format
+	GlogFormatter Formatter = MustStringFormatter("%{level:.1s}%{time:0102 15:04:05.999999} %{pid} %{shortfile}] %{message}")
+)
+
+// SetFormatter sets the default formatter for all new backends. A backend will
+// fetch this value once it is needed to format a record. Note that backends
+// will cache the formatter after the first point. For now, make sure to set
+// the formatter before logging.
+func SetFormatter(f Formatter) {
+	formatter.Lock()
+	defer formatter.Unlock()
+	formatter.def = f
+}
+
+var formatRe *regexp.Regexp = regexp.MustCompile(`%{([a-z]+)(?::(.*?[^\\]))?}`)
+
+type part struct {
+	verb   fmtVerb
+	layout string
+}
+
+// stringFormatter contains a list of parts which explains how to build the
+// formatted string passed on to the logging backend.
+type stringFormatter struct {
+	parts []part
+}
+
+// NewStringFormatter returns a new Formatter which outputs the log record as a
+// string based on the 'verbs' specified in the format string.
+//
+// The verbs:
+//
+// General:
+//     %{id}        Sequence number for log message (uint64).
+//     %{pid}       Process id (int)
+//     %{time}      Time when log occurred (time.Time)
+//     %{level}     Log level (Level)
+//     %{module}    Module (string)
+//     %{program}   Basename of os.Args[0] (string)
+//     %{message}   Message (string)
+//     %{longfile}  Full file name and line number: /a/b/c/d.go:23
+//     %{shortfile} Final file name element and line number: d.go:23
+//     %{color}     ANSI color based on log level
+//
+// For normal types, the output can be customized by using the 'verbs' defined
+// in the fmt package, eg. '%{id:04d}' to make the id output be '%04d' as the
+// format string.
+//
+// For time.Time, use the same layout as time.Format to change the time format
+// when output, eg "2006-01-02T15:04:05.999Z-07:00".
+//
+// For the 'color' verb, the output can be adjusted to either use bold colors,
+// i.e., '%{color:bold}' or to reset the ANSI attributes, i.e.,
+// '%{color:reset}' Note that if you use the color verb explicitly, be sure to
+// reset it or else the color state will persist past your log message.  e.g.,
+// "%{color:bold}%{time:15:04:05} %{level:-8s}%{color:reset} %{message}" will
+// just colorize the time and level, leaving the message uncolored.
+//
+// There's also a couple of experimental 'verbs'. These are exposed to get
+// feedback and needs a bit of tinkering. Hence, they might change in the
+// future.
+//
+// Experimental:
+//     %{longpkg}   Full package path, eg. github.com/go-logging
+//     %{shortpkg}  Base package path, eg. go-logging
+//     %{longfunc}  Full function name, eg. littleEndian.PutUint32
+//     %{shortfunc} Base function name, eg. PutUint32
+func NewStringFormatter(format string) (*stringFormatter, error) {
+	var fmter = &stringFormatter{}
+
+	// Find the boundaries of all %{vars}
+	matches := formatRe.FindAllStringSubmatchIndex(format, -1)
+	if matches == nil {
+		return nil, errors.New("logger: invalid log format: " + format)
+	}
+
+	// Collect all variables and static text for the format
+	prev := 0
+	for _, m := range matches {
+		start, end := m[0], m[1]
+		if start > prev {
+			fmter.add(fmtVerbStatic, format[prev:start])
+		}
+
+		name := format[m[2]:m[3]]
+		verb := getFmtVerbByName(name)
+		if verb == fmtVerbUnknown {
+			return nil, errors.New("logger: unknown variable: " + name)
+		}
+
+		// Handle layout customizations or use the default. If this is not for the
+		// time or color formatting, we need to prefix with %.
+		layout := defaultVerbsLayout[verb]
+		if m[4] != -1 {
+			layout = format[m[4]:m[5]]
+		}
+		if verb != fmtVerbTime && verb != fmtVerbLevelColor {
+			layout = "%" + layout
+		}
+
+		fmter.add(verb, layout)
+		prev = end
+	}
+	end := format[prev:]
+	if end != "" {
+		fmter.add(fmtVerbStatic, end)
+	}
+
+	// Make a test run to make sure we can format it correctly.
+	t, err := time.Parse(time.RFC3339, "2010-02-04T21:00:57-08:00")
+	if err != nil {
+		panic(err)
+	}
+	r := &Record{
+		Id:     12345,
+		Time:   t,
+		Module: "logger",
+		fmt:    "hello %s",
+		args:   []interface{}{"go"},
+	}
+	if err := fmter.Format(0, r, &bytes.Buffer{}); err != nil {
+		return nil, err
+	}
+
+	return fmter, nil
+}
+
+// MustStringFormatter is equivalent to NewStringFormatter with a call to panic
+// on error.
+func MustStringFormatter(format string) *stringFormatter {
+	f, err := NewStringFormatter(format)
+	if err != nil {
+		panic("Failed to initialized string formatter: " + err.Error())
+	}
+	return f
+}
+
+func (f *stringFormatter) add(verb fmtVerb, layout string) {
+	f.parts = append(f.parts, part{verb, layout})
+}
+
+func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) error {
+	for _, part := range f.parts {
+		if part.verb == fmtVerbStatic {
+			output.Write([]byte(part.layout))
+		} else if part.verb == fmtVerbTime {
+			output.Write([]byte(r.Time.Format(part.layout)))
+		} else if part.verb == fmtVerbLevelColor {
+			if part.layout == "bold" {
+				output.Write([]byte(boldcolors[r.Level]))
+			} else if part.layout == "reset" {
+				output.Write([]byte("\033[0m"))
+			} else {
+				output.Write([]byte(colors[r.Level]))
+			}
+		} else {
+			var v interface{}
+			switch part.verb {
+			case fmtVerbLevel:
+				v = r.Level
+				break
+			case fmtVerbId:
+				v = r.Id
+				break
+			case fmtVerbPid:
+				v = pid
+				break
+			case fmtVerbProgram:
+				v = program
+				break
+			case fmtVerbModule:
+				v = r.Module
+				break
+			case fmtVerbMessage:
+				v = r.Message()
+				break
+			case fmtVerbLongfile, fmtVerbShortfile:
+				_, file, line, ok := runtime.Caller(calldepth + 1)
+				if !ok {
+					file = "???"
+					line = 0
+				} else if part.verb == fmtVerbShortfile {
+					file = filepath.Base(file)
+				}
+				v = fmt.Sprintf("%s:%d", file, line)
+			case fmtVerbLongfunc, fmtVerbShortfunc,
+				fmtVerbLongpkg, fmtVerbShortpkg:
+				// TODO cache pc
+				v = "???"
+				if pc, _, _, ok := runtime.Caller(calldepth + 1); ok {
+					if f := runtime.FuncForPC(pc); f != nil {
+						v = formatFuncName(part.verb, f.Name())
+					}
+				}
+			default:
+				panic("unhandled format part")
+			}
+			fmt.Fprintf(output, part.layout, v)
+		}
+	}
+	return nil
+}
+
+// formatFuncName tries to extract certain part of the runtime formatted
+// function name to some pre-defined variation.
+//
+// This function is known to not work properly if the package path or name
+// contains a dot.
+func formatFuncName(v fmtVerb, f string) string {
+	i := strings.LastIndex(f, "/")
+	j := strings.Index(f[i+1:], ".")
+	if j < 1 {
+		return "???"
+	}
+	pkg, fun := f[:i+j+1], f[i+j+2:]
+	switch v {
+	case fmtVerbLongpkg:
+		return pkg
+	case fmtVerbShortpkg:
+		return path.Base(pkg)
+	case fmtVerbLongfunc:
+		return fun
+	case fmtVerbShortfunc:
+		i = strings.LastIndex(fun, ".")
+		return fun[i+1:]
+	}
+	panic("unexpected func formatter")
+}
+
+// backendFormatter combines a backend with a specific formatter making it
+// possible to have different log formats for different backends.
+type backendFormatter struct {
+	b Backend
+	f Formatter
+}
+
+// NewBackendFormatter creates a new backend which makes all records that
+// passes through it beeing formatted by the specific formatter.
+func NewBackendFormatter(b Backend, f Formatter) *backendFormatter {
+	return &backendFormatter{b, f}
+}
+
+// Log implements the Log function required by the Backend interface.
+func (bf *backendFormatter) Log(level Level, calldepth int, r *Record) error {
+	// Make a shallow copy of the record and replace any formatter
+	r2 := *r
+	r2.formatter = bf.f
+	return bf.b.Log(level, calldepth+1, &r2)
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/level.go b/vendor/github.com/whyrusleeping/go-logging/level.go
new file mode 100644
index 000000000..929346438
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/level.go
@@ -0,0 +1,129 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+import (
+	"errors"
+	"strings"
+	"sync"
+)
+
+var ErrInvalidLogLevel = errors.New("logger: invalid log level")
+
+// Level defines all available log levels for log messages.
+type Level int
+
+const (
+	CRITICAL Level = iota
+	ERROR
+	WARNING
+	NOTICE
+	INFO
+	DEBUG
+)
+
+var levelNames = []string{
+	"CRITICAL",
+	"ERROR",
+	"WARNING",
+	"NOTICE",
+	"INFO",
+	"DEBUG",
+}
+
+// String returns the string representation of a logging level.
+func (p Level) String() string {
+	return levelNames[p]
+}
+
+// LogLevel returns the log level from a string representation.
+func LogLevel(level string) (Level, error) {
+	for i, name := range levelNames {
+		if strings.EqualFold(name, level) {
+			return Level(i), nil
+		}
+	}
+	return ERROR, ErrInvalidLogLevel
+}
+
+type Leveled interface {
+	GetLevel(string) Level
+	SetLevel(Level, string)
+	IsEnabledFor(Level, string) bool
+}
+
+// LeveledBackend is a log backend with additional knobs for setting levels on
+// individual modules to different levels.
+type LeveledBackend interface {
+	Backend
+	Leveled
+}
+
+type moduleLeveled struct {
+	sync.RWMutex
+	levels    map[string]Level
+	backend   Backend
+	formatter Formatter
+	once      sync.Once
+}
+
+// AddModuleLevel wraps a log backend with knobs to have different log levels
+// for different modules.
+func AddModuleLevel(backend Backend) LeveledBackend {
+	var leveled LeveledBackend
+	var ok bool
+	if leveled, ok = backend.(LeveledBackend); !ok {
+		leveled = &moduleLeveled{
+			levels:  make(map[string]Level),
+			backend: backend,
+		}
+	}
+	return leveled
+}
+
+// GetLevel returns the log level for the given module.
+func (l *moduleLeveled) GetLevel(module string) Level {
+	l.RLock()
+	defer l.RUnlock()
+	level, exists := l.levels[module]
+	if exists == false {
+		level, exists = l.levels[""]
+		// no configuration exists, default to debug
+		if exists == false {
+			level = DEBUG
+		}
+	}
+	return level
+}
+
+// SetLevel sets the log level for the given module.
+func (l *moduleLeveled) SetLevel(level Level, module string) {
+	l.Lock()
+	defer l.Unlock()
+	l.levels[module] = level
+}
+
+// IsEnabledFor will return true if logging is enabled for the given module.
+func (l *moduleLeveled) IsEnabledFor(level Level, module string) bool {
+	return level <= l.GetLevel(module)
+}
+
+func (l *moduleLeveled) Log(level Level, calldepth int, rec *Record) (err error) {
+	if l.IsEnabledFor(level, rec.Module) {
+		// TODO get rid of traces of formatter here. BackendFormatter should be used.
+		rec.formatter = l.getFormatterAndCacheCurrent()
+		err = l.backend.Log(level, calldepth+1, rec)
+	}
+	return
+}
+
+func (l *moduleLeveled) getFormatterAndCacheCurrent() Formatter {
+	l.once.Do(func() {
+		if l.formatter == nil {
+			l.formatter = getFormatter()
+		}
+	})
+	return l.formatter
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/log.go b/vendor/github.com/whyrusleeping/go-logging/log.go
new file mode 100644
index 000000000..f009f8af5
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/log.go
@@ -0,0 +1,80 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+)
+
+// TODO initialize here
+var colors []string
+var boldcolors []string
+
+type color int
+
+const (
+	colorBlack = (iota + 30)
+	colorRed
+	colorGreen
+	colorYellow
+	colorBlue
+	colorMagenta
+	colorCyan
+	colorWhite
+)
+
+// LogBackend utilizes the standard log module.
+type LogBackend struct {
+	Logger *log.Logger
+	Color  bool
+}
+
+// NewLogBackend creates a new LogBackend.
+func NewLogBackend(out io.Writer, prefix string, flag int) *LogBackend {
+	return &LogBackend{Logger: log.New(out, prefix, flag)}
+}
+
+func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error {
+	if b.Color {
+		buf := &bytes.Buffer{}
+		buf.Write([]byte(colors[level]))
+		buf.Write([]byte(rec.Formatted(calldepth + 1)))
+		buf.Write([]byte("\033[0m"))
+		// For some reason, the Go logger arbitrarily decided "2" was the correct
+		// call depth...
+		return b.Logger.Output(calldepth+2, buf.String())
+	} else {
+		return b.Logger.Output(calldepth+2, rec.Formatted(calldepth+1))
+	}
+	panic("should not be reached")
+}
+
+func colorSeq(color color) string {
+	return fmt.Sprintf("\033[%dm", int(color))
+}
+
+func colorSeqBold(color color) string {
+	return fmt.Sprintf("\033[%d;1m", int(color))
+}
+
+func init() {
+	colors = []string{
+		CRITICAL: colorSeq(colorMagenta),
+		ERROR:    colorSeq(colorRed),
+		WARNING:  colorSeq(colorYellow),
+		NOTICE:   colorSeq(colorGreen),
+		DEBUG:    colorSeq(colorCyan),
+	}
+	boldcolors = []string{
+		CRITICAL: colorSeqBold(colorMagenta),
+		ERROR:    colorSeqBold(colorRed),
+		WARNING:  colorSeqBold(colorYellow),
+		NOTICE:   colorSeqBold(colorGreen),
+		DEBUG:    colorSeqBold(colorCyan),
+	}
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/logger.go b/vendor/github.com/whyrusleeping/go-logging/logger.go
new file mode 100644
index 000000000..42b494955
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/logger.go
@@ -0,0 +1,279 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package logging implements a logging infrastructure for Go. It supports
+// different logging backends like syslog, file and memory. Multiple backends
+// can be utilized with different log levels per backend and logger.
+package logging
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+// Redactor is an interface for types that may contain sensitive information
+// (like passwords), which shouldn't be printed to the log. The idea was found
+// in relog as part of the vitness project.
+type Redactor interface {
+	Redacted() interface{}
+}
+
+// Redact returns a string of * having the same length as s.
+func Redact(s string) string {
+	return strings.Repeat("*", len(s))
+}
+
+var (
+	// Sequence number is incremented and utilized for all log records created.
+	sequenceNo uint64
+
+	// timeNow is a customizable for testing purposes.
+	timeNow = time.Now
+)
+
+// Record represents a log record and contains the timestamp when the record
+// was created, an increasing id, filename and line and finally the actual
+// formatted log line.
+type Record struct {
+	Id     uint64
+	Time   time.Time
+	Module string
+	Level  Level
+
+	// message is kept as a pointer to have shallow copies update this once
+	// needed.
+	message   *string
+	args      []interface{}
+	fmt       string
+	formatter Formatter
+	formatted string
+}
+
+// Formatted returns the string-formatted version of a record.
+func (r *Record) Formatted(calldepth int) string {
+	if r.formatted == "" {
+		var buf bytes.Buffer
+		r.formatter.Format(calldepth+1, r, &buf)
+		r.formatted = buf.String()
+	}
+	return r.formatted
+}
+
+// Message returns a string message for outputting. Redacts any record args
+// that implement the Redactor interface
+func (r *Record) Message() string {
+	if r.message == nil {
+		// Redact the arguments that implements the Redactor interface
+		for i, arg := range r.args {
+			if redactor, ok := arg.(Redactor); ok == true {
+				r.args[i] = redactor.Redacted()
+			}
+		}
+		msg := fmt.Sprintf(r.fmt, r.args...)
+		r.message = &msg
+	}
+	return *r.message
+}
+
+// Logger is a logging unit. It controls the flow of messages to a given
+// (swappable) backend.
+type Logger struct {
+	Module      string
+	backend     LeveledBackend
+	haveBackend bool
+
+	// ExtraCallDepth can be used to add additional call depth when getting the
+	// calling function. This is normally used when wrapping a logger.
+	ExtraCalldepth int
+}
+
+// SetBackend changes the backend of the logger.
+func (l *Logger) SetBackend(backend LeveledBackend) {
+	l.backend = backend
+	l.haveBackend = true
+}
+
+// GetLogger creates and returns a Logger object based on the module name.
+// TODO call NewLogger and remove MustGetLogger?
+func GetLogger(module string) (*Logger, error) {
+	return &Logger{Module: module}, nil
+}
+
+// MustGetLogger is like GetLogger but panics if the logger can't be created.
+// It simplifies safe initialization of a global logger for eg. a package.
+func MustGetLogger(module string) *Logger {
+	logger, err := GetLogger(module)
+	if err != nil {
+		panic("logger: " + module + ": " + err.Error())
+	}
+	return logger
+}
+
+// Reset restores the internal state of the logging library.
+func Reset() {
+	// TODO make a global Init() method to be less magic? or make it such that
+	// if there's no backends at all configured, we could use some tricks to
+	// automatically setup backends based if we have a TTY or not.
+	sequenceNo = 0
+	b := SetBackend(NewLogBackend(os.Stderr, "", log.LstdFlags))
+	b.SetLevel(DEBUG, "")
+	SetFormatter(DefaultFormatter)
+	timeNow = time.Now
+}
+
+// InitForTesting is a convenient method when using logging in a test. Once
+// called, the time will be frozen to January 1, 1970 UTC.
+func InitForTesting(level Level) *MemoryBackend {
+	Reset()
+
+	memoryBackend := NewMemoryBackend(10240)
+
+	leveledBackend := AddModuleLevel(memoryBackend)
+	leveledBackend.SetLevel(level, "")
+	SetBackend(leveledBackend)
+
+	timeNow = func() time.Time {
+		return time.Unix(0, 0).UTC()
+	}
+	return memoryBackend
+}
+
+// IsEnabledFor returns true if the logger is enabled for the given level.
+func (l *Logger) IsEnabledFor(level Level) bool {
+	return defaultBackend.IsEnabledFor(level, l.Module)
+}
+
+func (l *Logger) log(lvl Level, format string, args ...interface{}) {
+	if !l.IsEnabledFor(lvl) {
+		return
+	}
+
+	// Create the logging record and pass it in to the backend
+	record := &Record{
+		Id:     atomic.AddUint64(&sequenceNo, 1),
+		Time:   timeNow(),
+		Module: l.Module,
+		Level:  lvl,
+		fmt:    format,
+		args:   args,
+	}
+
+	// TODO use channels to fan out the records to all backends?
+	// TODO in case of errors, do something (tricky)
+
+	// calldepth=2 brings the stack up to the caller of the level
+	// methods, Info(), Fatal(), etc.
+	// ExtraCallDepth allows this to be extended further up the stack in case we
+	// are wrapping these methods, eg. to expose them package level
+	if l.haveBackend {
+		l.backend.Log(lvl, 2+l.ExtraCalldepth, record)
+		return
+	}
+
+	defaultBackend.Log(lvl, 2+l.ExtraCalldepth, record)
+}
+
+// Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1).
+func (l *Logger) Fatal(args ...interface{}) {
+	s := fmt.Sprint(args...)
+	l.log(CRITICAL, "%s", s)
+	os.Exit(1)
+}
+
+// Fatalf is equivalent to l.Critical followed by a call to os.Exit(1).
+func (l *Logger) Fatalf(format string, args ...interface{}) {
+	l.log(CRITICAL, format, args...)
+	os.Exit(1)
+}
+
+// Panic is equivalent to l.Critical(fmt.Sprint()) followed by a call to panic().
+func (l *Logger) Panic(args ...interface{}) {
+	s := fmt.Sprint(args...)
+	l.log(CRITICAL, "%s", s)
+	panic(s)
+}
+
+// Panicf is equivalent to l.Critical followed by a call to panic().
+func (l *Logger) Panicf(format string, args ...interface{}) {
+	s := fmt.Sprintf(format, args...)
+	l.log(CRITICAL, "%s", s)
+	panic(s)
+}
+
+// Critical logs a message using CRITICAL as log level. (fmt.Sprint())
+func (l *Logger) Critical(args ...interface{}) {
+	l.log(CRITICAL, defaultArgsFormat(len(args)), args...)
+}
+
+// Criticalf logs a message using CRITICAL as log level.
+func (l *Logger) Criticalf(format string, args ...interface{}) {
+	l.log(CRITICAL, format, args...)
+}
+
+// Error logs a message using ERROR as log level. (fmt.Sprint())
+func (l *Logger) Error(args ...interface{}) {
+	l.log(ERROR, defaultArgsFormat(len(args)), args...)
+}
+
+// Errorf logs a message using ERROR as log level.
+func (l *Logger) Errorf(format string, args ...interface{}) {
+	l.log(ERROR, format, args...)
+}
+
+// Warning logs a message using WARNING as log level.
+func (l *Logger) Warning(args ...interface{}) {
+	l.log(WARNING, defaultArgsFormat(len(args)), args...)
+}
+
+// Warningf logs a message using WARNING as log level.
+func (l *Logger) Warningf(format string, args ...interface{}) {
+	l.log(WARNING, format, args...)
+}
+
+// Notice logs a message using NOTICE as log level.
+func (l *Logger) Notice(args ...interface{}) {
+	l.log(NOTICE, defaultArgsFormat(len(args)), args...)
+}
+
+// Noticef logs a message using NOTICE as log level.
+func (l *Logger) Noticef(format string, args ...interface{}) {
+	l.log(NOTICE, format, args...)
+}
+
+// Info logs a message using INFO as log level.
+func (l *Logger) Info(args ...interface{}) {
+	l.log(INFO, defaultArgsFormat(len(args)), args...)
+}
+
+// Infof logs a message using INFO as log level.
+func (l *Logger) Infof(format string, args ...interface{}) {
+	l.log(INFO, format, args...)
+}
+
+// Debug logs a message using DEBUG as log level.
+func (l *Logger) Debug(args ...interface{}) {
+	l.log(DEBUG, defaultArgsFormat(len(args)), args...)
+}
+
+// Debugf logs a message using DEBUG as log level.
+func (l *Logger) Debugf(format string, args ...interface{}) {
+	l.log(DEBUG, format, args...)
+}
+
+func defaultArgsFormat(argc int) string {
+	f := strings.Repeat("%s ", argc)
+	if argc > 0 {
+		f = f[:len(f) - 1]
+	}
+	return f
+}
+
+func init() {
+	Reset()
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/memory.go b/vendor/github.com/whyrusleeping/go-logging/memory.go
new file mode 100644
index 000000000..c59b92dde
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/memory.go
@@ -0,0 +1,217 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+import (
+	"sync"
+	"sync/atomic"
+	"unsafe"
+)
+
+// TODO pick one of the memory backends and stick with it or share interface.
+
+// Node is a record node pointing to an optional next node.
+type node struct {
+	next   *node
+	Record *Record
+}
+
+// Next returns the next record node. If there's no node available, it will
+// return nil.
+func (n *node) Next() *node {
+	return n.next
+}
+
+// MemoryBackend is a simple memory based logging backend that will not produce
+// any output but merly keep records, up to the given size, in memory.
+type MemoryBackend struct {
+	size       int32
+	maxSize    int32
+	head, tail unsafe.Pointer
+}
+
+// NewMemoryBackend creates a simple in-memory logging backend.
+func NewMemoryBackend(size int) *MemoryBackend {
+	return &MemoryBackend{maxSize: int32(size)}
+}
+
+// Log implements the Log method required by Backend.
+func (b *MemoryBackend) Log(level Level, calldepth int, rec *Record) error {
+	var size int32
+
+	n := &node{Record: rec}
+	np := unsafe.Pointer(n)
+
+	// Add the record to the tail. If there's no records available, tail and
+	// head will both be nil. When we successfully set the tail and the previous
+	// value was nil, it's safe to set the head to the current value too.
+	for {
+		tailp := b.tail
+		swapped := atomic.CompareAndSwapPointer(
+			&b.tail,
+			tailp,
+			np,
+		)
+		if swapped == true {
+			if tailp == nil {
+				b.head = np
+			} else {
+				(*node)(tailp).next = n
+			}
+			size = atomic.AddInt32(&b.size, 1)
+			break
+		}
+	}
+
+	// Since one record was added, we might have overflowed the list. Remove
+	// a record if that is the case. The size will fluctate a bit, but
+	// eventual consistent.
+	if b.maxSize > 0 && size > b.maxSize {
+		for {
+			headp := b.head
+			head := (*node)(b.head)
+			if head.next == nil {
+				break
+			}
+			swapped := atomic.CompareAndSwapPointer(
+				&b.head,
+				headp,
+				unsafe.Pointer(head.next),
+			)
+			if swapped == true {
+				atomic.AddInt32(&b.size, -1)
+				break
+			}
+		}
+	}
+	return nil
+}
+
+// Head returns the oldest record node kept in memory. It can be used to
+// iterate over records, one by one, up to the last record.
+//
+// Note: new records can get added while iterating. Hence the number of records
+// iterated over might be larger than the maximum size.
+func (b *MemoryBackend) Head() *node {
+	return (*node)(b.head)
+}
+
+type event int
+
+const (
+	eventFlush event = iota
+	eventStop
+)
+
+// ChannelMemoryBackend is very similar to the MemoryBackend, except that it
+// internally utilizes a channel.
+type ChannelMemoryBackend struct {
+	maxSize    int
+	size       int
+	incoming   chan *Record
+	events     chan event
+	mu         sync.Mutex
+	running    bool
+	flushWg    sync.WaitGroup
+	stopWg     sync.WaitGroup
+	head, tail *node
+}
+
+// NewChannelMemoryBackend creates a simple in-memory logging backend which
+// utilizes a go channel for communication.
+//
+// Start will automatically be called by this function.
+func NewChannelMemoryBackend(size int) *ChannelMemoryBackend {
+	backend := &ChannelMemoryBackend{
+		maxSize:  size,
+		incoming: make(chan *Record, 1024),
+		events:   make(chan event),
+	}
+	backend.Start()
+	return backend
+}
+
+// Start launches the internal goroutine which starts processing data from the
+// input channel.
+func (b *ChannelMemoryBackend) Start() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	// Launch the goroutine unless it's already running.
+	if b.running != true {
+		b.running = true
+		b.stopWg.Add(1)
+		go b.process()
+	}
+}
+
+func (b *ChannelMemoryBackend) process() {
+	defer b.stopWg.Done()
+	for {
+		select {
+		case rec := <-b.incoming:
+			b.insertRecord(rec)
+		case e := <-b.events:
+			switch e {
+			case eventStop:
+				return
+			case eventFlush:
+				for len(b.incoming) > 0 {
+					b.insertRecord(<-b.incoming)
+				}
+				b.flushWg.Done()
+			}
+		}
+	}
+}
+
+func (b *ChannelMemoryBackend) insertRecord(rec *Record) {
+	prev := b.tail
+	b.tail = &node{Record: rec}
+	if prev == nil {
+		b.head = b.tail
+	} else {
+		prev.next = b.tail
+	}
+
+	if b.maxSize > 0 && b.size >= b.maxSize {
+		b.head = b.head.next
+	} else {
+		b.size += 1
+	}
+}
+
+// Flush waits until all records in the buffered channel have been processed.
+func (b *ChannelMemoryBackend) Flush() {
+	b.flushWg.Add(1)
+	b.events <- eventFlush
+	b.flushWg.Wait()
+}
+
+// Stop signals the internal goroutine to exit and waits until it have.
+func (b *ChannelMemoryBackend) Stop() {
+	b.mu.Lock()
+	if b.running == true {
+		b.running = false
+		b.events <- eventStop
+	}
+	b.mu.Unlock()
+	b.stopWg.Wait()
+}
+
+// Log implements the Log method required by Backend.
+func (b *ChannelMemoryBackend) Log(level Level, calldepth int, rec *Record) error {
+	b.incoming <- rec
+	return nil
+}
+
+// Head returns the oldest record node kept in memory. It can be used to
+// iterate over records, one by one, up to the last record.
+//
+// Note: new records can get added while iterating. Hence the number of records
+// iterated over might be larger than the maximum size.
+func (b *ChannelMemoryBackend) Head() *node {
+	return b.head
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/multi.go b/vendor/github.com/whyrusleeping/go-logging/multi.go
new file mode 100644
index 000000000..3731653e6
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/multi.go
@@ -0,0 +1,65 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+// TODO remove Level stuff from the multi logger. Do one thing.
+
+// multiLogger is a log multiplexer which can be used to utilize multiple log
+// backends at once.
+type multiLogger struct {
+	backends []LeveledBackend
+}
+
+// MultiLogger creates a logger which contain multiple loggers.
+func MultiLogger(backends ...Backend) LeveledBackend {
+	var leveledBackends []LeveledBackend
+	for _, backend := range backends {
+		leveledBackends = append(leveledBackends, AddModuleLevel(backend))
+	}
+	return &multiLogger{leveledBackends}
+}
+
+// Log passes the log record to all backends.
+func (b *multiLogger) Log(level Level, calldepth int, rec *Record) (err error) {
+	for _, backend := range b.backends {
+		if backend.IsEnabledFor(level, rec.Module) {
+			// Shallow copy of the record for the formatted cache on Record and get the
+			// record formatter from the backend.
+			r2 := *rec
+			if e := backend.Log(level, calldepth+1, &r2); e != nil {
+				err = e
+			}
+		}
+	}
+	return
+}
+
+// GetLevel returns the highest level enabled by all backends.
+func (b *multiLogger) GetLevel(module string) Level {
+	var level Level
+	for _, backend := range b.backends {
+		if backendLevel := backend.GetLevel(module); backendLevel > level {
+			level = backendLevel
+		}
+	}
+	return level
+}
+
+// SetLevel propagates the same level to all backends.
+func (b *multiLogger) SetLevel(level Level, module string) {
+	for _, backend := range b.backends {
+		backend.SetLevel(level, module)
+	}
+}
+
+// IsEnabledFor returns true if any of the backends are enabled for it.
+func (b *multiLogger) IsEnabledFor(level Level, module string) bool {
+	for _, backend := range b.backends {
+		if backend.IsEnabledFor(level, module) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/github.com/whyrusleeping/go-logging/syslog.go b/vendor/github.com/whyrusleeping/go-logging/syslog.go
new file mode 100644
index 000000000..9a5c8f5d3
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-logging/syslog.go
@@ -0,0 +1,52 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//+build !windows,!plan9
+
+package logging
+
+import "log/syslog"
+
+// SyslogBackend is a simple logger to syslog backend. It automatically maps
+// the internal log levels to appropriate syslog log levels.
+type SyslogBackend struct {
+	Writer *syslog.Writer
+}
+
+// NewSyslogBackend connects to the syslog daemon using UNIX sockets with the
+// given prefix. If prefix is not given, the prefix will be derived from the
+// launched command.
+func NewSyslogBackend(prefix string) (b *SyslogBackend, err error) {
+	var w *syslog.Writer
+	w, err = syslog.New(syslog.LOG_CRIT, prefix)
+	return &SyslogBackend{w}, err
+}
+
+// NewSyslogBackendPriority is the same as NewSyslogBackend, but with custom
+// syslog priority, like syslog.LOG_LOCAL3|syslog.LOG_DEBUG etc.
+func NewSyslogBackendPriority(prefix string, priority syslog.Priority) (b *SyslogBackend, err error) {
+	var w *syslog.Writer
+	w, err = syslog.New(priority, prefix)
+	return &SyslogBackend{w}, err
+}
+
+func (b *SyslogBackend) Log(level Level, calldepth int, rec *Record) error {
+	line := rec.Formatted(calldepth + 1)
+	switch level {
+	case CRITICAL:
+		return b.Writer.Crit(line)
+	case ERROR:
+		return b.Writer.Err(line)
+	case WARNING:
+		return b.Writer.Warning(line)
+	case NOTICE:
+		return b.Writer.Notice(line)
+	case INFO:
+		return b.Writer.Info(line)
+	case DEBUG:
+		return b.Writer.Debug(line)
+	default:
+	}
+	panic("unhandled log level")
+}
diff --git a/vendor/github.com/whyrusleeping/go-multiplex/LICENSE b/vendor/github.com/whyrusleeping/go-multiplex/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-multiplex/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/go-multiplex/multiplex.go b/vendor/github.com/whyrusleeping/go-multiplex/multiplex.go
new file mode 100644
index 000000000..f6dc812ea
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-multiplex/multiplex.go
@@ -0,0 +1,417 @@
+package multiplex
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+var log = logging.Logger("multiplex")
+
+var MaxMessageSize = 1 << 20
+
+// Max time to block waiting for a slow reader to read from a stream before
+// resetting it. Preferably, we'd have some form of back-pressure mechanism but
+// we don't have that in this protocol.
+var ReceiveTimeout = 5 * time.Second
+
+// ErrShutdown is returned when operating on a shutdown session
+var ErrShutdown = errors.New("session shut down")
+
+// ErrTwoInitiators is returned when both sides think they're the initiator
+var ErrTwoInitiators = errors.New("two initiators")
+
+// ErrInvalidState is returned when the other side does something it shouldn't.
+// In this case, we close the connection to be safe.
+var ErrInvalidState = errors.New("received an unexpected message from the peer")
+
+// +1 for initiator
+const (
+	newStreamTag = 0
+	messageTag   = 2
+	closeTag     = 4
+	resetTag     = 6
+)
+
+type Multiplex struct {
+	con       net.Conn
+	buf       *bufio.Reader
+	nextID    uint64
+	initiator bool
+
+	closed       chan struct{}
+	shutdown     chan struct{}
+	shutdownErr  error
+	shutdownLock sync.Mutex
+
+	wrLock sync.Mutex
+
+	nstreams chan *Stream
+	hdrBuf   []byte
+
+	channels map[streamID]*Stream
+	chLock   sync.Mutex
+}
+
+func NewMultiplex(con net.Conn, initiator bool) *Multiplex {
+	mp := &Multiplex{
+		con:       con,
+		initiator: initiator,
+		buf:       bufio.NewReader(con),
+		channels:  make(map[streamID]*Stream),
+		closed:    make(chan struct{}),
+		shutdown:  make(chan struct{}),
+		nstreams:  make(chan *Stream, 16),
+		hdrBuf:    make([]byte, 20),
+	}
+
+	go mp.handleIncoming()
+
+	return mp
+}
+
+func (mp *Multiplex) newStream(id streamID, name string) *Stream {
+	return &Stream{
+		id:     id,
+		name:   name,
+		dataIn: make(chan []byte, 8),
+		reset:  make(chan struct{}),
+		mp:     mp,
+	}
+}
+
+func (m *Multiplex) Accept() (*Stream, error) {
+	select {
+	case s, ok := <-m.nstreams:
+		if !ok {
+			return nil, errors.New("multiplex closed")
+		}
+		return s, nil
+	case <-m.closed:
+		return nil, m.shutdownErr
+	}
+}
+
+func (mp *Multiplex) Close() error {
+	mp.closeNoWait()
+
+	// Wait for the receive loop to finish.
+	<-mp.closed
+
+	return nil
+}
+
+func (mp *Multiplex) closeNoWait() {
+	mp.shutdownLock.Lock()
+	select {
+	case <-mp.shutdown:
+	default:
+		mp.con.Close()
+		close(mp.shutdown)
+	}
+	mp.shutdownLock.Unlock()
+}
+
+func (mp *Multiplex) IsClosed() bool {
+	select {
+	case <-mp.closed:
+		return true
+	default:
+		return false
+	}
+}
+
+func (mp *Multiplex) sendMsg(header uint64, data []byte, dl time.Time) error {
+	mp.wrLock.Lock()
+	defer mp.wrLock.Unlock()
+	if !dl.IsZero() {
+		if err := mp.con.SetWriteDeadline(dl); err != nil {
+			return err
+		}
+	}
+	n := binary.PutUvarint(mp.hdrBuf, header)
+	n += binary.PutUvarint(mp.hdrBuf[n:], uint64(len(data)))
+	_, err := mp.con.Write(mp.hdrBuf[:n])
+	if err != nil {
+		return err
+	}
+
+	if len(data) != 0 {
+		_, err = mp.con.Write(data)
+		if err != nil {
+			return err
+		}
+	}
+	if !dl.IsZero() {
+		if err := mp.con.SetWriteDeadline(time.Time{}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (mp *Multiplex) nextChanID() uint64 {
+	out := mp.nextID
+	mp.nextID++
+	return out
+}
+
+func (mp *Multiplex) NewStream() (*Stream, error) {
+	return mp.NewNamedStream("")
+}
+
+func (mp *Multiplex) NewNamedStream(name string) (*Stream, error) {
+	mp.chLock.Lock()
+
+	// We could call IsClosed but this is faster (given that we already have
+	// the lock).
+	if mp.channels == nil {
+		return nil, ErrShutdown
+	}
+
+	sid := mp.nextChanID()
+	header := (sid << 3) | newStreamTag
+
+	if name == "" {
+		name = fmt.Sprint(sid)
+	}
+	s := mp.newStream(streamID{
+		id:        sid,
+		initiator: true,
+	}, name)
+	mp.channels[s.id] = s
+	mp.chLock.Unlock()
+
+	err := mp.sendMsg(header, []byte(name), time.Time{})
+	if err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}
+
+func (mp *Multiplex) cleanup() {
+	mp.closeNoWait()
+	mp.chLock.Lock()
+	defer mp.chLock.Unlock()
+	for _, msch := range mp.channels {
+		msch.clLock.Lock()
+		if !msch.closedRemote {
+			msch.closedRemote = true
+			// Cancel readers
+			close(msch.reset)
+		}
+		msch.closedLocal = true
+		msch.clLock.Unlock()
+	}
+	// Don't remove this nil assignment. We check if this is nil to check if
+	// the connection is closed when we already have the lock (faster than
+	// checking if the stream is closed).
+	mp.channels = nil
+	if mp.shutdownErr == nil {
+		mp.shutdownErr = ErrShutdown
+	}
+	close(mp.closed)
+}
+
+func (mp *Multiplex) handleIncoming() {
+	defer mp.cleanup()
+
+	recvTimeout := time.NewTimer(0)
+	defer recvTimeout.Stop()
+
+	if !recvTimeout.Stop() {
+		<-recvTimeout.C
+	}
+
+	for {
+		chID, tag, err := mp.readNextHeader()
+		if err != nil {
+			mp.shutdownErr = err
+			return
+		}
+
+		remoteIsInitiator := tag&1 == 0
+		ch := streamID{
+			// true if *I'm* the initiator.
+			initiator: !remoteIsInitiator,
+			id:        chID,
+		}
+		// Rounds up the tag:
+		// 0 -> 0
+		// 1 -> 2
+		// 2 -> 2
+		// 3 -> 4
+		// etc...
+		tag += (tag & 1)
+
+		b, err := mp.readNext()
+		if err != nil {
+			mp.shutdownErr = err
+			return
+		}
+
+		mp.chLock.Lock()
+		msch, ok := mp.channels[ch]
+		mp.chLock.Unlock()
+
+		switch tag {
+		case newStreamTag:
+			if ok {
+				log.Debugf("received NewStream message for existing stream: %d", ch)
+				mp.shutdownErr = ErrInvalidState
+				return
+			}
+
+			name := string(b)
+			msch = mp.newStream(ch, name)
+			mp.chLock.Lock()
+			mp.channels[ch] = msch
+			mp.chLock.Unlock()
+			select {
+			case mp.nstreams <- msch:
+			case <-mp.shutdown:
+				return
+			}
+
+		case resetTag:
+			if !ok {
+				// This is *ok*. We forget the stream on reset.
+				continue
+			}
+			msch.clLock.Lock()
+
+			// Honestly, this check should never be true... It means we've leaked.
+			// However, this is an error on *our* side so we shouldn't just bail.
+			if msch.closedLocal && msch.closedRemote {
+				msch.clLock.Unlock()
+				log.Errorf("leaked a completely closed stream")
+				continue
+			}
+
+			if !msch.closedRemote {
+				close(msch.reset)
+			}
+			msch.closedRemote = true
+			msch.closedLocal = true
+			msch.clLock.Unlock()
+
+			mp.chLock.Lock()
+			delete(mp.channels, ch)
+			mp.chLock.Unlock()
+		case closeTag:
+			if !ok {
+				continue
+			}
+
+			msch.clLock.Lock()
+
+			if msch.closedRemote {
+				msch.clLock.Unlock()
+				// Technically a bug on the other side. We
+				// should consider killing the connection.
+				continue
+			}
+
+			close(msch.dataIn)
+			msch.closedRemote = true
+
+			cleanup := msch.closedLocal
+
+			msch.clLock.Unlock()
+
+			if cleanup {
+				mp.chLock.Lock()
+				delete(mp.channels, ch)
+				mp.chLock.Unlock()
+			}
+		case messageTag:
+			if !ok {
+				// This is a perfectly valid case when we reset
+				// and forget about the stream.
+				log.Debugf("message for non-existant stream, dropping data: %d", ch)
+				go mp.sendMsg(ch.header(resetTag), nil, time.Time{})
+				continue
+			}
+
+			msch.clLock.Lock()
+			remoteClosed := msch.closedRemote
+			msch.clLock.Unlock()
+			if remoteClosed {
+				log.Errorf("Received data from remote after stream was closed by them. (len = %d)", len(b))
+				go mp.sendMsg(msch.id.header(resetTag), nil, time.Time{})
+				continue
+			}
+
+			recvTimeout.Reset(ReceiveTimeout)
+			select {
+			case msch.dataIn <- b:
+			case <-msch.reset:
+			case <-recvTimeout.C:
+				log.Warningf("timed out receiving message into stream queue.")
+				// Do not do this asynchronously. Otherwise, we
+				// could drop a message, then receive a message,
+				// then reset.
+				msch.Reset()
+				continue
+			case <-mp.shutdown:
+				return
+			}
+			if !recvTimeout.Stop() {
+				<-recvTimeout.C
+			}
+		default:
+			log.Debugf("message with unknown header on stream %s", ch)
+			if ok {
+				msch.Reset()
+			}
+		}
+	}
+}
+
+func (mp *Multiplex) readNextHeader() (uint64, uint64, error) {
+	h, err := binary.ReadUvarint(mp.buf)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// get channel ID
+	ch := h >> 3
+
+	rem := h & 7
+
+	return ch, rem, nil
+}
+
+func (mp *Multiplex) readNext() ([]byte, error) {
+	// get length
+	l, err := binary.ReadUvarint(mp.buf)
+	if err != nil {
+		return nil, err
+	}
+
+	if l > uint64(MaxMessageSize) {
+		return nil, fmt.Errorf("message size too large!")
+	}
+
+	if l == 0 {
+		return nil, nil
+	}
+
+	buf := mpool.ByteSlicePool.Get(uint32(l)).([]byte)[:l]
+	n, err := io.ReadFull(mp.buf, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf[:n], nil
+}
diff --git a/vendor/github.com/whyrusleeping/go-multiplex/stream.go b/vendor/github.com/whyrusleeping/go-multiplex/stream.go
new file mode 100644
index 000000000..de1a68d15
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-multiplex/stream.go
@@ -0,0 +1,220 @@
+package multiplex
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	mpool "github.com/libp2p/go-msgio/mpool"
+)
+
+// streamID is a convenience type for operating on stream IDs
+type streamID struct {
+	id        uint64
+	initiator bool
+}
+
+// header computes the header for the given tag
+func (id *streamID) header(tag uint64) uint64 {
+	header := id.id<<3 | tag
+	if !id.initiator {
+		header--
+	}
+	return header
+}
+
+type Stream struct {
+	id     streamID
+	name   string
+	dataIn chan []byte
+	mp     *Multiplex
+
+	extra []byte
+
+	// exbuf is for holding the reference to the beginning of the extra slice
+	// for later memory pool freeing
+	exbuf []byte
+
+	wDeadline time.Time
+	rDeadline time.Time
+
+	clLock       sync.Mutex
+	closedLocal  bool
+	closedRemote bool
+
+	// Closed when the connection is reset.
+	reset chan struct{}
+}
+
+func (s *Stream) Name() string {
+	return s.name
+}
+
+func (s *Stream) waitForData(ctx context.Context) error {
+	if !s.rDeadline.IsZero() {
+		dctx, cancel := context.WithDeadline(ctx, s.rDeadline)
+		defer cancel()
+		ctx = dctx
+	}
+
+	select {
+	case <-s.reset:
+		// This is the only place where it's safe to return these.
+		s.returnBuffers()
+		return fmt.Errorf("stream reset")
+	case read, ok := <-s.dataIn:
+		if !ok {
+			return io.EOF
+		}
+		s.extra = read
+		s.exbuf = read
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+func (s *Stream) returnBuffers() {
+	if s.exbuf != nil {
+		mpool.ByteSlicePool.Put(uint32(cap(s.exbuf)), s.exbuf)
+		s.exbuf = nil
+		s.extra = nil
+	}
+	for {
+		select {
+		case read, ok := <-s.dataIn:
+			if !ok {
+				return
+			}
+			if read == nil {
+				continue
+			}
+			mpool.ByteSlicePool.Put(uint32(cap(read)), read)
+		default:
+			return
+		}
+	}
+}
+
+func (s *Stream) Read(b []byte) (int, error) {
+	if s.extra == nil {
+		err := s.waitForData(context.Background())
+		if err != nil {
+			return 0, err
+		}
+	}
+	n := copy(b, s.extra)
+	if n < len(s.extra) {
+		s.extra = s.extra[n:]
+	} else {
+		if s.exbuf != nil {
+			mpool.ByteSlicePool.Put(uint32(cap(s.exbuf)), s.exbuf)
+		}
+		s.extra = nil
+		s.exbuf = nil
+	}
+	return n, nil
+}
+
+func (s *Stream) Write(b []byte) (int, error) {
+	var written int
+	for written < len(b) {
+		wl := len(b) - written
+		if wl > MaxMessageSize {
+			wl = MaxMessageSize
+		}
+
+		n, err := s.write(b[written : written+wl])
+		if err != nil {
+			return written, err
+		}
+
+		written += n
+	}
+
+	return written, nil
+}
+
+func (s *Stream) write(b []byte) (int, error) {
+	if s.isClosed() {
+		return 0, fmt.Errorf("cannot write to closed stream")
+	}
+
+	err := s.mp.sendMsg(s.id.header(messageTag), b, s.wDeadline)
+	if err != nil {
+		return 0, err
+	}
+
+	return len(b), nil
+}
+
+func (s *Stream) isClosed() bool {
+	s.clLock.Lock()
+	defer s.clLock.Unlock()
+	return s.closedLocal
+}
+
+func (s *Stream) Close() error {
+	err := s.mp.sendMsg(s.id.header(closeTag), nil, time.Time{})
+
+	s.clLock.Lock()
+	if s.closedLocal {
+		s.clLock.Unlock()
+		return nil
+	}
+
+	remote := s.closedRemote
+	s.closedLocal = true
+	s.clLock.Unlock()
+
+	if remote {
+		s.mp.chLock.Lock()
+		delete(s.mp.channels, s.id)
+		s.mp.chLock.Unlock()
+	}
+
+	return err
+}
+
+func (s *Stream) Reset() error {
+	s.clLock.Lock()
+	if s.closedRemote && s.closedLocal {
+		s.clLock.Unlock()
+		return nil
+	}
+
+	if !s.closedRemote {
+		close(s.reset)
+		// We generally call this to tell the other side to go away. No point in waiting around.
+		go s.mp.sendMsg(s.id.header(resetTag), nil, time.Time{})
+	}
+
+	s.closedLocal = true
+	s.closedRemote = true
+
+	s.clLock.Unlock()
+
+	s.mp.chLock.Lock()
+	delete(s.mp.channels, s.id)
+	s.mp.chLock.Unlock()
+
+	return nil
+}
+
+func (s *Stream) SetDeadline(t time.Time) error {
+	s.rDeadline = t
+	s.wDeadline = t
+	return nil
+}
+
+func (s *Stream) SetReadDeadline(t time.Time) error {
+	s.rDeadline = t
+	return nil
+}
+
+func (s *Stream) SetWriteDeadline(t time.Time) error {
+	s.wDeadline = t
+	return nil
+}
diff --git a/vendor/github.com/whyrusleeping/go-notifier/LICENSE b/vendor/github.com/whyrusleeping/go-notifier/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-notifier/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/go-notifier/notifier.go b/vendor/github.com/whyrusleeping/go-notifier/notifier.go
new file mode 100644
index 000000000..33302cfde
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-notifier/notifier.go
@@ -0,0 +1,146 @@
+// Package notifier provides a simple notification dispatcher
+// meant to be embedded in larger structres who wish to allow
+// clients to sign up for event notifications.
+package notifier
+
+import (
+	"sync"
+
+	process "github.com/jbenet/goprocess"
+	ratelimit "github.com/jbenet/goprocess/ratelimit"
+)
+
+// Notifiee is a generic interface. Clients implement
+// their own Notifiee interfaces to ensure type-safety
+// of notifications:
+//
+//  type RocketNotifiee interface{
+//    Countdown(r Rocket, countdown time.Duration)
+//    LiftedOff(Rocket)
+//    ReachedOrbit(Rocket)
+//    Detached(Rocket, Capsule)
+//    Landed(Rocket)
+//  }
+//
+type Notifiee interface{}
+
+// Notifier is a notification dispatcher. It's meant
+// to be composed, and its zero-value is ready to be used.
+//
+//  type Rocket struct {
+//    notifier notifier.Notifier
+//  }
+//
+type Notifier struct {
+	mu   sync.RWMutex // guards notifiees
+	nots map[Notifiee]struct{}
+	lim  *ratelimit.RateLimiter
+}
+
+// RateLimited returns a rate limited Notifier. only limit goroutines
+// will be spawned. If limit is zero, no rate limiting happens. This
+// is the same as `Notifier{}`.
+func RateLimited(limit int) Notifier {
+	n := Notifier{}
+	if limit > 0 {
+		n.lim = ratelimit.NewRateLimiter(process.Background(), limit)
+	}
+	return n
+}
+
+// Notify signs up Notifiee e for notifications. This function
+// is meant to be called behind your own type-safe function(s):
+//
+//   // generic function for pattern-following
+//   func (r *Rocket) Notify(n Notifiee) {
+//     r.notifier.Notify(n)
+//   }
+//
+//   // or as part of other functions
+//   func (r *Rocket) Onboard(a Astronaut) {
+//     r.astronauts = append(r.austronauts, a)
+//     r.notifier.Notify(a)
+//   }
+//
+func (n *Notifier) Notify(e Notifiee) {
+	n.mu.Lock()
+	if n.nots == nil { // so that zero-value is ready to be used.
+		n.nots = make(map[Notifiee]struct{})
+	}
+	n.nots[e] = struct{}{}
+	n.mu.Unlock()
+}
+
+// StopNotify stops notifying Notifiee e. This function
+// is meant to be called behind your own type-safe function(s):
+//
+//   // generic function for pattern-following
+//   func (r *Rocket) StopNotify(n Notifiee) {
+//     r.notifier.StopNotify(n)
+//   }
+//
+//   // or as part of other functions
+//   func (r *Rocket) Detach(c Capsule) {
+//     r.notifier.StopNotify(c)
+//     r.capsule = nil
+//   }
+//
+func (n *Notifier) StopNotify(e Notifiee) {
+	n.mu.Lock()
+	if n.nots != nil { // so that zero-value is ready to be used.
+		delete(n.nots, e)
+	}
+	n.mu.Unlock()
+}
+
+// NotifyAll messages the notifier's notifiees with a given notification.
+// This is done by calling the given function with each notifiee. It is
+// meant to be called with your own type-safe notification functions:
+//
+//  func (r *Rocket) Launch() {
+//    r.notifyAll(func(n Notifiee) {
+//      n.Launched(r)
+//    })
+//  }
+//
+//  // make it private so only you can use it. This function is necessary
+//  // to make sure you only up-cast in one place. You control who you added
+//  // to be a notifiee. If Go adds generics, maybe we can get rid of this
+//  // method but for now it is like wrapping a type-less container with
+//  // a type safe interface.
+//  func (r *Rocket) notifyAll(notify func(Notifiee)) {
+//    r.notifier.NotifyAll(func(n notifier.Notifiee) {
+//      notify(n.(Notifiee))
+//    })
+//  }
+//
+// Note well: each notification is launched in its own goroutine, so they
+// can be processed concurrently, and so that whatever the notification does
+// it _never_ blocks out the client. This is so that consumers _cannot_ add
+// hooks into your object that block you accidentally.
+func (n *Notifier) NotifyAll(notify func(Notifiee)) {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	if n.nots == nil { // so that zero-value is ready to be used.
+		return
+	}
+
+	// no rate limiting.
+	if n.lim == nil {
+		for notifiee := range n.nots {
+			go notify(notifiee)
+		}
+		return
+	}
+
+	// with rate limiting.
+	n.lim.Go(func(worker process.Process) {
+		for notifiee := range n.nots {
+			notifiee := notifiee // rebind for loop data races
+			n.lim.LimitedGo(func(worker process.Process) {
+				notify(notifiee)
+			})
+		}
+	})
+}
diff --git a/vendor/github.com/whyrusleeping/go-smux-multiplex/LICENSE b/vendor/github.com/whyrusleeping/go-smux-multiplex/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-multiplex/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/go-smux-multiplex/multiplex.go b/vendor/github.com/whyrusleeping/go-smux-multiplex/multiplex.go
new file mode 100644
index 000000000..0eebb7262
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-multiplex/multiplex.go
@@ -0,0 +1,41 @@
+package peerstream_multiplex
+
+import (
+	"net"
+
+	smux "github.com/libp2p/go-stream-muxer"
+	mp "github.com/whyrusleeping/go-multiplex" // Conn is a connection to a remote peer.
+)
+
+type conn struct {
+	*mp.Multiplex
+}
+
+func (c *conn) Close() error {
+	return c.Multiplex.Close()
+}
+
+func (c *conn) IsClosed() bool {
+	return c.Multiplex.IsClosed()
+}
+
+// OpenStream creates a new stream.
+func (c *conn) OpenStream() (smux.Stream, error) {
+	return c.Multiplex.NewStream()
+}
+
+// AcceptStream accepts a stream opened by the other side.
+func (c *conn) AcceptStream() (smux.Stream, error) {
+	return c.Multiplex.Accept()
+}
+
+// Transport is a go-peerstream transport that constructs
+// multiplex-backed connections.
+type Transport struct{}
+
+// DefaultTransport has default settings for multiplex
+var DefaultTransport = &Transport{}
+
+func (t *Transport) NewConn(nc net.Conn, isServer bool) (smux.Conn, error) {
+	return &conn{mp.NewMultiplex(nc, isServer)}, nil
+}
diff --git a/vendor/github.com/whyrusleeping/go-smux-multistream/LICENSE b/vendor/github.com/whyrusleeping/go-smux-multistream/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-multistream/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/go-smux-multistream/multistream.go b/vendor/github.com/whyrusleeping/go-smux-multistream/multistream.go
new file mode 100644
index 000000000..ad453a995
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-multistream/multistream.go
@@ -0,0 +1,74 @@
+// package multistream implements a peerstream transport using
+// go-multistream to select the underlying stream muxer
+package multistream
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	smux "github.com/libp2p/go-stream-muxer"
+	mss "github.com/multiformats/go-multistream"
+)
+
+var DefaultNegotiateTimeout = time.Second * 60
+
+type Transport struct {
+	mux *mss.MultistreamMuxer
+
+	tpts map[string]smux.Transport
+
+	NegotiateTimeout time.Duration
+
+	OrderPreference []string
+}
+
+func NewBlankTransport() *Transport {
+	return &Transport{
+		mux:              mss.NewMultistreamMuxer(),
+		tpts:             make(map[string]smux.Transport),
+		NegotiateTimeout: DefaultNegotiateTimeout,
+	}
+}
+
+func (t *Transport) AddTransport(path string, tpt smux.Transport) {
+	t.mux.AddHandler(path, nil)
+	t.tpts[path] = tpt
+	t.OrderPreference = append(t.OrderPreference, path)
+}
+
+func (t *Transport) NewConn(nc net.Conn, isServer bool) (smux.Conn, error) {
+	if t.NegotiateTimeout != 0 {
+		if err := nc.SetDeadline(time.Now().Add(t.NegotiateTimeout)); err != nil {
+			return nil, err
+		}
+	}
+
+	var proto string
+	if isServer {
+		selected, _, err := t.mux.Negotiate(nc)
+		if err != nil {
+			return nil, err
+		}
+		proto = selected
+	} else {
+		selected, err := mss.SelectOneOf(t.OrderPreference, nc)
+		if err != nil {
+			return nil, err
+		}
+		proto = selected
+	}
+
+	if t.NegotiateTimeout != 0 {
+		if err := nc.SetDeadline(time.Time{}); err != nil {
+			return nil, err
+		}
+	}
+
+	tpt, ok := t.tpts[proto]
+	if !ok {
+		return nil, fmt.Errorf("selected protocol we don't have a transport for")
+	}
+
+	return tpt.NewConn(nc, isServer)
+}
diff --git a/vendor/github.com/whyrusleeping/go-smux-yamux/LICENSE b/vendor/github.com/whyrusleeping/go-smux-yamux/LICENSE
new file mode 100644
index 000000000..c7386b3c9
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-yamux/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/go-smux-yamux/yamux.go b/vendor/github.com/whyrusleeping/go-smux-yamux/yamux.go
new file mode 100644
index 000000000..7a602d0ba
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/go-smux-yamux/yamux.go
@@ -0,0 +1,70 @@
+package sm_yamux
+
+import (
+	"io/ioutil"
+	"net"
+	"time"
+
+	smux "github.com/libp2p/go-stream-muxer"
+	yamux "github.com/whyrusleeping/yamux"
+)
+
+// Conn is a connection to a remote peer.
+type conn yamux.Session
+
+func (c *conn) yamuxSession() *yamux.Session {
+	return (*yamux.Session)(c)
+}
+
+func (c *conn) Close() error {
+	return c.yamuxSession().Close()
+}
+
+func (c *conn) IsClosed() bool {
+	return c.yamuxSession().IsClosed()
+}
+
+// OpenStream creates a new stream.
+func (c *conn) OpenStream() (smux.Stream, error) {
+	s, err := c.yamuxSession().OpenStream()
+	if err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}
+
+// AcceptStream accepts a stream opened by the other side.
+func (c *conn) AcceptStream() (smux.Stream, error) {
+	s, err := c.yamuxSession().AcceptStream()
+	return s, err
+}
+
+// Transport is a go-peerstream transport that constructs
+// yamux-backed connections.
+type Transport yamux.Config
+
+// DefaultTransport has default settings for yamux
+var DefaultTransport = (*Transport)(&yamux.Config{
+	AcceptBacklog:          256,                // from yamux.DefaultConfig
+	EnableKeepAlive:        true,               // from yamux.DefaultConfig
+	KeepAliveInterval:      30 * time.Second,   // from yamux.DefaultConfig
+	ConnectionWriteTimeout: 10 * time.Second,   // from yamux.DefaultConfig
+	MaxStreamWindowSize:    uint32(256 * 1024), // from yamux.DefaultConfig
+	LogOutput:              ioutil.Discard,
+})
+
+func (t *Transport) NewConn(nc net.Conn, isServer bool) (smux.Conn, error) {
+	var s *yamux.Session
+	var err error
+	if isServer {
+		s, err = yamux.Server(nc, t.Config())
+	} else {
+		s, err = yamux.Client(nc, t.Config())
+	}
+	return (*conn)(s), err
+}
+
+func (t *Transport) Config() *yamux.Config {
+	return (*yamux.Config)(t)
+}
diff --git a/vendor/github.com/whyrusleeping/mafmt/LICENSE b/vendor/github.com/whyrusleeping/mafmt/LICENSE
new file mode 100644
index 000000000..26100332b
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/mafmt/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/mafmt/patterns.go b/vendor/github.com/whyrusleeping/mafmt/patterns.go
new file mode 100644
index 000000000..c3d191203
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/mafmt/patterns.go
@@ -0,0 +1,133 @@
+package mafmt
+
+import (
+	"strings"
+
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// Define IP as either ipv4 or ipv6
+var IP = Or(Base(ma.P_IP4), Base(ma.P_IP6))
+
+// Define TCP as 'tcp' on top of either ipv4 or ipv6
+var TCP = And(IP, Base(ma.P_TCP))
+
+// Define UDP as 'udp' on top of either ipv4 or ipv6
+var UDP = And(IP, Base(ma.P_UDP))
+
+// Define UTP as 'utp' on top of udp (on top of ipv4 or ipv6)
+var UTP = And(UDP, Base(ma.P_UTP))
+
+// Define QUIC as 'quic' on top of udp (on top of ipv4 or ipv6)
+var QUIC = And(UDP, Base(ma.P_QUIC))
+
+// Define unreliable transport as udp
+var Unreliable = Or(UDP)
+
+// Now define a Reliable transport as either tcp or utp or quic
+var Reliable = Or(TCP, UTP, QUIC)
+
+// IPFS can run over any reliable underlying transport protocol
+var IPFS = And(Reliable, Base(ma.P_IPFS))
+
+const (
+	or  = iota
+	and = iota
+)
+
+func And(ps ...Pattern) Pattern {
+	return &pattern{
+		Op:   and,
+		Args: ps,
+	}
+}
+
+func Or(ps ...Pattern) Pattern {
+	return &pattern{
+		Op:   or,
+		Args: ps,
+	}
+}
+
+type Pattern interface {
+	Matches(ma.Multiaddr) bool
+	partialMatch([]ma.Protocol) (bool, []ma.Protocol)
+	String() string
+}
+
+type pattern struct {
+	Args []Pattern
+	Op   int
+}
+
+func (ptrn *pattern) Matches(a ma.Multiaddr) bool {
+	ok, rem := ptrn.partialMatch(a.Protocols())
+	return ok && len(rem) == 0
+}
+
+func (ptrn *pattern) partialMatch(pcs []ma.Protocol) (bool, []ma.Protocol) {
+	switch ptrn.Op {
+	case or:
+		for _, a := range ptrn.Args {
+			ok, rem := a.partialMatch(pcs)
+			if ok {
+				return true, rem
+			}
+		}
+		return false, nil
+	case and:
+		if len(pcs) < len(ptrn.Args) {
+			return false, nil
+		}
+
+		for i := 0; i < len(ptrn.Args); i++ {
+			ok, rem := ptrn.Args[i].partialMatch(pcs)
+			if !ok {
+				return false, nil
+			}
+
+			pcs = rem
+		}
+
+		return true, pcs
+	default:
+		panic("unrecognized pattern operand")
+	}
+}
+
+func (ptrn *pattern) String() string {
+	var sub []string
+	for _, a := range ptrn.Args {
+		sub = append(sub, a.String())
+	}
+
+	switch ptrn.Op {
+	case and:
+		return strings.Join(sub, "/")
+	case or:
+		return "{" + strings.Join(sub, "|") + "}"
+	default:
+		panic("unrecognized pattern op!")
+	}
+}
+
+type Base int
+
+func (p Base) Matches(a ma.Multiaddr) bool {
+	pcs := a.Protocols()
+	return pcs[0].Code == int(p) && len(pcs) == 1
+}
+
+func (p Base) partialMatch(pcs []ma.Protocol) (bool, []ma.Protocol) {
+	if len(pcs) == 0 {
+		return false, nil
+	}
+	if pcs[0].Code == int(p) {
+		return true, pcs[1:]
+	}
+	return false, nil
+}
+
+func (p Base) String() string {
+	return ma.ProtocolWithCode(int(p)).Name
+}
diff --git a/vendor/github.com/whyrusleeping/multiaddr-filter/LICENSE b/vendor/github.com/whyrusleeping/multiaddr-filter/LICENSE
new file mode 100644
index 000000000..1a976e72e
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/multiaddr-filter/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/whyrusleeping/multiaddr-filter/mask.go b/vendor/github.com/whyrusleeping/multiaddr-filter/mask.go
new file mode 100644
index 000000000..7f012258d
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/multiaddr-filter/mask.go
@@ -0,0 +1,47 @@
+package mask
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+)
+
+var ErrInvalidFormat = errors.New("invalid multiaddr-filter format")
+
+func NewMask(a string) (*net.IPNet, error) {
+	parts := strings.Split(a, "/")
+
+	if parts[0] != "" {
+		return nil, ErrInvalidFormat
+	}
+
+	if len(parts) != 5 {
+		return nil, ErrInvalidFormat
+	}
+
+	// check it's a valid filter address. ip + cidr
+	isip := parts[1] == "ip4" || parts[1] == "ip6"
+	iscidr := parts[3] == "ipcidr"
+	if !isip || !iscidr {
+		return nil, ErrInvalidFormat
+	}
+
+	_, ipn, err := net.ParseCIDR(parts[2] + "/" + parts[4])
+	if err != nil {
+		return nil, err
+	}
+	return ipn, nil
+}
+
+func ConvertIPNet(n *net.IPNet) (string, error) {
+	b, _ := n.Mask.Size()
+	switch {
+	case n.IP.To4() != nil:
+		return fmt.Sprintf("/ip4/%s/ipcidr/%d", n.IP, b), nil
+	case n.IP.To16() != nil:
+		return fmt.Sprintf("/ip6/%s/ipcidr/%d", n.IP, b), nil
+	default:
+		return "", fmt.Errorf("was not given valid ip addr")
+	}
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/LICENSE b/vendor/github.com/whyrusleeping/yamux/LICENSE
new file mode 100644
index 000000000..f0e5c79e1
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/LICENSE
@@ -0,0 +1,362 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+     means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the terms of
+        a Secondary License.
+
+1.6. "Executable Form"
+
+     means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+     means a work that combines Covered Software with other material, in a
+     separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+     means this document.
+
+1.9. "Licensable"
+
+     means having the right to grant, to the maximum extent possible, whether
+     at the time of the initial grant or subsequently, any and all of the
+     rights conveyed by this License.
+
+1.10. "Modifications"
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+      means any patent claim(s), including without limitation, method,
+      process, and apparatus claims, in any patent Licensable by such
+      Contributor that would be infringed, but for the grant of the License,
+      by the making, using, selling, offering for sale, having made, import,
+      or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+      means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, "You" includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, "control" means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or
+        as part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its
+        Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution
+     become effective for each Contribution on the date the Contributor first
+     distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under
+     this License. No additional rights or licenses will be implied from the
+     distribution or licensing of Covered Software under this License.
+     Notwithstanding Section 2.1(b) above, no patent license is granted by a
+     Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party's
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of
+        its Contributions.
+
+     This License does not grant any rights in the trademarks, service marks,
+     or logos of any Contributor (except as may be necessary to comply with
+     the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this
+     License (see Section 10.2) or under the terms of a Secondary License (if
+     permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its
+     Contributions are its original creation(s) or it has sufficient rights to
+     grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under
+     applicable copyright doctrines of fair use, fair dealing, or other
+     equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under
+     the terms of this License. You must inform recipients that the Source
+     Code Form of the Covered Software is governed by the terms of this
+     License, and how they can obtain a copy of this License. You may not
+     attempt to alter or restrict the recipients' rights in the Source Code
+     Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this
+        License, or sublicense it under different terms, provided that the
+        license for the Executable Form does not attempt to limit or alter the
+        recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for
+     the Covered Software. If the Larger Work is a combination of Covered
+     Software with a work governed by one or more Secondary Licenses, and the
+     Covered Software is not Incompatible With Secondary Licenses, this
+     License permits You to additionally distribute such Covered Software
+     under the terms of such Secondary License(s), so that the recipient of
+     the Larger Work may, at their option, further distribute the Covered
+     Software under the terms of either this License or such Secondary
+     License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices
+     (including copyright notices, patent notices, disclaimers of warranty, or
+     limitations of liability) contained within the Source Code Form of the
+     Covered Software, except that You may alter any license notices to the
+     extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on
+     behalf of any Contributor. You must make it absolutely clear that any
+     such warranty, support, indemnity, or liability obligation is offered by
+     You alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute,
+   judicial order, or regulation then You must: (a) comply with the terms of
+   this License to the maximum extent possible; and (b) describe the
+   limitations and the code they affect. Such description must be placed in a
+   text file included with all distributions of the Covered Software under
+   this License. Except to the extent prohibited by statute or regulation,
+   such description must be sufficiently detailed for a recipient of ordinary
+   skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing
+     basis, if such Contributor fails to notify You of the non-compliance by
+     some reasonable means prior to 60 days after You have come back into
+     compliance. Moreover, Your grants from a particular Contributor are
+     reinstated on an ongoing basis if such Contributor notifies You of the
+     non-compliance by some reasonable means, this is the first time You have
+     received notice of non-compliance with this License from such
+     Contributor, and You become compliant prior to 30 days after Your receipt
+     of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions,
+     counter-claims, and cross-claims) alleging that a Contributor Version
+     directly or indirectly infringes any patent, then the rights granted to
+     You by any and all Contributors for the Covered Software under Section
+     2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an "as is" basis,
+   without warranty of any kind, either expressed, implied, or statutory,
+   including, without limitation, warranties that the Covered Software is free
+   of defects, merchantable, fit for a particular purpose or non-infringing.
+   The entire risk as to the quality and performance of the Covered Software
+   is with You. Should any Covered Software prove defective in any respect,
+   You (not any Contributor) assume the cost of any necessary servicing,
+   repair, or correction. This disclaimer of warranty constitutes an essential
+   part of this License. No use of  any Covered Software is authorized under
+   this License except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from
+   such party's negligence to the extent applicable law prohibits such
+   limitation. Some jurisdictions do not allow the exclusion or limitation of
+   incidental or consequential damages, so this exclusion and limitation may
+   not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts
+   of a jurisdiction where the defendant maintains its principal place of
+   business and such litigation shall be governed by laws of that
+   jurisdiction, without reference to its conflict-of-law provisions. Nothing
+   in this Section shall prevent a party's ability to bring cross-claims or
+   counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject
+   matter hereof. If any provision of this License is held to be
+   unenforceable, such provision shall be reformed only to the extent
+   necessary to make it enforceable. Any law or regulation which provides that
+   the language of a contract shall be construed against the drafter shall not
+   be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version
+      of the License under which You originally received the Covered Software,
+      or under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a
+      modified version of this License if you rename the license and remove
+      any references to the name of the license steward (except to note that
+      such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+      Licenses If You choose to distribute Source Code Form that is
+      Incompatible With Secondary Licenses under the terms of this version of
+      the License, the notice described in Exhibit B of this License must be
+      attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+      This Source Code Form is "Incompatible
+      With Secondary Licenses", as defined by
+      the Mozilla Public License, v. 2.0.
\ No newline at end of file
diff --git a/vendor/github.com/whyrusleeping/yamux/addr.go b/vendor/github.com/whyrusleeping/yamux/addr.go
new file mode 100644
index 000000000..be6ebca9c
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/addr.go
@@ -0,0 +1,60 @@
+package yamux
+
+import (
+	"fmt"
+	"net"
+)
+
+// hasAddr is used to get the address from the underlying connection
+type hasAddr interface {
+	LocalAddr() net.Addr
+	RemoteAddr() net.Addr
+}
+
+// yamuxAddr is used when we cannot get the underlying address
+type yamuxAddr struct {
+	Addr string
+}
+
+func (*yamuxAddr) Network() string {
+	return "yamux"
+}
+
+func (y *yamuxAddr) String() string {
+	return fmt.Sprintf("yamux:%s", y.Addr)
+}
+
+// Addr is used to get the address of the listener.
+func (s *Session) Addr() net.Addr {
+	return s.LocalAddr()
+}
+
+// LocalAddr is used to get the local address of the
+// underlying connection.
+func (s *Session) LocalAddr() net.Addr {
+	addr, ok := s.conn.(hasAddr)
+	if !ok {
+		return &yamuxAddr{"local"}
+	}
+	return addr.LocalAddr()
+}
+
+// RemoteAddr is used to get the address of remote end
+// of the underlying connection
+func (s *Session) RemoteAddr() net.Addr {
+	addr, ok := s.conn.(hasAddr)
+	if !ok {
+		return &yamuxAddr{"remote"}
+	}
+	return addr.RemoteAddr()
+}
+
+// LocalAddr returns the local address
+func (s *Stream) LocalAddr() net.Addr {
+	return s.session.LocalAddr()
+}
+
+// LocalAddr returns the remote address
+func (s *Stream) RemoteAddr() net.Addr {
+	return s.session.RemoteAddr()
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/const.go b/vendor/github.com/whyrusleeping/yamux/const.go
new file mode 100644
index 000000000..22e349f91
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/const.go
@@ -0,0 +1,165 @@
+package yamux
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+type YamuxError struct {
+	msg string
+}
+
+func (ye YamuxError) Error() string {
+	return ye.msg
+}
+
+var (
+	// ErrInvalidVersion means we received a frame with an
+	// invalid version
+	ErrInvalidVersion = &YamuxError{"invalid protocol version"}
+
+	// ErrInvalidMsgType means we received a frame with an
+	// invalid message type
+	ErrInvalidMsgType = &YamuxError{"invalid msg type"}
+
+	// ErrSessionShutdown is used if there is a shutdown during
+	// an operation
+	ErrSessionShutdown = &YamuxError{"session shutdown"}
+
+	// ErrStreamsExhausted is returned if we have no more
+	// stream ids to issue
+	ErrStreamsExhausted = &YamuxError{"streams exhausted"}
+
+	// ErrDuplicateStream is used if a duplicate stream is
+	// opened inbound
+	ErrDuplicateStream = &YamuxError{"duplicate stream initiated"}
+
+	// ErrReceiveWindowExceeded indicates the window was exceeded
+	ErrRecvWindowExceeded = &YamuxError{"recv window exceeded"}
+
+	// ErrTimeout is used when we reach an IO deadline
+	ErrTimeout = &YamuxError{"i/o deadline reached"}
+
+	// ErrStreamClosed is returned when using a closed stream
+	ErrStreamClosed = &YamuxError{"stream closed"}
+
+	// ErrUnexpectedFlag is set when we get an unexpected flag
+	ErrUnexpectedFlag = &YamuxError{"unexpected flag"}
+
+	// ErrRemoteGoAway is used when we get a go away from the other side
+	ErrRemoteGoAway = &YamuxError{"remote end is not accepting connections"}
+
+	// ErrConnectionReset is sent if a stream is reset. This can happen
+	// if the backlog is exceeded, or if there was a remote GoAway.
+	ErrConnectionReset = &YamuxError{"stream reset"}
+
+	// ErrConnectionWriteTimeout indicates that we hit the "safety valve"
+	// timeout writing to the underlying stream connection.
+	ErrConnectionWriteTimeout = &YamuxError{"connection write timeout"}
+
+	// ErrKeepAliveTimeout is sent if a missed keepalive caused the stream close
+	ErrKeepAliveTimeout = &YamuxError{"keepalive timeout"}
+)
+
+const (
+	// protoVersion is the only version we support
+	protoVersion uint8 = 0
+)
+
+const (
+	// Data is used for data frames. They are followed
+	// by length bytes worth of payload.
+	typeData uint8 = iota
+
+	// WindowUpdate is used to change the window of
+	// a given stream. The length indicates the delta
+	// update to the window.
+	typeWindowUpdate
+
+	// Ping is sent as a keep-alive or to measure
+	// the RTT. The StreamID and Length value are echoed
+	// back in the response.
+	typePing
+
+	// GoAway is sent to terminate a session. The StreamID
+	// should be 0 and the length is an error code.
+	typeGoAway
+)
+
+const (
+	// SYN is sent to signal a new stream. May
+	// be sent with a data payload
+	flagSYN uint16 = 1 << iota
+
+	// ACK is sent to acknowledge a new stream. May
+	// be sent with a data payload
+	flagACK
+
+	// FIN is sent to half-close the given stream.
+	// May be sent with a data payload.
+	flagFIN
+
+	// RST is used to hard close a given stream.
+	flagRST
+)
+
+const (
+	// initialStreamWindow is the initial stream window size
+	initialStreamWindow uint32 = 256 * 1024
+)
+
+const (
+	// goAwayNormal is sent on a normal termination
+	goAwayNormal uint32 = iota
+
+	// goAwayProtoErr sent on a protocol error
+	goAwayProtoErr
+
+	// goAwayInternalErr sent on an internal error
+	goAwayInternalErr
+)
+
+const (
+	sizeOfVersion  = 1
+	sizeOfType     = 1
+	sizeOfFlags    = 2
+	sizeOfStreamID = 4
+	sizeOfLength   = 4
+	headerSize     = sizeOfVersion + sizeOfType + sizeOfFlags +
+		sizeOfStreamID + sizeOfLength
+)
+
+type header []byte
+
+func (h header) Version() uint8 {
+	return h[0]
+}
+
+func (h header) MsgType() uint8 {
+	return h[1]
+}
+
+func (h header) Flags() uint16 {
+	return binary.BigEndian.Uint16(h[2:4])
+}
+
+func (h header) StreamID() uint32 {
+	return binary.BigEndian.Uint32(h[4:8])
+}
+
+func (h header) Length() uint32 {
+	return binary.BigEndian.Uint32(h[8:12])
+}
+
+func (h header) String() string {
+	return fmt.Sprintf("Vsn:%d Type:%d Flags:%d StreamID:%d Length:%d",
+		h.Version(), h.MsgType(), h.Flags(), h.StreamID(), h.Length())
+}
+
+func (h header) encode(msgType uint8, flags uint16, streamID uint32, length uint32) {
+	h[0] = protoVersion
+	h[1] = msgType
+	binary.BigEndian.PutUint16(h[2:4], flags)
+	binary.BigEndian.PutUint32(h[4:8], streamID)
+	binary.BigEndian.PutUint32(h[8:12], length)
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/mux.go b/vendor/github.com/whyrusleeping/yamux/mux.go
new file mode 100644
index 000000000..7abc7c744
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/mux.go
@@ -0,0 +1,87 @@
+package yamux
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"time"
+)
+
+// Config is used to tune the Yamux session
+type Config struct {
+	// AcceptBacklog is used to limit how many streams may be
+	// waiting an accept.
+	AcceptBacklog int
+
+	// EnableKeepalive is used to do a period keep alive
+	// messages using a ping.
+	EnableKeepAlive bool
+
+	// KeepAliveInterval is how often to perform the keep alive
+	KeepAliveInterval time.Duration
+
+	// ConnectionWriteTimeout is meant to be a "safety valve" timeout after
+	// we which will suspect a problem with the underlying connection and
+	// close it. This is only applied to writes, where's there's generally
+	// an expectation that things will move along quickly.
+	ConnectionWriteTimeout time.Duration
+
+	// MaxStreamWindowSize is used to control the maximum
+	// window size that we allow for a stream.
+	MaxStreamWindowSize uint32
+
+	// LogOutput is used to control the log destination
+	LogOutput io.Writer
+}
+
+// DefaultConfig is used to return a default configuration
+func DefaultConfig() *Config {
+	return &Config{
+		AcceptBacklog:          256,
+		EnableKeepAlive:        true,
+		KeepAliveInterval:      30 * time.Second,
+		ConnectionWriteTimeout: 10 * time.Second,
+		MaxStreamWindowSize:    initialStreamWindow,
+		LogOutput:              os.Stderr,
+	}
+}
+
+// VerifyConfig is used to verify the sanity of configuration
+func VerifyConfig(config *Config) error {
+	if config.AcceptBacklog <= 0 {
+		return fmt.Errorf("backlog must be positive")
+	}
+	if config.KeepAliveInterval == 0 {
+		return fmt.Errorf("keep-alive interval must be positive")
+	}
+	if config.MaxStreamWindowSize < initialStreamWindow {
+		return fmt.Errorf("MaxStreamWindowSize must be larger than %d", initialStreamWindow)
+	}
+	return nil
+}
+
+// Server is used to initialize a new server-side connection.
+// There must be at most one server-side connection. If a nil config is
+// provided, the DefaultConfiguration will be used.
+func Server(conn io.ReadWriteCloser, config *Config) (*Session, error) {
+	if config == nil {
+		config = DefaultConfig()
+	}
+	if err := VerifyConfig(config); err != nil {
+		return nil, err
+	}
+	return newSession(config, conn, false), nil
+}
+
+// Client is used to initialize a new client-side connection.
+// There must be at most one client-side connection.
+func Client(conn io.ReadWriteCloser, config *Config) (*Session, error) {
+	if config == nil {
+		config = DefaultConfig()
+	}
+
+	if err := VerifyConfig(config); err != nil {
+		return nil, err
+	}
+	return newSession(config, conn, true), nil
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/session.go b/vendor/github.com/whyrusleeping/yamux/session.go
new file mode 100644
index 000000000..d8446fa65
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/session.go
@@ -0,0 +1,646 @@
+package yamux
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"math"
+	"net"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Session is used to wrap a reliable ordered connection and to
+// multiplex it into multiple streams.
+type Session struct {
+	// remoteGoAway indicates the remote side does
+	// not want futher connections. Must be first for alignment.
+	remoteGoAway int32
+
+	// localGoAway indicates that we should stop
+	// accepting futher connections. Must be first for alignment.
+	localGoAway int32
+
+	// nextStreamID is the next stream we should
+	// send. This depends if we are a client/server.
+	nextStreamID uint32
+
+	// config holds our configuration
+	config *Config
+
+	// logger is used for our logs
+	logger *log.Logger
+
+	// conn is the underlying connection
+	conn io.ReadWriteCloser
+
+	// bufRead is a buffered reader
+	bufRead *bufio.Reader
+
+	// pings is used to track inflight pings
+	pings    map[uint32]chan struct{}
+	pingID   uint32
+	pingLock sync.Mutex
+
+	// streams maps a stream id to a stream, and inflight has an entry
+	// for any outgoing stream that has not yet been established. Both are
+	// protected by streamLock.
+	streams    map[uint32]*Stream
+	inflight   map[uint32]struct{}
+	streamLock sync.Mutex
+
+	// synCh acts like a semaphore. It is sized to the AcceptBacklog which
+	// is assumed to be symmetric between the client and server. This allows
+	// the client to avoid exceeding the backlog and instead blocks the open.
+	synCh chan struct{}
+
+	// acceptCh is used to pass ready streams to the client
+	acceptCh chan *Stream
+
+	// sendCh is used to mark a stream as ready to send,
+	// or to send a header out directly.
+	sendCh chan sendReady
+
+	// recvDoneCh is closed when recv() exits to avoid a race
+	// between stream registration and stream shutdown
+	recvDoneCh chan struct{}
+
+	// shutdown is used to safely close a session
+	shutdown     bool
+	shutdownErr  error
+	shutdownCh   chan struct{}
+	shutdownLock sync.Mutex
+}
+
+// sendReady is used to either mark a stream as ready
+// or to directly send a header
+type sendReady struct {
+	Hdr  []byte
+	Body io.Reader
+	Err  chan error
+}
+
+// newSession is used to construct a new session
+func newSession(config *Config, conn io.ReadWriteCloser, client bool) *Session {
+	s := &Session{
+		config:     config,
+		logger:     log.New(config.LogOutput, "", log.LstdFlags),
+		conn:       conn,
+		bufRead:    bufio.NewReader(conn),
+		pings:      make(map[uint32]chan struct{}),
+		streams:    make(map[uint32]*Stream),
+		inflight:   make(map[uint32]struct{}),
+		synCh:      make(chan struct{}, config.AcceptBacklog),
+		acceptCh:   make(chan *Stream, config.AcceptBacklog),
+		sendCh:     make(chan sendReady, 64),
+		recvDoneCh: make(chan struct{}),
+		shutdownCh: make(chan struct{}),
+	}
+	if client {
+		s.nextStreamID = 1
+	} else {
+		s.nextStreamID = 2
+	}
+	go s.recv()
+	go s.send()
+	if config.EnableKeepAlive {
+		go s.keepalive()
+	}
+	return s
+}
+
+// IsClosed does a safe check to see if we have shutdown
+func (s *Session) IsClosed() bool {
+	select {
+	case <-s.shutdownCh:
+		return true
+	default:
+		return false
+	}
+}
+
+// CloseChan returns a read-only channel which is closed as
+// soon as the session is closed.
+func (s *Session) CloseChan() <-chan struct{} {
+	return s.shutdownCh
+}
+
+// NumStreams returns the number of currently open streams
+func (s *Session) NumStreams() int {
+	s.streamLock.Lock()
+	num := len(s.streams)
+	s.streamLock.Unlock()
+	return num
+}
+
+// Open is used to create a new stream as a net.Conn
+func (s *Session) Open() (net.Conn, error) {
+	conn, err := s.OpenStream()
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+// OpenStream is used to create a new stream
+func (s *Session) OpenStream() (*Stream, error) {
+	if s.IsClosed() {
+		return nil, ErrSessionShutdown
+	}
+	if atomic.LoadInt32(&s.remoteGoAway) == 1 {
+		return nil, ErrRemoteGoAway
+	}
+
+	// Block if we have too many inflight SYNs
+	select {
+	case s.synCh <- struct{}{}:
+	case <-s.shutdownCh:
+		return nil, ErrSessionShutdown
+	}
+
+GET_ID:
+	// Get an ID, and check for stream exhaustion
+	id := atomic.LoadUint32(&s.nextStreamID)
+	if id >= math.MaxUint32-1 {
+		return nil, ErrStreamsExhausted
+	}
+	if !atomic.CompareAndSwapUint32(&s.nextStreamID, id, id+2) {
+		goto GET_ID
+	}
+
+	// Register the stream
+	stream := newStream(s, id, streamInit)
+	s.streamLock.Lock()
+	s.streams[id] = stream
+	s.inflight[id] = struct{}{}
+	s.streamLock.Unlock()
+
+	// Send the window update to create
+	if err := stream.sendWindowUpdate(); err != nil {
+		select {
+		case <-s.synCh:
+		default:
+			s.logger.Printf("[ERR] yamux: aborted stream open without inflight syn semaphore")
+		}
+		return nil, err
+	}
+	return stream, nil
+}
+
+// Accept is used to block until the next available stream
+// is ready to be accepted.
+func (s *Session) Accept() (net.Conn, error) {
+	conn, err := s.AcceptStream()
+	if err != nil {
+		return nil, err
+	}
+	return conn, err
+}
+
+// AcceptStream is used to block until the next available stream
+// is ready to be accepted.
+func (s *Session) AcceptStream() (*Stream, error) {
+	select {
+	case stream := <-s.acceptCh:
+		if err := stream.sendWindowUpdate(); err != nil {
+			return nil, err
+		}
+		return stream, nil
+	case <-s.shutdownCh:
+		return nil, s.shutdownErr
+	}
+}
+
+// Close is used to close the session and all streams.
+// Attempts to send a GoAway before closing the connection.
+func (s *Session) Close() error {
+	s.shutdownLock.Lock()
+	defer s.shutdownLock.Unlock()
+
+	if s.shutdown {
+		return nil
+	}
+	s.shutdown = true
+	if s.shutdownErr == nil {
+		s.shutdownErr = ErrSessionShutdown
+	}
+	close(s.shutdownCh)
+	s.conn.Close()
+	<-s.recvDoneCh
+
+	s.streamLock.Lock()
+	defer s.streamLock.Unlock()
+	for _, stream := range s.streams {
+		stream.forceClose()
+	}
+	return nil
+}
+
+// exitErr is used to handle an error that is causing the
+// session to terminate.
+func (s *Session) exitErr(err error) {
+	s.shutdownLock.Lock()
+	if s.shutdownErr == nil {
+		s.shutdownErr = err
+	}
+	s.shutdownLock.Unlock()
+	s.Close()
+}
+
+// GoAway can be used to prevent accepting further
+// connections. It does not close the underlying conn.
+func (s *Session) GoAway() error {
+	return s.waitForSend(s.goAway(goAwayNormal), nil)
+}
+
+// goAway is used to send a goAway message
+func (s *Session) goAway(reason uint32) header {
+	atomic.SwapInt32(&s.localGoAway, 1)
+	hdr := header(make([]byte, headerSize))
+	hdr.encode(typeGoAway, 0, 0, reason)
+	return hdr
+}
+
+// Ping is used to measure the RTT response time
+func (s *Session) Ping() (time.Duration, error) {
+	// Get a channel for the ping
+	ch := make(chan struct{})
+
+	// Get a new ping id, mark as pending
+	s.pingLock.Lock()
+	id := s.pingID
+	s.pingID++
+	s.pings[id] = ch
+	s.pingLock.Unlock()
+
+	// Send the ping request
+	hdr := header(make([]byte, headerSize))
+	hdr.encode(typePing, flagSYN, 0, id)
+	if err := s.waitForSend(hdr, nil); err != nil {
+		return 0, err
+	}
+
+	// Wait for a response
+	start := time.Now()
+	select {
+	case <-ch:
+	case <-time.After(s.config.ConnectionWriteTimeout):
+		s.pingLock.Lock()
+		delete(s.pings, id) // Ignore it if a response comes later.
+		s.pingLock.Unlock()
+		return 0, ErrTimeout
+	case <-s.shutdownCh:
+		return 0, ErrSessionShutdown
+	}
+
+	// Compute the RTT
+	return time.Now().Sub(start), nil
+}
+
+// keepalive is a long running goroutine that periodically does
+// a ping to keep the connection alive.
+func (s *Session) keepalive() {
+	for {
+		select {
+		case <-time.After(s.config.KeepAliveInterval):
+			_, err := s.Ping()
+			if err != nil {
+				s.logger.Printf("[ERR] yamux: keepalive failed: %v", err)
+				s.exitErr(ErrKeepAliveTimeout)
+				return
+			}
+		case <-s.shutdownCh:
+			return
+		}
+	}
+}
+
+// waitForSendErr waits to send a header, checking for a potential shutdown
+func (s *Session) waitForSend(hdr header, body io.Reader) error {
+	errCh := make(chan error, 1)
+	return s.waitForSendErr(hdr, body, errCh)
+}
+
+// waitForSendErr waits to send a header with optional data, checking for a
+// potential shutdown. Since there's the expectation that sends can happen
+// in a timely manner, we enforce the connection write timeout here.
+func (s *Session) waitForSendErr(hdr header, body io.Reader, errCh chan error) error {
+	t := timerPool.Get()
+	timer := t.(*time.Timer)
+	timer.Reset(s.config.ConnectionWriteTimeout)
+	defer func() {
+		timer.Stop()
+		select {
+		case <-timer.C:
+		default:
+		}
+		timerPool.Put(t)
+	}()
+
+	ready := sendReady{Hdr: hdr, Body: body, Err: errCh}
+	select {
+	case s.sendCh <- ready:
+	case <-s.shutdownCh:
+		return ErrSessionShutdown
+	case <-timer.C:
+		return ErrConnectionWriteTimeout
+	}
+
+	select {
+	case err := <-errCh:
+		return err
+	case <-s.shutdownCh:
+		return ErrSessionShutdown
+	case <-timer.C:
+		return ErrConnectionWriteTimeout
+	}
+}
+
+// sendNoWait does a send without waiting. Since there's the expectation that
+// the send happens right here, we enforce the connection write timeout if we
+// can't queue the header to be sent.
+func (s *Session) sendNoWait(hdr header) error {
+	t := timerPool.Get()
+	timer := t.(*time.Timer)
+	timer.Reset(s.config.ConnectionWriteTimeout)
+	defer func() {
+		timer.Stop()
+		select {
+		case <-timer.C:
+		default:
+		}
+		timerPool.Put(t)
+	}()
+
+	select {
+	case s.sendCh <- sendReady{Hdr: hdr}:
+		return nil
+	case <-s.shutdownCh:
+		return ErrSessionShutdown
+	case <-timer.C:
+		return ErrConnectionWriteTimeout
+	}
+}
+
+// send is a long running goroutine that sends data
+func (s *Session) send() {
+	for {
+		select {
+		case ready := <-s.sendCh:
+			// Send a header if ready
+			if ready.Hdr != nil {
+				sent := 0
+				for sent < len(ready.Hdr) {
+					n, err := s.conn.Write(ready.Hdr[sent:])
+					if err != nil {
+						s.logger.Printf("[ERR] yamux: Failed to write header: %v", err)
+						asyncSendErr(ready.Err, err)
+						s.exitErr(err)
+						return
+					}
+					sent += n
+				}
+			}
+
+			// Send data from a body if given
+			if ready.Body != nil {
+				_, err := io.Copy(s.conn, ready.Body)
+				if err != nil {
+					s.logger.Printf("[ERR] yamux: Failed to write body: %v", err)
+					asyncSendErr(ready.Err, err)
+					s.exitErr(err)
+					return
+				}
+			}
+
+			// No error, successful send
+			asyncSendErr(ready.Err, nil)
+		case <-s.shutdownCh:
+			return
+		}
+	}
+}
+
+// recv is a long running goroutine that accepts new data
+func (s *Session) recv() {
+	if err := s.recvLoop(); err != nil {
+		s.exitErr(err)
+	}
+}
+
+// Ensure that the index of the handler (typeData/typeWindowUpdate/etc) matches the message type
+var (
+	handlers = []func(*Session, header) error{
+		typeData:         (*Session).handleStreamMessage,
+		typeWindowUpdate: (*Session).handleStreamMessage,
+		typePing:         (*Session).handlePing,
+		typeGoAway:       (*Session).handleGoAway,
+	}
+)
+
+// recvLoop continues to receive data until a fatal error is encountered
+func (s *Session) recvLoop() error {
+	defer close(s.recvDoneCh)
+	hdr := header(make([]byte, headerSize))
+	for {
+		// Read the header
+		if _, err := io.ReadFull(s.bufRead, hdr); err != nil {
+			if err != io.EOF && !strings.Contains(err.Error(), "closed") && !strings.Contains(err.Error(), "reset by peer") {
+				s.logger.Printf("[ERR] yamux: Failed to read header: %v", err)
+			}
+			return err
+		}
+
+		// Verify the version
+		if hdr.Version() != protoVersion {
+			s.logger.Printf("[ERR] yamux: Invalid protocol version: %d", hdr.Version())
+			return ErrInvalidVersion
+		}
+
+		mt := hdr.MsgType()
+		if mt < typeData || mt > typeGoAway {
+			return ErrInvalidMsgType
+		}
+
+		if err := handlers[mt](s, hdr); err != nil {
+			return err
+		}
+	}
+}
+
+// handleStreamMessage handles either a data or window update frame
+func (s *Session) handleStreamMessage(hdr header) error {
+	// Check for a new stream creation
+	id := hdr.StreamID()
+	flags := hdr.Flags()
+	if flags&flagSYN == flagSYN {
+		if err := s.incomingStream(id); err != nil {
+			return err
+		}
+	}
+
+	// Get the stream
+	s.streamLock.Lock()
+	stream := s.streams[id]
+	s.streamLock.Unlock()
+
+	// If we do not have a stream, likely we sent a RST
+	if stream == nil {
+		// Drain any data on the wire
+		if hdr.MsgType() == typeData && hdr.Length() > 0 {
+			s.logger.Printf("[WARN] yamux: Discarding data for stream: %d", id)
+			if _, err := io.CopyN(ioutil.Discard, s.bufRead, int64(hdr.Length())); err != nil {
+				s.logger.Printf("[ERR] yamux: Failed to discard data: %v", err)
+				return nil
+			}
+		} else {
+			s.logger.Printf("[WARN] yamux: frame for missing stream: %v", hdr)
+		}
+		return nil
+	}
+
+	// Check if this is a window update
+	if hdr.MsgType() == typeWindowUpdate {
+		if err := stream.incrSendWindow(hdr, flags); err != nil {
+			if sendErr := s.sendNoWait(s.goAway(goAwayProtoErr)); sendErr != nil {
+				s.logger.Printf("[WARN] yamux: failed to send go away: %v", sendErr)
+			}
+			return err
+		}
+		return nil
+	}
+
+	// Read the new data
+	if err := stream.readData(hdr, flags, s.bufRead); err != nil {
+		if sendErr := s.sendNoWait(s.goAway(goAwayProtoErr)); sendErr != nil {
+			s.logger.Printf("[WARN] yamux: failed to send go away: %v", sendErr)
+		}
+		return err
+	}
+	return nil
+}
+
+// handlePing is invokde for a typePing frame
+func (s *Session) handlePing(hdr header) error {
+	flags := hdr.Flags()
+	pingID := hdr.Length()
+
+	// Check if this is a query, respond back in a separate context so we
+	// don't interfere with the receiving thread blocking for the write.
+	if flags&flagSYN == flagSYN {
+		go func() {
+			hdr := header(make([]byte, headerSize))
+			hdr.encode(typePing, flagACK, 0, pingID)
+			if err := s.sendNoWait(hdr); err != nil {
+				s.logger.Printf("[WARN] yamux: failed to send ping reply: %v", err)
+			}
+		}()
+		return nil
+	}
+
+	// Handle a response
+	s.pingLock.Lock()
+	ch := s.pings[pingID]
+	if ch != nil {
+		delete(s.pings, pingID)
+		close(ch)
+	}
+	s.pingLock.Unlock()
+	return nil
+}
+
+// handleGoAway is invokde for a typeGoAway frame
+func (s *Session) handleGoAway(hdr header) error {
+	code := hdr.Length()
+	switch code {
+	case goAwayNormal:
+		atomic.SwapInt32(&s.remoteGoAway, 1)
+	case goAwayProtoErr:
+		s.logger.Printf("[ERR] yamux: received protocol error go away")
+		return fmt.Errorf("yamux protocol error")
+	case goAwayInternalErr:
+		s.logger.Printf("[ERR] yamux: received internal error go away")
+		return fmt.Errorf("remote yamux internal error")
+	default:
+		s.logger.Printf("[ERR] yamux: received unexpected go away")
+		return fmt.Errorf("unexpected go away received")
+	}
+	return nil
+}
+
+// incomingStream is used to create a new incoming stream
+func (s *Session) incomingStream(id uint32) error {
+	// Reject immediately if we are doing a go away
+	if atomic.LoadInt32(&s.localGoAway) == 1 {
+		hdr := header(make([]byte, headerSize))
+		hdr.encode(typeWindowUpdate, flagRST, id, 0)
+		return s.sendNoWait(hdr)
+	}
+
+	// Allocate a new stream
+	stream := newStream(s, id, streamSYNReceived)
+
+	s.streamLock.Lock()
+	defer s.streamLock.Unlock()
+
+	// Check if stream already exists
+	if _, ok := s.streams[id]; ok {
+		s.logger.Printf("[ERR] yamux: duplicate stream declared")
+		if sendErr := s.sendNoWait(s.goAway(goAwayProtoErr)); sendErr != nil {
+			s.logger.Printf("[WARN] yamux: failed to send go away: %v", sendErr)
+		}
+		return ErrDuplicateStream
+	}
+
+	// Register the stream
+	s.streams[id] = stream
+
+	// Check if we've exceeded the backlog
+	select {
+	case s.acceptCh <- stream:
+		return nil
+	default:
+		// Backlog exceeded! RST the stream
+		s.logger.Printf("[WARN] yamux: backlog exceeded, forcing connection reset")
+		delete(s.streams, id)
+		stream.sendHdr.encode(typeWindowUpdate, flagRST, id, 0)
+		return s.sendNoWait(stream.sendHdr)
+	}
+}
+
+// closeStream is used to close a stream once both sides have
+// issued a close. If there was an in-flight SYN and the stream
+// was not yet established, then this will give the credit back.
+func (s *Session) closeStream(id uint32) {
+	s.streamLock.Lock()
+	if _, ok := s.inflight[id]; ok {
+		select {
+		case <-s.synCh:
+		default:
+			s.logger.Printf("[ERR] yamux: SYN tracking out of sync")
+		}
+	}
+	delete(s.streams, id)
+	s.streamLock.Unlock()
+}
+
+// establishStream is used to mark a stream that was in the
+// SYN Sent state as established.
+func (s *Session) establishStream(id uint32) {
+	s.streamLock.Lock()
+	if _, ok := s.inflight[id]; ok {
+		delete(s.inflight, id)
+	} else {
+		s.logger.Printf("[ERR] yamux: established stream without inflight SYN (no tracking entry)")
+	}
+	select {
+	case <-s.synCh:
+	default:
+		s.logger.Printf("[ERR] yamux: established stream without inflight SYN (didn't have semaphore)")
+	}
+	s.streamLock.Unlock()
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/stream.go b/vendor/github.com/whyrusleeping/yamux/stream.go
new file mode 100644
index 000000000..fb7d99d4b
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/stream.go
@@ -0,0 +1,502 @@
+package yamux
+
+import (
+	"bytes"
+	"io"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+type streamState int
+
+const (
+	streamInit streamState = iota
+	streamSYNSent
+	streamSYNReceived
+	streamEstablished
+	streamLocalClose
+	streamRemoteClose
+	streamClosed
+	streamReset
+)
+
+// Stream is used to represent a logical stream
+// within a session.
+type Stream struct {
+	recvWindow uint32
+	sendWindow uint32
+
+	id      uint32
+	session *Session
+
+	state     streamState
+	stateLock sync.Mutex
+
+	recvBuf  *bytes.Buffer
+	recvLock sync.Mutex
+
+	controlHdr     header
+	controlErr     chan error
+	controlHdrLock sync.Mutex
+
+	sendHdr  header
+	sendErr  chan error
+	sendLock sync.Mutex
+
+	recvNotifyCh chan struct{}
+	sendNotifyCh chan struct{}
+
+	readDeadline  atomic.Value // time.Time
+	writeDeadline atomic.Value // time.Time
+}
+
+// newStream is used to construct a new stream within
+// a given session for an ID
+func newStream(session *Session, id uint32, state streamState) *Stream {
+	s := &Stream{
+		id:           id,
+		session:      session,
+		state:        state,
+		controlHdr:   header(make([]byte, headerSize)),
+		controlErr:   make(chan error, 1),
+		sendHdr:      header(make([]byte, headerSize)),
+		sendErr:      make(chan error, 1),
+		recvWindow:   initialStreamWindow,
+		sendWindow:   initialStreamWindow,
+		recvNotifyCh: make(chan struct{}, 1),
+		sendNotifyCh: make(chan struct{}, 1),
+	}
+	s.readDeadline.Store(time.Time{})
+	s.writeDeadline.Store(time.Time{})
+	return s
+}
+
+// Session returns the associated stream session
+func (s *Stream) Session() *Session {
+	return s.session
+}
+
+// StreamID returns the ID of this stream
+func (s *Stream) StreamID() uint32 {
+	return s.id
+}
+
+// Read is used to read from the stream
+func (s *Stream) Read(b []byte) (n int, err error) {
+	defer asyncNotify(s.recvNotifyCh)
+START:
+	s.stateLock.Lock()
+	switch s.state {
+	case streamRemoteClose:
+		fallthrough
+	case streamClosed:
+		s.recvLock.Lock()
+		if s.recvBuf == nil || s.recvBuf.Len() == 0 {
+			s.recvLock.Unlock()
+			s.stateLock.Unlock()
+			return 0, io.EOF
+		}
+		s.recvLock.Unlock()
+	case streamReset:
+		s.stateLock.Unlock()
+		return 0, ErrConnectionReset
+	}
+	s.stateLock.Unlock()
+
+	// If there is no data available, block
+	s.recvLock.Lock()
+	if s.recvBuf == nil || s.recvBuf.Len() == 0 {
+		s.recvLock.Unlock()
+		goto WAIT
+	}
+
+	// Read any bytes
+	n, _ = s.recvBuf.Read(b)
+	s.recvLock.Unlock()
+
+	// Send a window update potentially
+	err = s.sendWindowUpdate()
+	return n, err
+
+WAIT:
+	var timeout <-chan time.Time
+	var timer *time.Timer
+	readDeadline := s.readDeadline.Load().(time.Time)
+	if !readDeadline.IsZero() {
+		delay := readDeadline.Sub(time.Now())
+		timer = time.NewTimer(delay)
+		timeout = timer.C
+	}
+	select {
+	case <-s.recvNotifyCh:
+		if timer != nil {
+			timer.Stop()
+		}
+		goto START
+	case <-timeout:
+		return 0, ErrTimeout
+	}
+}
+
+// Write is used to write to the stream
+func (s *Stream) Write(b []byte) (n int, err error) {
+	s.sendLock.Lock()
+	defer s.sendLock.Unlock()
+	total := 0
+	for total < len(b) {
+		n, err := s.write(b[total:])
+		total += n
+		if err != nil {
+			return total, err
+		}
+	}
+	return total, nil
+}
+
+// write is used to write to the stream, may return on
+// a short write.
+func (s *Stream) write(b []byte) (n int, err error) {
+	var flags uint16
+	var max uint32
+	var body io.Reader
+START:
+	s.stateLock.Lock()
+	switch s.state {
+	case streamLocalClose:
+		fallthrough
+	case streamClosed:
+		s.stateLock.Unlock()
+		return 0, ErrStreamClosed
+	case streamReset:
+		s.stateLock.Unlock()
+		return 0, ErrConnectionReset
+	}
+	s.stateLock.Unlock()
+
+	// If there is no data available, block
+	window := atomic.LoadUint32(&s.sendWindow)
+	if window == 0 {
+		goto WAIT
+	}
+
+	// Determine the flags if any
+	flags = s.sendFlags()
+
+	// Send up to our send window
+	max = min(window, uint32(len(b)))
+	body = bytes.NewReader(b[:max])
+
+	// Send the header
+	s.sendHdr.encode(typeData, flags, s.id, max)
+	if err = s.session.waitForSendErr(s.sendHdr, body, s.sendErr); err != nil {
+		return 0, err
+	}
+
+	// Reduce our send window
+	atomic.AddUint32(&s.sendWindow, ^uint32(max-1))
+
+	// Unlock
+	return int(max), err
+
+WAIT:
+	var timeout <-chan time.Time
+	writeDeadline := s.writeDeadline.Load().(time.Time)
+	if !writeDeadline.IsZero() {
+		delay := writeDeadline.Sub(time.Now())
+		timeout = time.After(delay)
+	}
+	select {
+	case <-s.sendNotifyCh:
+		goto START
+	case <-timeout:
+		return 0, ErrTimeout
+	}
+	return 0, nil
+}
+
+// sendFlags determines any flags that are appropriate
+// based on the current stream state
+func (s *Stream) sendFlags() uint16 {
+	s.stateLock.Lock()
+	defer s.stateLock.Unlock()
+	var flags uint16
+	switch s.state {
+	case streamInit:
+		flags |= flagSYN
+		s.state = streamSYNSent
+	case streamSYNReceived:
+		flags |= flagACK
+		s.state = streamEstablished
+	}
+	return flags
+}
+
+// sendWindowUpdate potentially sends a window update enabling
+// further writes to take place. Must be invoked with the lock.
+func (s *Stream) sendWindowUpdate() error {
+	s.controlHdrLock.Lock()
+	defer s.controlHdrLock.Unlock()
+
+	// Determine the delta update
+	max := s.session.config.MaxStreamWindowSize
+	var bufLen uint32
+	s.recvLock.Lock()
+	if s.recvBuf != nil {
+		bufLen = uint32(s.recvBuf.Len())
+	}
+	delta := (max - bufLen) - s.recvWindow
+
+	// Determine the flags if any
+	flags := s.sendFlags()
+
+	// Check if we can omit the update
+	if delta < (max/2) && flags == 0 {
+		s.recvLock.Unlock()
+		return nil
+	}
+
+	// Update our window
+	s.recvWindow += delta
+	s.recvLock.Unlock()
+
+	// Send the header
+	s.controlHdr.encode(typeWindowUpdate, flags, s.id, delta)
+	if err := s.session.waitForSendErr(s.controlHdr, nil, s.controlErr); err != nil {
+		return err
+	}
+	return nil
+}
+
+// sendClose is used to send a FIN
+func (s *Stream) sendClose() error {
+	s.controlHdrLock.Lock()
+	defer s.controlHdrLock.Unlock()
+
+	flags := s.sendFlags()
+	flags |= flagFIN
+	s.controlHdr.encode(typeWindowUpdate, flags, s.id, 0)
+	return s.session.waitForSendErr(s.controlHdr, nil, s.controlErr)
+}
+
+// sendReset is used to send a RST
+func (s *Stream) sendReset() error {
+	s.controlHdrLock.Lock()
+	defer s.controlHdrLock.Unlock()
+
+	s.controlHdr.encode(typeWindowUpdate, flagRST, s.id, 0)
+	return s.session.waitForSendErr(s.controlHdr, nil, s.controlErr)
+}
+
+// Reset resets the stream (forcibly closes the stream)
+func (s *Stream) Reset() error {
+	s.stateLock.Lock()
+	switch s.state {
+	case streamClosed, streamReset:
+		s.stateLock.Unlock()
+		return nil
+	case streamSYNSent, streamSYNReceived, streamEstablished:
+	case streamLocalClose, streamRemoteClose:
+	default:
+		panic("unhandled state")
+	}
+	s.state = streamReset
+	s.stateLock.Unlock()
+
+	err := s.sendReset()
+	s.notifyWaiting()
+	s.session.closeStream(s.id)
+
+	return err
+}
+
+// Close is used to close the stream
+func (s *Stream) Close() error {
+	closeStream := false
+	s.stateLock.Lock()
+	switch s.state {
+	// Opened means we need to signal a close
+	case streamSYNSent:
+		fallthrough
+	case streamSYNReceived:
+		fallthrough
+	case streamEstablished:
+		s.state = streamLocalClose
+		goto SEND_CLOSE
+
+	case streamLocalClose:
+	case streamRemoteClose:
+		s.state = streamClosed
+		closeStream = true
+		goto SEND_CLOSE
+
+	case streamClosed:
+	case streamReset:
+	default:
+		panic("unhandled state")
+	}
+	s.stateLock.Unlock()
+	return nil
+SEND_CLOSE:
+	s.stateLock.Unlock()
+	err := s.sendClose()
+	s.notifyWaiting()
+	if closeStream {
+		s.session.closeStream(s.id)
+	}
+	return err
+}
+
+// forceClose is used for when the session is exiting
+func (s *Stream) forceClose() {
+	s.stateLock.Lock()
+	switch s.state {
+	case streamClosed:
+		// Already successfully closed. It just hasn't been removed from
+		// the list of streams yet.
+	default:
+		s.state = streamReset
+	}
+	s.stateLock.Unlock()
+	s.notifyWaiting()
+}
+
+// processFlags is used to update the state of the stream
+// based on set flags, if any. Lock must be held
+func (s *Stream) processFlags(flags uint16) error {
+	// Close the stream without holding the state lock
+	closeStream := false
+	defer func() {
+		if closeStream {
+			s.session.closeStream(s.id)
+		}
+	}()
+
+	s.stateLock.Lock()
+	defer s.stateLock.Unlock()
+	if flags&flagACK == flagACK {
+		if s.state == streamSYNSent {
+			s.state = streamEstablished
+		}
+		s.session.establishStream(s.id)
+	}
+	if flags&flagFIN == flagFIN {
+		switch s.state {
+		case streamSYNSent:
+			fallthrough
+		case streamSYNReceived:
+			fallthrough
+		case streamEstablished:
+			s.state = streamRemoteClose
+			s.notifyWaiting()
+		case streamLocalClose:
+			s.state = streamClosed
+			closeStream = true
+			s.notifyWaiting()
+		default:
+			s.session.logger.Printf("[ERR] yamux: unexpected FIN flag in state %d", s.state)
+			return ErrUnexpectedFlag
+		}
+	}
+	if flags&flagRST == flagRST {
+		s.state = streamReset
+		closeStream = true
+		s.notifyWaiting()
+	}
+	return nil
+}
+
+// notifyWaiting notifies all the waiting channels
+func (s *Stream) notifyWaiting() {
+	asyncNotify(s.recvNotifyCh)
+	asyncNotify(s.sendNotifyCh)
+}
+
+// incrSendWindow updates the size of our send window
+func (s *Stream) incrSendWindow(hdr header, flags uint16) error {
+	if err := s.processFlags(flags); err != nil {
+		return err
+	}
+
+	// Increase window, unblock a sender
+	atomic.AddUint32(&s.sendWindow, hdr.Length())
+	asyncNotify(s.sendNotifyCh)
+	return nil
+}
+
+// readData is used to handle a data frame
+func (s *Stream) readData(hdr header, flags uint16, conn io.Reader) error {
+	if err := s.processFlags(flags); err != nil {
+		return err
+	}
+
+	// Check that our recv window is not exceeded
+	length := hdr.Length()
+	if length == 0 {
+		return nil
+	}
+
+	// Wrap in a limited reader
+	conn = &io.LimitedReader{R: conn, N: int64(length)}
+
+	// Copy into buffer
+	s.recvLock.Lock()
+
+	if length > s.recvWindow {
+		s.session.logger.Printf("[ERR] yamux: receive window exceeded (stream: %d, remain: %d, recv: %d)", s.id, s.recvWindow, length)
+		return ErrRecvWindowExceeded
+	}
+
+	if s.recvBuf == nil {
+		// Allocate the receive buffer just-in-time to fit the full data frame.
+		// This way we can read in the whole packet without further allocations.
+		s.recvBuf = bytes.NewBuffer(make([]byte, 0, length))
+	}
+	if _, err := io.Copy(s.recvBuf, conn); err != nil {
+		s.session.logger.Printf("[ERR] yamux: Failed to read stream data: %v", err)
+		s.recvLock.Unlock()
+		return err
+	}
+
+	// Decrement the receive window
+	s.recvWindow -= length
+	s.recvLock.Unlock()
+
+	// Unblock any readers
+	asyncNotify(s.recvNotifyCh)
+	return nil
+}
+
+// SetDeadline sets the read and write deadlines
+func (s *Stream) SetDeadline(t time.Time) error {
+	if err := s.SetReadDeadline(t); err != nil {
+		return err
+	}
+	if err := s.SetWriteDeadline(t); err != nil {
+		return err
+	}
+	return nil
+}
+
+// SetReadDeadline sets the deadline for future Read calls.
+func (s *Stream) SetReadDeadline(t time.Time) error {
+	s.readDeadline.Store(t)
+	return nil
+}
+
+// SetWriteDeadline sets the deadline for future Write calls
+func (s *Stream) SetWriteDeadline(t time.Time) error {
+	s.writeDeadline.Store(t)
+	return nil
+}
+
+// Shrink is used to compact the amount of buffers utilized
+// This is useful when using Yamux in a connection pool to reduce
+// the idle memory utilization.
+func (s *Stream) Shrink() {
+	s.recvLock.Lock()
+	if s.recvBuf != nil && s.recvBuf.Len() == 0 {
+		s.recvBuf = nil
+	}
+	s.recvLock.Unlock()
+}
diff --git a/vendor/github.com/whyrusleeping/yamux/util.go b/vendor/github.com/whyrusleeping/yamux/util.go
new file mode 100644
index 000000000..8a73e9249
--- /dev/null
+++ b/vendor/github.com/whyrusleeping/yamux/util.go
@@ -0,0 +1,43 @@
+package yamux
+
+import (
+	"sync"
+	"time"
+)
+
+var (
+	timerPool = &sync.Pool{
+		New: func() interface{} {
+			timer := time.NewTimer(time.Hour * 1e6)
+			timer.Stop()
+			return timer
+		},
+	}
+)
+
+// asyncSendErr is used to try an async send of an error
+func asyncSendErr(ch chan error, err error) {
+	if ch == nil {
+		return
+	}
+	select {
+	case ch <- err:
+	default:
+	}
+}
+
+// asyncNotify is used to signal a waiting goroutine
+func asyncNotify(ch chan struct{}) {
+	select {
+	case ch <- struct{}{}:
+	default:
+	}
+}
+
+// min computes the minimum of two values
+func min(a, b uint32) uint32 {
+	if a < b {
+		return a
+	}
+	return b
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s.go b/vendor/golang.org/x/crypto/blake2s/blake2s.go
new file mode 100644
index 000000000..ae0dc922b
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s.go
@@ -0,0 +1,187 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package blake2s implements the BLAKE2s hash algorithm defined by RFC 7693
+// and the extendable output function (XOF) BLAKE2Xs.
+//
+// For a detailed specification of BLAKE2s see https://blake2.net/blake2.pdf
+// and for BLAKE2Xs see https://blake2.net/blake2x.pdf
+//
+// If you aren't sure which function you need, use BLAKE2s (Sum256 or New256).
+// If you need a secret-key MAC (message authentication code), use the New256
+// function with a non-nil key.
+//
+// BLAKE2X is a construction to compute hash values larger than 32 bytes. It
+// can produce hash values between 0 and 65535 bytes.
+package blake2s // import "golang.org/x/crypto/blake2s"
+
+import (
+	"encoding/binary"
+	"errors"
+	"hash"
+)
+
+const (
+	// The blocksize of BLAKE2s in bytes.
+	BlockSize = 64
+
+	// The hash size of BLAKE2s-256 in bytes.
+	Size = 32
+
+	// The hash size of BLAKE2s-128 in bytes.
+	Size128 = 16
+)
+
+var errKeySize = errors.New("blake2s: invalid key size")
+
+var iv = [8]uint32{
+	0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+	0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+}
+
+// Sum256 returns the BLAKE2s-256 checksum of the data.
+func Sum256(data []byte) [Size]byte {
+	var sum [Size]byte
+	checkSum(&sum, Size, data)
+	return sum
+}
+
+// New256 returns a new hash.Hash computing the BLAKE2s-256 checksum. A non-nil
+// key turns the hash into a MAC. The key must between zero and 32 bytes long.
+func New256(key []byte) (hash.Hash, error) { return newDigest(Size, key) }
+
+// New128 returns a new hash.Hash computing the BLAKE2s-128 checksum given a
+// non-empty key. Note that a 128-bit digest is too small to be secure as a
+// cryptographic hash and should only be used as a MAC, thus the key argument
+// is not optional.
+func New128(key []byte) (hash.Hash, error) {
+	if len(key) == 0 {
+		return nil, errors.New("blake2s: a key is required for a 128-bit hash")
+	}
+	return newDigest(Size128, key)
+}
+
+func newDigest(hashSize int, key []byte) (*digest, error) {
+	if len(key) > Size {
+		return nil, errKeySize
+	}
+	d := &digest{
+		size:   hashSize,
+		keyLen: len(key),
+	}
+	copy(d.key[:], key)
+	d.Reset()
+	return d, nil
+}
+
+func checkSum(sum *[Size]byte, hashSize int, data []byte) {
+	var (
+		h [8]uint32
+		c [2]uint32
+	)
+
+	h = iv
+	h[0] ^= uint32(hashSize) | (1 << 16) | (1 << 24)
+
+	if length := len(data); length > BlockSize {
+		n := length &^ (BlockSize - 1)
+		if length == n {
+			n -= BlockSize
+		}
+		hashBlocks(&h, &c, 0, data[:n])
+		data = data[n:]
+	}
+
+	var block [BlockSize]byte
+	offset := copy(block[:], data)
+	remaining := uint32(BlockSize - offset)
+
+	if c[0] < remaining {
+		c[1]--
+	}
+	c[0] -= remaining
+
+	hashBlocks(&h, &c, 0xFFFFFFFF, block[:])
+
+	for i, v := range h {
+		binary.LittleEndian.PutUint32(sum[4*i:], v)
+	}
+}
+
+type digest struct {
+	h      [8]uint32
+	c      [2]uint32
+	size   int
+	block  [BlockSize]byte
+	offset int
+
+	key    [BlockSize]byte
+	keyLen int
+}
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Size() int { return d.size }
+
+func (d *digest) Reset() {
+	d.h = iv
+	d.h[0] ^= uint32(d.size) | (uint32(d.keyLen) << 8) | (1 << 16) | (1 << 24)
+	d.offset, d.c[0], d.c[1] = 0, 0, 0
+	if d.keyLen > 0 {
+		d.block = d.key
+		d.offset = BlockSize
+	}
+}
+
+func (d *digest) Write(p []byte) (n int, err error) {
+	n = len(p)
+
+	if d.offset > 0 {
+		remaining := BlockSize - d.offset
+		if n <= remaining {
+			d.offset += copy(d.block[d.offset:], p)
+			return
+		}
+		copy(d.block[d.offset:], p[:remaining])
+		hashBlocks(&d.h, &d.c, 0, d.block[:])
+		d.offset = 0
+		p = p[remaining:]
+	}
+
+	if length := len(p); length > BlockSize {
+		nn := length &^ (BlockSize - 1)
+		if length == nn {
+			nn -= BlockSize
+		}
+		hashBlocks(&d.h, &d.c, 0, p[:nn])
+		p = p[nn:]
+	}
+
+	d.offset += copy(d.block[:], p)
+	return
+}
+
+func (d *digest) Sum(sum []byte) []byte {
+	var hash [Size]byte
+	d.finalize(&hash)
+	return append(sum, hash[:d.size]...)
+}
+
+func (d *digest) finalize(hash *[Size]byte) {
+	var block [BlockSize]byte
+	h := d.h
+	c := d.c
+
+	copy(block[:], d.block[:d.offset])
+	remaining := uint32(BlockSize - d.offset)
+	if c[0] < remaining {
+		c[1]--
+	}
+	c[0] -= remaining
+
+	hashBlocks(&h, &c, 0xFFFFFFFF, block[:])
+	for i, v := range h {
+		binary.LittleEndian.PutUint32(hash[4*i:], v)
+	}
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_386.go b/vendor/golang.org/x/crypto/blake2s/blake2s_386.go
new file mode 100644
index 000000000..45ae54614
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_386.go
@@ -0,0 +1,35 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build 386,!gccgo,!appengine
+
+package blake2s
+
+var (
+	useSSE4  = false
+	useSSSE3 = supportSSSE3()
+	useSSE2  = supportSSE2()
+)
+
+//go:noescape
+func supportSSE2() bool
+
+//go:noescape
+func supportSSSE3() bool
+
+//go:noescape
+func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+
+//go:noescape
+func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+
+func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
+	if useSSSE3 {
+		hashBlocksSSSE3(h, c, flag, blocks)
+	} else if useSSE2 {
+		hashBlocksSSE2(h, c, flag, blocks)
+	} else {
+		hashBlocksGeneric(h, c, flag, blocks)
+	}
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_386.s b/vendor/golang.org/x/crypto/blake2s/blake2s_386.s
new file mode 100644
index 000000000..0bb65c70f
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_386.s
@@ -0,0 +1,460 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build 386,!gccgo,!appengine
+
+#include "textflag.h"
+
+DATA iv0<>+0x00(SB)/4, $0x6a09e667
+DATA iv0<>+0x04(SB)/4, $0xbb67ae85
+DATA iv0<>+0x08(SB)/4, $0x3c6ef372
+DATA iv0<>+0x0c(SB)/4, $0xa54ff53a
+GLOBL iv0<>(SB), (NOPTR+RODATA), $16
+
+DATA iv1<>+0x00(SB)/4, $0x510e527f
+DATA iv1<>+0x04(SB)/4, $0x9b05688c
+DATA iv1<>+0x08(SB)/4, $0x1f83d9ab
+DATA iv1<>+0x0c(SB)/4, $0x5be0cd19
+GLOBL iv1<>(SB), (NOPTR+RODATA), $16
+
+DATA rol16<>+0x00(SB)/8, $0x0504070601000302
+DATA rol16<>+0x08(SB)/8, $0x0D0C0F0E09080B0A
+GLOBL rol16<>(SB), (NOPTR+RODATA), $16
+
+DATA rol8<>+0x00(SB)/8, $0x0407060500030201
+DATA rol8<>+0x08(SB)/8, $0x0C0F0E0D080B0A09
+GLOBL rol8<>(SB), (NOPTR+RODATA), $16
+
+DATA counter<>+0x00(SB)/8, $0x40
+DATA counter<>+0x08(SB)/8, $0x0
+GLOBL counter<>(SB), (NOPTR+RODATA), $16
+
+#define ROTL_SSE2(n, t, v) \
+	MOVO  v, t;       \
+	PSLLL $n, t;      \
+	PSRLL $(32-n), v; \
+	PXOR  t, v
+
+#define ROTL_SSSE3(c, v) \
+	PSHUFB c, v
+
+#define ROUND_SSE2(v0, v1, v2, v3, m0, m1, m2, m3, t) \
+	PADDL  m0, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(16, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m1, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(24, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v1, v1; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v3, v3; \
+	PADDL  m2, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(16, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m3, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(24, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v3, v3; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v1, v1
+
+#define ROUND_SSSE3(v0, v1, v2, v3, m0, m1, m2, m3, t, c16, c8) \
+	PADDL  m0, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c16, v3);  \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m1, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c8, v3);   \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v1, v1; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v3, v3; \
+	PADDL  m2, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c16, v3);  \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m3, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c8, v3);   \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v3, v3; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v1, v1
+
+#define PRECOMPUTE(dst, off, src, t) \
+	MOVL 0*4(src), t;          \
+	MOVL t, 0*4+off+0(dst);    \
+	MOVL t, 9*4+off+64(dst);   \
+	MOVL t, 5*4+off+128(dst);  \
+	MOVL t, 14*4+off+192(dst); \
+	MOVL t, 4*4+off+256(dst);  \
+	MOVL t, 2*4+off+320(dst);  \
+	MOVL t, 8*4+off+384(dst);  \
+	MOVL t, 12*4+off+448(dst); \
+	MOVL t, 3*4+off+512(dst);  \
+	MOVL t, 15*4+off+576(dst); \
+	MOVL 1*4(src), t;          \
+	MOVL t, 4*4+off+0(dst);    \
+	MOVL t, 8*4+off+64(dst);   \
+	MOVL t, 14*4+off+128(dst); \
+	MOVL t, 5*4+off+192(dst);  \
+	MOVL t, 12*4+off+256(dst); \
+	MOVL t, 11*4+off+320(dst); \
+	MOVL t, 1*4+off+384(dst);  \
+	MOVL t, 6*4+off+448(dst);  \
+	MOVL t, 10*4+off+512(dst); \
+	MOVL t, 3*4+off+576(dst);  \
+	MOVL 2*4(src), t;          \
+	MOVL t, 1*4+off+0(dst);    \
+	MOVL t, 13*4+off+64(dst);  \
+	MOVL t, 6*4+off+128(dst);  \
+	MOVL t, 8*4+off+192(dst);  \
+	MOVL t, 2*4+off+256(dst);  \
+	MOVL t, 0*4+off+320(dst);  \
+	MOVL t, 14*4+off+384(dst); \
+	MOVL t, 11*4+off+448(dst); \
+	MOVL t, 12*4+off+512(dst); \
+	MOVL t, 4*4+off+576(dst);  \
+	MOVL 3*4(src), t;          \
+	MOVL t, 5*4+off+0(dst);    \
+	MOVL t, 15*4+off+64(dst);  \
+	MOVL t, 9*4+off+128(dst);  \
+	MOVL t, 1*4+off+192(dst);  \
+	MOVL t, 11*4+off+256(dst); \
+	MOVL t, 7*4+off+320(dst);  \
+	MOVL t, 13*4+off+384(dst); \
+	MOVL t, 3*4+off+448(dst);  \
+	MOVL t, 6*4+off+512(dst);  \
+	MOVL t, 10*4+off+576(dst); \
+	MOVL 4*4(src), t;          \
+	MOVL t, 2*4+off+0(dst);    \
+	MOVL t, 1*4+off+64(dst);   \
+	MOVL t, 15*4+off+128(dst); \
+	MOVL t, 10*4+off+192(dst); \
+	MOVL t, 6*4+off+256(dst);  \
+	MOVL t, 8*4+off+320(dst);  \
+	MOVL t, 3*4+off+384(dst);  \
+	MOVL t, 13*4+off+448(dst); \
+	MOVL t, 14*4+off+512(dst); \
+	MOVL t, 5*4+off+576(dst);  \
+	MOVL 5*4(src), t;          \
+	MOVL t, 6*4+off+0(dst);    \
+	MOVL t, 11*4+off+64(dst);  \
+	MOVL t, 2*4+off+128(dst);  \
+	MOVL t, 9*4+off+192(dst);  \
+	MOVL t, 1*4+off+256(dst);  \
+	MOVL t, 13*4+off+320(dst); \
+	MOVL t, 4*4+off+384(dst);  \
+	MOVL t, 8*4+off+448(dst);  \
+	MOVL t, 15*4+off+512(dst); \
+	MOVL t, 7*4+off+576(dst);  \
+	MOVL 6*4(src), t;          \
+	MOVL t, 3*4+off+0(dst);    \
+	MOVL t, 7*4+off+64(dst);   \
+	MOVL t, 13*4+off+128(dst); \
+	MOVL t, 12*4+off+192(dst); \
+	MOVL t, 10*4+off+256(dst); \
+	MOVL t, 1*4+off+320(dst);  \
+	MOVL t, 9*4+off+384(dst);  \
+	MOVL t, 14*4+off+448(dst); \
+	MOVL t, 0*4+off+512(dst);  \
+	MOVL t, 6*4+off+576(dst);  \
+	MOVL 7*4(src), t;          \
+	MOVL t, 7*4+off+0(dst);    \
+	MOVL t, 14*4+off+64(dst);  \
+	MOVL t, 10*4+off+128(dst); \
+	MOVL t, 0*4+off+192(dst);  \
+	MOVL t, 5*4+off+256(dst);  \
+	MOVL t, 9*4+off+320(dst);  \
+	MOVL t, 12*4+off+384(dst); \
+	MOVL t, 1*4+off+448(dst);  \
+	MOVL t, 13*4+off+512(dst); \
+	MOVL t, 2*4+off+576(dst);  \
+	MOVL 8*4(src), t;          \
+	MOVL t, 8*4+off+0(dst);    \
+	MOVL t, 5*4+off+64(dst);   \
+	MOVL t, 4*4+off+128(dst);  \
+	MOVL t, 15*4+off+192(dst); \
+	MOVL t, 14*4+off+256(dst); \
+	MOVL t, 3*4+off+320(dst);  \
+	MOVL t, 11*4+off+384(dst); \
+	MOVL t, 10*4+off+448(dst); \
+	MOVL t, 7*4+off+512(dst);  \
+	MOVL t, 1*4+off+576(dst);  \
+	MOVL 9*4(src), t;          \
+	MOVL t, 12*4+off+0(dst);   \
+	MOVL t, 2*4+off+64(dst);   \
+	MOVL t, 11*4+off+128(dst); \
+	MOVL t, 4*4+off+192(dst);  \
+	MOVL t, 0*4+off+256(dst);  \
+	MOVL t, 15*4+off+320(dst); \
+	MOVL t, 10*4+off+384(dst); \
+	MOVL t, 7*4+off+448(dst);  \
+	MOVL t, 5*4+off+512(dst);  \
+	MOVL t, 9*4+off+576(dst);  \
+	MOVL 10*4(src), t;         \
+	MOVL t, 9*4+off+0(dst);    \
+	MOVL t, 4*4+off+64(dst);   \
+	MOVL t, 8*4+off+128(dst);  \
+	MOVL t, 13*4+off+192(dst); \
+	MOVL t, 3*4+off+256(dst);  \
+	MOVL t, 5*4+off+320(dst);  \
+	MOVL t, 7*4+off+384(dst);  \
+	MOVL t, 15*4+off+448(dst); \
+	MOVL t, 11*4+off+512(dst); \
+	MOVL t, 0*4+off+576(dst);  \
+	MOVL 11*4(src), t;         \
+	MOVL t, 13*4+off+0(dst);   \
+	MOVL t, 10*4+off+64(dst);  \
+	MOVL t, 0*4+off+128(dst);  \
+	MOVL t, 3*4+off+192(dst);  \
+	MOVL t, 9*4+off+256(dst);  \
+	MOVL t, 6*4+off+320(dst);  \
+	MOVL t, 15*4+off+384(dst); \
+	MOVL t, 4*4+off+448(dst);  \
+	MOVL t, 2*4+off+512(dst);  \
+	MOVL t, 12*4+off+576(dst); \
+	MOVL 12*4(src), t;         \
+	MOVL t, 10*4+off+0(dst);   \
+	MOVL t, 12*4+off+64(dst);  \
+	MOVL t, 1*4+off+128(dst);  \
+	MOVL t, 6*4+off+192(dst);  \
+	MOVL t, 13*4+off+256(dst); \
+	MOVL t, 4*4+off+320(dst);  \
+	MOVL t, 0*4+off+384(dst);  \
+	MOVL t, 2*4+off+448(dst);  \
+	MOVL t, 8*4+off+512(dst);  \
+	MOVL t, 14*4+off+576(dst); \
+	MOVL 13*4(src), t;         \
+	MOVL t, 14*4+off+0(dst);   \
+	MOVL t, 3*4+off+64(dst);   \
+	MOVL t, 7*4+off+128(dst);  \
+	MOVL t, 2*4+off+192(dst);  \
+	MOVL t, 15*4+off+256(dst); \
+	MOVL t, 12*4+off+320(dst); \
+	MOVL t, 6*4+off+384(dst);  \
+	MOVL t, 0*4+off+448(dst);  \
+	MOVL t, 9*4+off+512(dst);  \
+	MOVL t, 11*4+off+576(dst); \
+	MOVL 14*4(src), t;         \
+	MOVL t, 11*4+off+0(dst);   \
+	MOVL t, 0*4+off+64(dst);   \
+	MOVL t, 12*4+off+128(dst); \
+	MOVL t, 7*4+off+192(dst);  \
+	MOVL t, 8*4+off+256(dst);  \
+	MOVL t, 14*4+off+320(dst); \
+	MOVL t, 2*4+off+384(dst);  \
+	MOVL t, 5*4+off+448(dst);  \
+	MOVL t, 1*4+off+512(dst);  \
+	MOVL t, 13*4+off+576(dst); \
+	MOVL 15*4(src), t;         \
+	MOVL t, 15*4+off+0(dst);   \
+	MOVL t, 6*4+off+64(dst);   \
+	MOVL t, 3*4+off+128(dst);  \
+	MOVL t, 11*4+off+192(dst); \
+	MOVL t, 7*4+off+256(dst);  \
+	MOVL t, 10*4+off+320(dst); \
+	MOVL t, 5*4+off+384(dst);  \
+	MOVL t, 9*4+off+448(dst);  \
+	MOVL t, 4*4+off+512(dst);  \
+	MOVL t, 8*4+off+576(dst)
+
+// func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+TEXT ·hashBlocksSSE2(SB), 0, $672-24 // frame = 656 + 16 byte alignment
+	MOVL h+0(FP), AX
+	MOVL c+4(FP), BX
+	MOVL flag+8(FP), CX
+	MOVL blocks_base+12(FP), SI
+	MOVL blocks_len+16(FP), DX
+
+	MOVL SP, BP
+	MOVL SP, DI
+	ADDL $15, DI
+	ANDL $~15, DI
+	MOVL DI, SP
+
+	MOVL CX, 8(SP)
+	MOVL 0(BX), CX
+	MOVL CX, 0(SP)
+	MOVL 4(BX), CX
+	MOVL CX, 4(SP)
+	XORL CX, CX
+	MOVL CX, 12(SP)
+
+	MOVOU 0(AX), X0
+	MOVOU 16(AX), X1
+	MOVOU counter<>(SB), X2
+
+loop:
+	MOVO  X0, X4
+	MOVO  X1, X5
+	MOVOU iv0<>(SB), X6
+	MOVOU iv1<>(SB), X7
+
+	MOVO  0(SP), X3
+	PADDQ X2, X3
+	PXOR  X3, X7
+	MOVO  X3, 0(SP)
+
+	PRECOMPUTE(SP, 16, SI, CX)
+	ROUND_SSE2(X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+64(SP), 32+64(SP), 48+64(SP), 64+64(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+128(SP), 32+128(SP), 48+128(SP), 64+128(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+192(SP), 32+192(SP), 48+192(SP), 64+192(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+256(SP), 32+256(SP), 48+256(SP), 64+256(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+320(SP), 32+320(SP), 48+320(SP), 64+320(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+384(SP), 32+384(SP), 48+384(SP), 64+384(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+448(SP), 32+448(SP), 48+448(SP), 64+448(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+512(SP), 32+512(SP), 48+512(SP), 64+512(SP), X3)
+	ROUND_SSE2(X4, X5, X6, X7, 16+576(SP), 32+576(SP), 48+576(SP), 64+576(SP), X3)
+
+	PXOR X4, X0
+	PXOR X5, X1
+	PXOR X6, X0
+	PXOR X7, X1
+
+	LEAL 64(SI), SI
+	SUBL $64, DX
+	JNE  loop
+
+	MOVL 0(SP), CX
+	MOVL CX, 0(BX)
+	MOVL 4(SP), CX
+	MOVL CX, 4(BX)
+
+	MOVOU X0, 0(AX)
+	MOVOU X1, 16(AX)
+
+	MOVL BP, SP
+	RET
+
+// func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+TEXT ·hashBlocksSSSE3(SB), 0, $704-24 // frame = 688 + 16 byte alignment
+	MOVL h+0(FP), AX
+	MOVL c+4(FP), BX
+	MOVL flag+8(FP), CX
+	MOVL blocks_base+12(FP), SI
+	MOVL blocks_len+16(FP), DX
+
+	MOVL SP, BP
+	MOVL SP, DI
+	ADDL $15, DI
+	ANDL $~15, DI
+	MOVL DI, SP
+
+	MOVL CX, 8(SP)
+	MOVL 0(BX), CX
+	MOVL CX, 0(SP)
+	MOVL 4(BX), CX
+	MOVL CX, 4(SP)
+	XORL CX, CX
+	MOVL CX, 12(SP)
+
+	MOVOU 0(AX), X0
+	MOVOU 16(AX), X1
+	MOVOU counter<>(SB), X2
+
+loop:
+	MOVO  X0, 656(SP)
+	MOVO  X1, 672(SP)
+	MOVO  X0, X4
+	MOVO  X1, X5
+	MOVOU iv0<>(SB), X6
+	MOVOU iv1<>(SB), X7
+
+	MOVO  0(SP), X3
+	PADDQ X2, X3
+	PXOR  X3, X7
+	MOVO  X3, 0(SP)
+
+	MOVOU rol16<>(SB), X0
+	MOVOU rol8<>(SB), X1
+
+	PRECOMPUTE(SP, 16, SI, CX)
+	ROUND_SSSE3(X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+64(SP), 32+64(SP), 48+64(SP), 64+64(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+128(SP), 32+128(SP), 48+128(SP), 64+128(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+192(SP), 32+192(SP), 48+192(SP), 64+192(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+256(SP), 32+256(SP), 48+256(SP), 64+256(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+320(SP), 32+320(SP), 48+320(SP), 64+320(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+384(SP), 32+384(SP), 48+384(SP), 64+384(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+448(SP), 32+448(SP), 48+448(SP), 64+448(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+512(SP), 32+512(SP), 48+512(SP), 64+512(SP), X3, X0, X1)
+	ROUND_SSSE3(X4, X5, X6, X7, 16+576(SP), 32+576(SP), 48+576(SP), 64+576(SP), X3, X0, X1)
+
+	MOVO 656(SP), X0
+	MOVO 672(SP), X1
+	PXOR X4, X0
+	PXOR X5, X1
+	PXOR X6, X0
+	PXOR X7, X1
+
+	LEAL 64(SI), SI
+	SUBL $64, DX
+	JNE  loop
+
+	MOVL 0(SP), CX
+	MOVL CX, 0(BX)
+	MOVL 4(SP), CX
+	MOVL CX, 4(BX)
+
+	MOVOU X0, 0(AX)
+	MOVOU X1, 16(AX)
+
+	MOVL BP, SP
+	RET
+
+// func supportSSSE3() bool
+TEXT ·supportSSSE3(SB), 4, $0-1
+	MOVL $1, AX
+	CPUID
+	MOVL CX, BX
+	ANDL $0x1, BX      // supports SSE3
+	JZ   FALSE
+	ANDL $0x200, CX    // supports SSSE3
+	JZ   FALSE
+	MOVB $1, ret+0(FP)
+	RET
+
+FALSE:
+	MOVB $0, ret+0(FP)
+	RET
+
+// func supportSSE2() bool
+TEXT ·supportSSE2(SB), 4, $0-1
+	MOVL $1, AX
+	CPUID
+	SHRL $26, DX
+	ANDL $1, DX        // DX != 0 if support SSE2
+	MOVB DX, ret+0(FP)
+	RET
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go
new file mode 100644
index 000000000..a925e6b20
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go
@@ -0,0 +1,40 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64,!gccgo,!appengine
+
+package blake2s
+
+var (
+	useSSE4  = supportSSE4()
+	useSSSE3 = supportSSSE3()
+	useSSE2  = true // Always available on amd64
+)
+
+//go:noescape
+func supportSSSE3() bool
+
+//go:noescape
+func supportSSE4() bool
+
+//go:noescape
+func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+
+//go:noescape
+func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+
+//go:noescape
+func hashBlocksSSE4(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+
+func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
+	if useSSE4 {
+		hashBlocksSSE4(h, c, flag, blocks)
+	} else if useSSSE3 {
+		hashBlocksSSSE3(h, c, flag, blocks)
+	} else if useSSE2 {
+		hashBlocksSSE2(h, c, flag, blocks)
+	} else {
+		hashBlocksGeneric(h, c, flag, blocks)
+	}
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s
new file mode 100644
index 000000000..6cdf5a94c
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s
@@ -0,0 +1,463 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64,!gccgo,!appengine
+
+#include "textflag.h"
+
+DATA iv0<>+0x00(SB)/4, $0x6a09e667
+DATA iv0<>+0x04(SB)/4, $0xbb67ae85
+DATA iv0<>+0x08(SB)/4, $0x3c6ef372
+DATA iv0<>+0x0c(SB)/4, $0xa54ff53a
+GLOBL iv0<>(SB), (NOPTR+RODATA), $16
+
+DATA iv1<>+0x00(SB)/4, $0x510e527f
+DATA iv1<>+0x04(SB)/4, $0x9b05688c
+DATA iv1<>+0x08(SB)/4, $0x1f83d9ab
+DATA iv1<>+0x0c(SB)/4, $0x5be0cd19
+GLOBL iv1<>(SB), (NOPTR+RODATA), $16
+
+DATA rol16<>+0x00(SB)/8, $0x0504070601000302
+DATA rol16<>+0x08(SB)/8, $0x0D0C0F0E09080B0A
+GLOBL rol16<>(SB), (NOPTR+RODATA), $16
+
+DATA rol8<>+0x00(SB)/8, $0x0407060500030201
+DATA rol8<>+0x08(SB)/8, $0x0C0F0E0D080B0A09
+GLOBL rol8<>(SB), (NOPTR+RODATA), $16
+
+DATA counter<>+0x00(SB)/8, $0x40
+DATA counter<>+0x08(SB)/8, $0x0
+GLOBL counter<>(SB), (NOPTR+RODATA), $16
+
+#define ROTL_SSE2(n, t, v) \
+	MOVO  v, t;       \
+	PSLLL $n, t;      \
+	PSRLL $(32-n), v; \
+	PXOR  t, v
+
+#define ROTL_SSSE3(c, v) \
+	PSHUFB c, v
+
+#define ROUND_SSE2(v0, v1, v2, v3, m0, m1, m2, m3, t) \
+	PADDL  m0, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(16, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m1, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(24, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v1, v1; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v3, v3; \
+	PADDL  m2, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(16, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m3, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSE2(24, t, v3); \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v3, v3; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v1, v1
+
+#define ROUND_SSSE3(v0, v1, v2, v3, m0, m1, m2, m3, t, c16, c8) \
+	PADDL  m0, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c16, v3);  \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m1, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c8, v3);   \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v1, v1; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v3, v3; \
+	PADDL  m2, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c16, v3);  \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(20, t, v1); \
+	PADDL  m3, v0;        \
+	PADDL  v1, v0;        \
+	PXOR   v0, v3;        \
+	ROTL_SSSE3(c8, v3);   \
+	PADDL  v3, v2;        \
+	PXOR   v2, v1;        \
+	ROTL_SSE2(25, t, v1); \
+	PSHUFL $0x39, v3, v3; \
+	PSHUFL $0x4E, v2, v2; \
+	PSHUFL $0x93, v1, v1
+
+
+#define LOAD_MSG_SSE4(m0, m1, m2, m3, src, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) \
+	MOVL   i0*4(src), m0;      \
+	PINSRD $1, i1*4(src), m0;  \
+	PINSRD $2, i2*4(src), m0;  \
+	PINSRD $3, i3*4(src), m0;  \
+	MOVL   i4*4(src), m1;      \
+	PINSRD $1, i5*4(src), m1;  \
+	PINSRD $2, i6*4(src), m1;  \
+	PINSRD $3, i7*4(src), m1;  \
+	MOVL   i8*4(src), m2;      \
+	PINSRD $1, i9*4(src), m2;  \
+	PINSRD $2, i10*4(src), m2; \
+	PINSRD $3, i11*4(src), m2; \
+	MOVL   i12*4(src), m3;     \
+	PINSRD $1, i13*4(src), m3; \
+	PINSRD $2, i14*4(src), m3; \
+	PINSRD $3, i15*4(src), m3
+
+#define PRECOMPUTE_MSG(dst, off, src, R8, R9, R10, R11, R12, R13, R14, R15) \
+	MOVQ 0*4(src), R8;           \
+	MOVQ 2*4(src), R9;           \
+	MOVQ 4*4(src), R10;          \
+	MOVQ 6*4(src), R11;          \
+	MOVQ 8*4(src), R12;          \
+	MOVQ 10*4(src), R13;         \
+	MOVQ 12*4(src), R14;         \
+	MOVQ 14*4(src), R15;         \
+	                             \
+	MOVL R8, 0*4+off+0(dst);     \
+	MOVL R8, 9*4+off+64(dst);    \
+	MOVL R8, 5*4+off+128(dst);   \
+	MOVL R8, 14*4+off+192(dst);  \
+	MOVL R8, 4*4+off+256(dst);   \
+	MOVL R8, 2*4+off+320(dst);   \
+	MOVL R8, 8*4+off+384(dst);   \
+	MOVL R8, 12*4+off+448(dst);  \
+	MOVL R8, 3*4+off+512(dst);   \
+	MOVL R8, 15*4+off+576(dst);  \
+	SHRQ $32, R8;                \
+	MOVL R8, 4*4+off+0(dst);     \
+	MOVL R8, 8*4+off+64(dst);    \
+	MOVL R8, 14*4+off+128(dst);  \
+	MOVL R8, 5*4+off+192(dst);   \
+	MOVL R8, 12*4+off+256(dst);  \
+	MOVL R8, 11*4+off+320(dst);  \
+	MOVL R8, 1*4+off+384(dst);   \
+	MOVL R8, 6*4+off+448(dst);   \
+	MOVL R8, 10*4+off+512(dst);  \
+	MOVL R8, 3*4+off+576(dst);   \
+	                             \
+	MOVL R9, 1*4+off+0(dst);     \
+	MOVL R9, 13*4+off+64(dst);   \
+	MOVL R9, 6*4+off+128(dst);   \
+	MOVL R9, 8*4+off+192(dst);   \
+	MOVL R9, 2*4+off+256(dst);   \
+	MOVL R9, 0*4+off+320(dst);   \
+	MOVL R9, 14*4+off+384(dst);  \
+	MOVL R9, 11*4+off+448(dst);  \
+	MOVL R9, 12*4+off+512(dst);  \
+	MOVL R9, 4*4+off+576(dst);   \
+	SHRQ $32, R9;                \
+	MOVL R9, 5*4+off+0(dst);     \
+	MOVL R9, 15*4+off+64(dst);   \
+	MOVL R9, 9*4+off+128(dst);   \
+	MOVL R9, 1*4+off+192(dst);   \
+	MOVL R9, 11*4+off+256(dst);  \
+	MOVL R9, 7*4+off+320(dst);   \
+	MOVL R9, 13*4+off+384(dst);  \
+	MOVL R9, 3*4+off+448(dst);   \
+	MOVL R9, 6*4+off+512(dst);   \
+	MOVL R9, 10*4+off+576(dst);  \
+	                             \
+	MOVL R10, 2*4+off+0(dst);    \
+	MOVL R10, 1*4+off+64(dst);   \
+	MOVL R10, 15*4+off+128(dst); \
+	MOVL R10, 10*4+off+192(dst); \
+	MOVL R10, 6*4+off+256(dst);  \
+	MOVL R10, 8*4+off+320(dst);  \
+	MOVL R10, 3*4+off+384(dst);  \
+	MOVL R10, 13*4+off+448(dst); \
+	MOVL R10, 14*4+off+512(dst); \
+	MOVL R10, 5*4+off+576(dst);  \
+	SHRQ $32, R10;               \
+	MOVL R10, 6*4+off+0(dst);    \
+	MOVL R10, 11*4+off+64(dst);  \
+	MOVL R10, 2*4+off+128(dst);  \
+	MOVL R10, 9*4+off+192(dst);  \
+	MOVL R10, 1*4+off+256(dst);  \
+	MOVL R10, 13*4+off+320(dst); \
+	MOVL R10, 4*4+off+384(dst);  \
+	MOVL R10, 8*4+off+448(dst);  \
+	MOVL R10, 15*4+off+512(dst); \
+	MOVL R10, 7*4+off+576(dst);  \
+	                             \
+	MOVL R11, 3*4+off+0(dst);    \
+	MOVL R11, 7*4+off+64(dst);   \
+	MOVL R11, 13*4+off+128(dst); \
+	MOVL R11, 12*4+off+192(dst); \
+	MOVL R11, 10*4+off+256(dst); \
+	MOVL R11, 1*4+off+320(dst);  \
+	MOVL R11, 9*4+off+384(dst);  \
+	MOVL R11, 14*4+off+448(dst); \
+	MOVL R11, 0*4+off+512(dst);  \
+	MOVL R11, 6*4+off+576(dst);  \
+	SHRQ $32, R11;               \
+	MOVL R11, 7*4+off+0(dst);    \
+	MOVL R11, 14*4+off+64(dst);  \
+	MOVL R11, 10*4+off+128(dst); \
+	MOVL R11, 0*4+off+192(dst);  \
+	MOVL R11, 5*4+off+256(dst);  \
+	MOVL R11, 9*4+off+320(dst);  \
+	MOVL R11, 12*4+off+384(dst); \
+	MOVL R11, 1*4+off+448(dst);  \
+	MOVL R11, 13*4+off+512(dst); \
+	MOVL R11, 2*4+off+576(dst);  \
+	                             \
+	MOVL R12, 8*4+off+0(dst);    \
+	MOVL R12, 5*4+off+64(dst);   \
+	MOVL R12, 4*4+off+128(dst);  \
+	MOVL R12, 15*4+off+192(dst); \
+	MOVL R12, 14*4+off+256(dst); \
+	MOVL R12, 3*4+off+320(dst);  \
+	MOVL R12, 11*4+off+384(dst); \
+	MOVL R12, 10*4+off+448(dst); \
+	MOVL R12, 7*4+off+512(dst);  \
+	MOVL R12, 1*4+off+576(dst);  \
+	SHRQ $32, R12;               \
+	MOVL R12, 12*4+off+0(dst);   \
+	MOVL R12, 2*4+off+64(dst);   \
+	MOVL R12, 11*4+off+128(dst); \
+	MOVL R12, 4*4+off+192(dst);  \
+	MOVL R12, 0*4+off+256(dst);  \
+	MOVL R12, 15*4+off+320(dst); \
+	MOVL R12, 10*4+off+384(dst); \
+	MOVL R12, 7*4+off+448(dst);  \
+	MOVL R12, 5*4+off+512(dst);  \
+	MOVL R12, 9*4+off+576(dst);  \
+	                             \
+	MOVL R13, 9*4+off+0(dst);    \
+	MOVL R13, 4*4+off+64(dst);   \
+	MOVL R13, 8*4+off+128(dst);  \
+	MOVL R13, 13*4+off+192(dst); \
+	MOVL R13, 3*4+off+256(dst);  \
+	MOVL R13, 5*4+off+320(dst);  \
+	MOVL R13, 7*4+off+384(dst);  \
+	MOVL R13, 15*4+off+448(dst); \
+	MOVL R13, 11*4+off+512(dst); \
+	MOVL R13, 0*4+off+576(dst);  \
+	SHRQ $32, R13;               \
+	MOVL R13, 13*4+off+0(dst);   \
+	MOVL R13, 10*4+off+64(dst);  \
+	MOVL R13, 0*4+off+128(dst);  \
+	MOVL R13, 3*4+off+192(dst);  \
+	MOVL R13, 9*4+off+256(dst);  \
+	MOVL R13, 6*4+off+320(dst);  \
+	MOVL R13, 15*4+off+384(dst); \
+	MOVL R13, 4*4+off+448(dst);  \
+	MOVL R13, 2*4+off+512(dst);  \
+	MOVL R13, 12*4+off+576(dst); \
+	                             \
+	MOVL R14, 10*4+off+0(dst);   \
+	MOVL R14, 12*4+off+64(dst);  \
+	MOVL R14, 1*4+off+128(dst);  \
+	MOVL R14, 6*4+off+192(dst);  \
+	MOVL R14, 13*4+off+256(dst); \
+	MOVL R14, 4*4+off+320(dst);  \
+	MOVL R14, 0*4+off+384(dst);  \
+	MOVL R14, 2*4+off+448(dst);  \
+	MOVL R14, 8*4+off+512(dst);  \
+	MOVL R14, 14*4+off+576(dst); \
+	SHRQ $32, R14;               \
+	MOVL R14, 14*4+off+0(dst);   \
+	MOVL R14, 3*4+off+64(dst);   \
+	MOVL R14, 7*4+off+128(dst);  \
+	MOVL R14, 2*4+off+192(dst);  \
+	MOVL R14, 15*4+off+256(dst); \
+	MOVL R14, 12*4+off+320(dst); \
+	MOVL R14, 6*4+off+384(dst);  \
+	MOVL R14, 0*4+off+448(dst);  \
+	MOVL R14, 9*4+off+512(dst);  \
+	MOVL R14, 11*4+off+576(dst); \
+	                             \
+	MOVL R15, 11*4+off+0(dst);   \
+	MOVL R15, 0*4+off+64(dst);   \
+	MOVL R15, 12*4+off+128(dst); \
+	MOVL R15, 7*4+off+192(dst);  \
+	MOVL R15, 8*4+off+256(dst);  \
+	MOVL R15, 14*4+off+320(dst); \
+	MOVL R15, 2*4+off+384(dst);  \
+	MOVL R15, 5*4+off+448(dst);  \
+	MOVL R15, 1*4+off+512(dst);  \
+	MOVL R15, 13*4+off+576(dst); \
+	SHRQ $32, R15;               \
+	MOVL R15, 15*4+off+0(dst);   \
+	MOVL R15, 6*4+off+64(dst);   \
+	MOVL R15, 3*4+off+128(dst);  \
+	MOVL R15, 11*4+off+192(dst); \
+	MOVL R15, 7*4+off+256(dst);  \
+	MOVL R15, 10*4+off+320(dst); \
+	MOVL R15, 5*4+off+384(dst);  \
+	MOVL R15, 9*4+off+448(dst);  \
+	MOVL R15, 4*4+off+512(dst);  \
+	MOVL R15, 8*4+off+576(dst)
+
+#define BLAKE2s_SSE2() \
+	PRECOMPUTE_MSG(SP, 16, SI, R8, R9, R10, R11, R12, R13, R14, R15);               \
+	ROUND_SSE2(X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X8);                 \
+	ROUND_SSE2(X4, X5, X6, X7, 16+64(SP), 32+64(SP), 48+64(SP), 64+64(SP), X8);     \
+	ROUND_SSE2(X4, X5, X6, X7, 16+128(SP), 32+128(SP), 48+128(SP), 64+128(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+192(SP), 32+192(SP), 48+192(SP), 64+192(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+256(SP), 32+256(SP), 48+256(SP), 64+256(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+320(SP), 32+320(SP), 48+320(SP), 64+320(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+384(SP), 32+384(SP), 48+384(SP), 64+384(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+448(SP), 32+448(SP), 48+448(SP), 64+448(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+512(SP), 32+512(SP), 48+512(SP), 64+512(SP), X8); \
+	ROUND_SSE2(X4, X5, X6, X7, 16+576(SP), 32+576(SP), 48+576(SP), 64+576(SP), X8)
+
+#define BLAKE2s_SSSE3() \
+	PRECOMPUTE_MSG(SP, 16, SI, R8, R9, R10, R11, R12, R13, R14, R15);                          \
+	ROUND_SSSE3(X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X8, X13, X14);                 \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+64(SP), 32+64(SP), 48+64(SP), 64+64(SP), X8, X13, X14);     \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+128(SP), 32+128(SP), 48+128(SP), 64+128(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+192(SP), 32+192(SP), 48+192(SP), 64+192(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+256(SP), 32+256(SP), 48+256(SP), 64+256(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+320(SP), 32+320(SP), 48+320(SP), 64+320(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+384(SP), 32+384(SP), 48+384(SP), 64+384(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+448(SP), 32+448(SP), 48+448(SP), 64+448(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+512(SP), 32+512(SP), 48+512(SP), 64+512(SP), X8, X13, X14); \
+	ROUND_SSSE3(X4, X5, X6, X7, 16+576(SP), 32+576(SP), 48+576(SP), 64+576(SP), X8, X13, X14)
+
+#define BLAKE2s_SSE4() \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 14, 4, 9, 13, 10, 8, 15, 6, 1, 0, 11, 5, 12, 2, 7, 3); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 11, 12, 5, 15, 8, 0, 2, 13, 10, 3, 7, 9, 14, 6, 1, 4); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 7, 3, 13, 11, 9, 1, 12, 14, 2, 5, 4, 15, 6, 10, 0, 8); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 9, 5, 2, 10, 0, 7, 4, 15, 14, 11, 6, 3, 1, 12, 8, 13); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 2, 6, 0, 8, 12, 10, 11, 3, 4, 7, 15, 1, 13, 5, 14, 9); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 12, 1, 14, 4, 5, 15, 13, 10, 0, 6, 9, 8, 7, 3, 2, 11); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 13, 7, 12, 3, 11, 14, 1, 9, 5, 15, 8, 2, 0, 4, 6, 10); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 6, 14, 11, 0, 15, 9, 3, 8, 12, 13, 1, 10, 2, 7, 4, 5); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14);                               \
+	LOAD_MSG_SSE4(X8, X9, X10, X11, SI, 10, 8, 7, 1, 2, 4, 6, 5, 15, 9, 3, 13, 11, 14, 12, 0); \
+	ROUND_SSSE3(X4, X5, X6, X7, X8, X9, X10, X11, X8, X13, X14)
+
+#define HASH_BLOCKS(h, c, flag, blocks_base, blocks_len, BLAKE2s_FUNC) \
+	MOVQ  h, AX;                   \
+	MOVQ  c, BX;                   \
+	MOVL  flag, CX;                \
+	MOVQ  blocks_base, SI;         \
+	MOVQ  blocks_len, DX;          \
+	                               \
+	MOVQ  SP, BP;                  \
+	MOVQ  SP, R9;                  \
+	ADDQ  $15, R9;                 \
+	ANDQ  $~15, R9;                \
+	MOVQ  R9, SP;                  \
+	                               \
+	MOVQ  0(BX), R9;               \
+	MOVQ  R9, 0(SP);               \
+	XORQ  R9, R9;                  \
+	MOVQ  R9, 8(SP);               \
+	MOVL  CX, 8(SP);               \
+	                               \
+	MOVOU 0(AX), X0;               \
+	MOVOU 16(AX), X1;              \
+	MOVOU iv0<>(SB), X2;           \
+	MOVOU iv1<>(SB), X3            \
+	                               \
+	MOVOU counter<>(SB), X12;      \
+	MOVOU rol16<>(SB), X13;        \
+	MOVOU rol8<>(SB), X14;         \
+	MOVO  0(SP), X15;              \
+	                               \
+	loop:                          \
+	MOVO  X0, X4;                  \
+	MOVO  X1, X5;                  \
+	MOVO  X2, X6;                  \
+	MOVO  X3, X7;                  \
+	                               \
+	PADDQ X12, X15;                \
+	PXOR  X15, X7;                 \
+	                               \
+	BLAKE2s_FUNC();                \
+	                               \
+	PXOR  X4, X0;                  \
+	PXOR  X5, X1;                  \
+	PXOR  X6, X0;                  \
+	PXOR  X7, X1;                  \
+	                               \
+	LEAQ  64(SI), SI;              \
+	SUBQ  $64, DX;                 \
+	JNE   loop;                    \
+	                               \
+	MOVO  X15, 0(SP);              \
+	MOVQ  0(SP), R9;               \
+	MOVQ  R9, 0(BX);               \
+	                               \
+	MOVOU X0, 0(AX);               \
+	MOVOU X1, 16(AX);              \
+	                               \
+	MOVQ  BP, SP
+
+// func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+TEXT ·hashBlocksSSE2(SB), 0, $672-48 // frame = 656 + 16 byte alignment
+	HASH_BLOCKS(h+0(FP), c+8(FP), flag+16(FP), blocks_base+24(FP), blocks_len+32(FP), BLAKE2s_SSE2)
+	RET
+
+// func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+TEXT ·hashBlocksSSSE3(SB), 0, $672-48 // frame = 656 + 16 byte alignment
+	HASH_BLOCKS(h+0(FP), c+8(FP), flag+16(FP), blocks_base+24(FP), blocks_len+32(FP), BLAKE2s_SSSE3)
+	RET
+
+// func hashBlocksSSE4(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
+TEXT ·hashBlocksSSE4(SB), 0, $32-48 // frame = 16 + 16 byte alignment
+	HASH_BLOCKS(h+0(FP), c+8(FP), flag+16(FP), blocks_base+24(FP), blocks_len+32(FP), BLAKE2s_SSE4)
+	RET
+
+// func supportSSE4() bool
+TEXT ·supportSSE4(SB), 4, $0-1
+	MOVL $1, AX
+	CPUID
+	SHRL $19, CX       // Bit 19 indicates SSE4.1.
+	ANDL $1, CX
+	MOVB CX, ret+0(FP)
+	RET
+
+// func supportSSSE3() bool
+TEXT ·supportSSSE3(SB), 4, $0-1
+	MOVL $1, AX
+	CPUID
+	MOVL CX, BX
+	ANDL $0x1, BX      // Bit zero indicates SSE3 support.
+	JZ   FALSE
+	ANDL $0x200, CX    // Bit nine indicates SSSE3 support.
+	JZ   FALSE
+	MOVB $1, ret+0(FP)
+	RET
+
+FALSE:
+	MOVB $0, ret+0(FP)
+	RET
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go b/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go
new file mode 100644
index 000000000..f7e065378
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go
@@ -0,0 +1,174 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package blake2s
+
+// the precomputed values for BLAKE2s
+// there are 10 16-byte arrays - one for each round
+// the entries are calculated from the sigma constants.
+var precomputed = [10][16]byte{
+	{0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15},
+	{14, 4, 9, 13, 10, 8, 15, 6, 1, 0, 11, 5, 12, 2, 7, 3},
+	{11, 12, 5, 15, 8, 0, 2, 13, 10, 3, 7, 9, 14, 6, 1, 4},
+	{7, 3, 13, 11, 9, 1, 12, 14, 2, 5, 4, 15, 6, 10, 0, 8},
+	{9, 5, 2, 10, 0, 7, 4, 15, 14, 11, 6, 3, 1, 12, 8, 13},
+	{2, 6, 0, 8, 12, 10, 11, 3, 4, 7, 15, 1, 13, 5, 14, 9},
+	{12, 1, 14, 4, 5, 15, 13, 10, 0, 6, 9, 8, 7, 3, 2, 11},
+	{13, 7, 12, 3, 11, 14, 1, 9, 5, 15, 8, 2, 0, 4, 6, 10},
+	{6, 14, 11, 0, 15, 9, 3, 8, 12, 13, 1, 10, 2, 7, 4, 5},
+	{10, 8, 7, 1, 2, 4, 6, 5, 15, 9, 3, 13, 11, 14, 12, 0},
+}
+
+func hashBlocksGeneric(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
+	var m [16]uint32
+	c0, c1 := c[0], c[1]
+
+	for i := 0; i < len(blocks); {
+		c0 += BlockSize
+		if c0 < BlockSize {
+			c1++
+		}
+
+		v0, v1, v2, v3, v4, v5, v6, v7 := h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
+		v8, v9, v10, v11, v12, v13, v14, v15 := iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]
+		v12 ^= c0
+		v13 ^= c1
+		v14 ^= flag
+
+		for j := range m {
+			m[j] = uint32(blocks[i]) | uint32(blocks[i+1])<<8 | uint32(blocks[i+2])<<16 | uint32(blocks[i+3])<<24
+			i += 4
+		}
+
+		for k := range precomputed {
+			s := &(precomputed[k])
+
+			v0 += m[s[0]]
+			v0 += v4
+			v12 ^= v0
+			v12 = v12<<(32-16) | v12>>16
+			v8 += v12
+			v4 ^= v8
+			v4 = v4<<(32-12) | v4>>12
+			v1 += m[s[1]]
+			v1 += v5
+			v13 ^= v1
+			v13 = v13<<(32-16) | v13>>16
+			v9 += v13
+			v5 ^= v9
+			v5 = v5<<(32-12) | v5>>12
+			v2 += m[s[2]]
+			v2 += v6
+			v14 ^= v2
+			v14 = v14<<(32-16) | v14>>16
+			v10 += v14
+			v6 ^= v10
+			v6 = v6<<(32-12) | v6>>12
+			v3 += m[s[3]]
+			v3 += v7
+			v15 ^= v3
+			v15 = v15<<(32-16) | v15>>16
+			v11 += v15
+			v7 ^= v11
+			v7 = v7<<(32-12) | v7>>12
+
+			v0 += m[s[4]]
+			v0 += v4
+			v12 ^= v0
+			v12 = v12<<(32-8) | v12>>8
+			v8 += v12
+			v4 ^= v8
+			v4 = v4<<(32-7) | v4>>7
+			v1 += m[s[5]]
+			v1 += v5
+			v13 ^= v1
+			v13 = v13<<(32-8) | v13>>8
+			v9 += v13
+			v5 ^= v9
+			v5 = v5<<(32-7) | v5>>7
+			v2 += m[s[6]]
+			v2 += v6
+			v14 ^= v2
+			v14 = v14<<(32-8) | v14>>8
+			v10 += v14
+			v6 ^= v10
+			v6 = v6<<(32-7) | v6>>7
+			v3 += m[s[7]]
+			v3 += v7
+			v15 ^= v3
+			v15 = v15<<(32-8) | v15>>8
+			v11 += v15
+			v7 ^= v11
+			v7 = v7<<(32-7) | v7>>7
+
+			v0 += m[s[8]]
+			v0 += v5
+			v15 ^= v0
+			v15 = v15<<(32-16) | v15>>16
+			v10 += v15
+			v5 ^= v10
+			v5 = v5<<(32-12) | v5>>12
+			v1 += m[s[9]]
+			v1 += v6
+			v12 ^= v1
+			v12 = v12<<(32-16) | v12>>16
+			v11 += v12
+			v6 ^= v11
+			v6 = v6<<(32-12) | v6>>12
+			v2 += m[s[10]]
+			v2 += v7
+			v13 ^= v2
+			v13 = v13<<(32-16) | v13>>16
+			v8 += v13
+			v7 ^= v8
+			v7 = v7<<(32-12) | v7>>12
+			v3 += m[s[11]]
+			v3 += v4
+			v14 ^= v3
+			v14 = v14<<(32-16) | v14>>16
+			v9 += v14
+			v4 ^= v9
+			v4 = v4<<(32-12) | v4>>12
+
+			v0 += m[s[12]]
+			v0 += v5
+			v15 ^= v0
+			v15 = v15<<(32-8) | v15>>8
+			v10 += v15
+			v5 ^= v10
+			v5 = v5<<(32-7) | v5>>7
+			v1 += m[s[13]]
+			v1 += v6
+			v12 ^= v1
+			v12 = v12<<(32-8) | v12>>8
+			v11 += v12
+			v6 ^= v11
+			v6 = v6<<(32-7) | v6>>7
+			v2 += m[s[14]]
+			v2 += v7
+			v13 ^= v2
+			v13 = v13<<(32-8) | v13>>8
+			v8 += v13
+			v7 ^= v8
+			v7 = v7<<(32-7) | v7>>7
+			v3 += m[s[15]]
+			v3 += v4
+			v14 ^= v3
+			v14 = v14<<(32-8) | v14>>8
+			v9 += v14
+			v4 ^= v9
+			v4 = v4<<(32-7) | v4>>7
+		}
+
+		h[0] ^= v0 ^ v8
+		h[1] ^= v1 ^ v9
+		h[2] ^= v2 ^ v10
+		h[3] ^= v3 ^ v11
+		h[4] ^= v4 ^ v12
+		h[5] ^= v5 ^ v13
+		h[6] ^= v6 ^ v14
+		h[7] ^= v7 ^ v15
+	}
+	c[0], c[1] = c0, c1
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go b/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go
new file mode 100644
index 000000000..a31127345
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go
@@ -0,0 +1,17 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !amd64,!386 gccgo appengine
+
+package blake2s
+
+var (
+	useSSE4  = false
+	useSSSE3 = false
+	useSSE2  = false
+)
+
+func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
+	hashBlocksGeneric(h, c, flag, blocks)
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2x.go b/vendor/golang.org/x/crypto/blake2s/blake2x.go
new file mode 100644
index 000000000..eaff2a7f8
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/blake2x.go
@@ -0,0 +1,178 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package blake2s
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+// XOF defines the interface to hash functions that
+// support arbitrary-length output.
+type XOF interface {
+	// Write absorbs more data into the hash's state. It panics if called
+	// after Read.
+	io.Writer
+
+	// Read reads more output from the hash. It returns io.EOF if the limit
+	// has been reached.
+	io.Reader
+
+	// Clone returns a copy of the XOF in its current state.
+	Clone() XOF
+
+	// Reset resets the XOF to its initial state.
+	Reset()
+}
+
+// OutputLengthUnknown can be used as the size argument to NewXOF to indicate
+// the the length of the output is not known in advance.
+const OutputLengthUnknown = 0
+
+// magicUnknownOutputLength is a magic value for the output size that indicates
+// an unknown number of output bytes.
+const magicUnknownOutputLength = 65535
+
+// maxOutputLength is the absolute maximum number of bytes to produce when the
+// number of output bytes is unknown.
+const maxOutputLength = (1 << 32) * 32
+
+// NewXOF creates a new variable-output-length hash. The hash either produce a
+// known number of bytes (1 <= size < 65535), or an unknown number of bytes
+// (size == OutputLengthUnknown). In the latter case, an absolute limit of
+// 128GiB applies.
+//
+// A non-nil key turns the hash into a MAC. The key must between
+// zero and 32 bytes long.
+func NewXOF(size uint16, key []byte) (XOF, error) {
+	if len(key) > Size {
+		return nil, errKeySize
+	}
+	if size == magicUnknownOutputLength {
+		// 2^16-1 indicates an unknown number of bytes and thus isn't a
+		// valid length.
+		return nil, errors.New("blake2s: XOF length too large")
+	}
+	if size == OutputLengthUnknown {
+		size = magicUnknownOutputLength
+	}
+	x := &xof{
+		d: digest{
+			size:   Size,
+			keyLen: len(key),
+		},
+		length: size,
+	}
+	copy(x.d.key[:], key)
+	x.Reset()
+	return x, nil
+}
+
+type xof struct {
+	d                digest
+	length           uint16
+	remaining        uint64
+	cfg, root, block [Size]byte
+	offset           int
+	nodeOffset       uint32
+	readMode         bool
+}
+
+func (x *xof) Write(p []byte) (n int, err error) {
+	if x.readMode {
+		panic("blake2s: write to XOF after read")
+	}
+	return x.d.Write(p)
+}
+
+func (x *xof) Clone() XOF {
+	clone := *x
+	return &clone
+}
+
+func (x *xof) Reset() {
+	x.cfg[0] = byte(Size)
+	binary.LittleEndian.PutUint32(x.cfg[4:], uint32(Size)) // leaf length
+	binary.LittleEndian.PutUint16(x.cfg[12:], x.length)    // XOF length
+	x.cfg[15] = byte(Size)                                 // inner hash size
+
+	x.d.Reset()
+	x.d.h[3] ^= uint32(x.length)
+
+	x.remaining = uint64(x.length)
+	if x.remaining == magicUnknownOutputLength {
+		x.remaining = maxOutputLength
+	}
+	x.offset, x.nodeOffset = 0, 0
+	x.readMode = false
+}
+
+func (x *xof) Read(p []byte) (n int, err error) {
+	if !x.readMode {
+		x.d.finalize(&x.root)
+		x.readMode = true
+	}
+
+	if x.remaining == 0 {
+		return 0, io.EOF
+	}
+
+	n = len(p)
+	if uint64(n) > x.remaining {
+		n = int(x.remaining)
+		p = p[:n]
+	}
+
+	if x.offset > 0 {
+		blockRemaining := Size - x.offset
+		if n < blockRemaining {
+			x.offset += copy(p, x.block[x.offset:])
+			x.remaining -= uint64(n)
+			return
+		}
+		copy(p, x.block[x.offset:])
+		p = p[blockRemaining:]
+		x.offset = 0
+		x.remaining -= uint64(blockRemaining)
+	}
+
+	for len(p) >= Size {
+		binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset)
+		x.nodeOffset++
+
+		x.d.initConfig(&x.cfg)
+		x.d.Write(x.root[:])
+		x.d.finalize(&x.block)
+
+		copy(p, x.block[:])
+		p = p[Size:]
+		x.remaining -= uint64(Size)
+	}
+
+	if todo := len(p); todo > 0 {
+		if x.remaining < uint64(Size) {
+			x.cfg[0] = byte(x.remaining)
+		}
+		binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset)
+		x.nodeOffset++
+
+		x.d.initConfig(&x.cfg)
+		x.d.Write(x.root[:])
+		x.d.finalize(&x.block)
+
+		x.offset = copy(p, x.block[:todo])
+		x.remaining -= uint64(todo)
+	}
+
+	return
+}
+
+func (d *digest) initConfig(cfg *[Size]byte) {
+	d.offset, d.c[0], d.c[1] = 0, 0, 0
+	for i := range d.h {
+		d.h[i] = iv[i] ^ binary.LittleEndian.Uint32(cfg[i*4:])
+	}
+}
diff --git a/vendor/golang.org/x/crypto/blake2s/register.go b/vendor/golang.org/x/crypto/blake2s/register.go
new file mode 100644
index 000000000..d277459a1
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blake2s/register.go
@@ -0,0 +1,21 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.9
+
+package blake2s
+
+import (
+	"crypto"
+	"hash"
+)
+
+func init() {
+	newHash256 := func() hash.Hash {
+		h, _ := New256(nil)
+		return h
+	}
+
+	crypto.RegisterHash(crypto.BLAKE2s_256, newHash256)
+}
diff --git a/vendor/golang.org/x/crypto/blowfish/block.go b/vendor/golang.org/x/crypto/blowfish/block.go
new file mode 100644
index 000000000..9d80f1952
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blowfish/block.go
@@ -0,0 +1,159 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package blowfish
+
+// getNextWord returns the next big-endian uint32 value from the byte slice
+// at the given position in a circular manner, updating the position.
+func getNextWord(b []byte, pos *int) uint32 {
+	var w uint32
+	j := *pos
+	for i := 0; i < 4; i++ {
+		w = w<<8 | uint32(b[j])
+		j++
+		if j >= len(b) {
+			j = 0
+		}
+	}
+	*pos = j
+	return w
+}
+
+// ExpandKey performs a key expansion on the given *Cipher. Specifically, it
+// performs the Blowfish algorithm's key schedule which sets up the *Cipher's
+// pi and substitution tables for calls to Encrypt. This is used, primarily,
+// by the bcrypt package to reuse the Blowfish key schedule during its
+// set up. It's unlikely that you need to use this directly.
+func ExpandKey(key []byte, c *Cipher) {
+	j := 0
+	for i := 0; i < 18; i++ {
+		// Using inlined getNextWord for performance.
+		var d uint32
+		for k := 0; k < 4; k++ {
+			d = d<<8 | uint32(key[j])
+			j++
+			if j >= len(key) {
+				j = 0
+			}
+		}
+		c.p[i] ^= d
+	}
+
+	var l, r uint32
+	for i := 0; i < 18; i += 2 {
+		l, r = encryptBlock(l, r, c)
+		c.p[i], c.p[i+1] = l, r
+	}
+
+	for i := 0; i < 256; i += 2 {
+		l, r = encryptBlock(l, r, c)
+		c.s0[i], c.s0[i+1] = l, r
+	}
+	for i := 0; i < 256; i += 2 {
+		l, r = encryptBlock(l, r, c)
+		c.s1[i], c.s1[i+1] = l, r
+	}
+	for i := 0; i < 256; i += 2 {
+		l, r = encryptBlock(l, r, c)
+		c.s2[i], c.s2[i+1] = l, r
+	}
+	for i := 0; i < 256; i += 2 {
+		l, r = encryptBlock(l, r, c)
+		c.s3[i], c.s3[i+1] = l, r
+	}
+}
+
+// This is similar to ExpandKey, but folds the salt during the key
+// schedule. While ExpandKey is essentially expandKeyWithSalt with an all-zero
+// salt passed in, reusing ExpandKey turns out to be a place of inefficiency
+// and specializing it here is useful.
+func expandKeyWithSalt(key []byte, salt []byte, c *Cipher) {
+	j := 0
+	for i := 0; i < 18; i++ {
+		c.p[i] ^= getNextWord(key, &j)
+	}
+
+	j = 0
+	var l, r uint32
+	for i := 0; i < 18; i += 2 {
+		l ^= getNextWord(salt, &j)
+		r ^= getNextWord(salt, &j)
+		l, r = encryptBlock(l, r, c)
+		c.p[i], c.p[i+1] = l, r
+	}
+
+	for i := 0; i < 256; i += 2 {
+		l ^= getNextWord(salt, &j)
+		r ^= getNextWord(salt, &j)
+		l, r = encryptBlock(l, r, c)
+		c.s0[i], c.s0[i+1] = l, r
+	}
+
+	for i := 0; i < 256; i += 2 {
+		l ^= getNextWord(salt, &j)
+		r ^= getNextWord(salt, &j)
+		l, r = encryptBlock(l, r, c)
+		c.s1[i], c.s1[i+1] = l, r
+	}
+
+	for i := 0; i < 256; i += 2 {
+		l ^= getNextWord(salt, &j)
+		r ^= getNextWord(salt, &j)
+		l, r = encryptBlock(l, r, c)
+		c.s2[i], c.s2[i+1] = l, r
+	}
+
+	for i := 0; i < 256; i += 2 {
+		l ^= getNextWord(salt, &j)
+		r ^= getNextWord(salt, &j)
+		l, r = encryptBlock(l, r, c)
+		c.s3[i], c.s3[i+1] = l, r
+	}
+}
+
+func encryptBlock(l, r uint32, c *Cipher) (uint32, uint32) {
+	xl, xr := l, r
+	xl ^= c.p[0]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[1]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[2]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[3]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[4]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[5]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[6]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[7]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[8]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[9]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[10]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[11]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[12]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[13]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[14]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[15]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[16]
+	xr ^= c.p[17]
+	return xr, xl
+}
+
+func decryptBlock(l, r uint32, c *Cipher) (uint32, uint32) {
+	xl, xr := l, r
+	xl ^= c.p[17]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[16]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[15]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[14]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[13]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[12]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[11]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[10]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[9]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[8]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[7]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[6]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[5]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[4]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[3]
+	xr ^= ((c.s0[byte(xl>>24)] + c.s1[byte(xl>>16)]) ^ c.s2[byte(xl>>8)]) + c.s3[byte(xl)] ^ c.p[2]
+	xl ^= ((c.s0[byte(xr>>24)] + c.s1[byte(xr>>16)]) ^ c.s2[byte(xr>>8)]) + c.s3[byte(xr)] ^ c.p[1]
+	xr ^= c.p[0]
+	return xr, xl
+}
diff --git a/vendor/golang.org/x/crypto/blowfish/cipher.go b/vendor/golang.org/x/crypto/blowfish/cipher.go
new file mode 100644
index 000000000..2641dadd6
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blowfish/cipher.go
@@ -0,0 +1,91 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package blowfish implements Bruce Schneier's Blowfish encryption algorithm.
+package blowfish // import "golang.org/x/crypto/blowfish"
+
+// The code is a port of Bruce Schneier's C implementation.
+// See https://www.schneier.com/blowfish.html.
+
+import "strconv"
+
+// The Blowfish block size in bytes.
+const BlockSize = 8
+
+// A Cipher is an instance of Blowfish encryption using a particular key.
+type Cipher struct {
+	p              [18]uint32
+	s0, s1, s2, s3 [256]uint32
+}
+
+type KeySizeError int
+
+func (k KeySizeError) Error() string {
+	return "crypto/blowfish: invalid key size " + strconv.Itoa(int(k))
+}
+
+// NewCipher creates and returns a Cipher.
+// The key argument should be the Blowfish key, from 1 to 56 bytes.
+func NewCipher(key []byte) (*Cipher, error) {
+	var result Cipher
+	if k := len(key); k < 1 || k > 56 {
+		return nil, KeySizeError(k)
+	}
+	initCipher(&result)
+	ExpandKey(key, &result)
+	return &result, nil
+}
+
+// NewSaltedCipher creates a returns a Cipher that folds a salt into its key
+// schedule. For most purposes, NewCipher, instead of NewSaltedCipher, is
+// sufficient and desirable. For bcrypt compatibility, the key can be over 56
+// bytes.
+func NewSaltedCipher(key, salt []byte) (*Cipher, error) {
+	if len(salt) == 0 {
+		return NewCipher(key)
+	}
+	var result Cipher
+	if k := len(key); k < 1 {
+		return nil, KeySizeError(k)
+	}
+	initCipher(&result)
+	expandKeyWithSalt(key, salt, &result)
+	return &result, nil
+}
+
+// BlockSize returns the Blowfish block size, 8 bytes.
+// It is necessary to satisfy the Block interface in the
+// package "crypto/cipher".
+func (c *Cipher) BlockSize() int { return BlockSize }
+
+// Encrypt encrypts the 8-byte buffer src using the key k
+// and stores the result in dst.
+// Note that for amounts of data larger than a block,
+// it is not safe to just call Encrypt on successive blocks;
+// instead, use an encryption mode like CBC (see crypto/cipher/cbc.go).
+func (c *Cipher) Encrypt(dst, src []byte) {
+	l := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+	r := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7])
+	l, r = encryptBlock(l, r, c)
+	dst[0], dst[1], dst[2], dst[3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l)
+	dst[4], dst[5], dst[6], dst[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r)
+}
+
+// Decrypt decrypts the 8-byte buffer src using the key k
+// and stores the result in dst.
+func (c *Cipher) Decrypt(dst, src []byte) {
+	l := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+	r := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7])
+	l, r = decryptBlock(l, r, c)
+	dst[0], dst[1], dst[2], dst[3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l)
+	dst[4], dst[5], dst[6], dst[7] = byte(r>>24), byte(r>>16), byte(r>>8), byte(r)
+}
+
+func initCipher(c *Cipher) {
+	copy(c.p[0:], p[0:])
+	copy(c.s0[0:], s0[0:])
+	copy(c.s1[0:], s1[0:])
+	copy(c.s2[0:], s2[0:])
+	copy(c.s3[0:], s3[0:])
+}
diff --git a/vendor/golang.org/x/crypto/blowfish/const.go b/vendor/golang.org/x/crypto/blowfish/const.go
new file mode 100644
index 000000000..d04077595
--- /dev/null
+++ b/vendor/golang.org/x/crypto/blowfish/const.go
@@ -0,0 +1,199 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The startup permutation array and substitution boxes.
+// They are the hexadecimal digits of PI; see:
+// https://www.schneier.com/code/constants.txt.
+
+package blowfish
+
+var s0 = [256]uint32{
+	0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
+	0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+	0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658,
+	0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+	0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
+	0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+	0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6,
+	0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+	0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c,
+	0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+	0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1,
+	0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+	0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a,
+	0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+	0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
+	0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+	0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706,
+	0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+	0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b,
+	0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+	0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c,
+	0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+	0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a,
+	0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+	0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
+	0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+	0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8,
+	0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+	0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33,
+	0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+	0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0,
+	0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+	0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777,
+	0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+	0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
+	0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+	0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e,
+	0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+	0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9,
+	0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+	0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f,
+	0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+	0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
+}
+
+var s1 = [256]uint32{
+	0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d,
+	0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+	0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65,
+	0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+	0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9,
+	0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+	0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d,
+	0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+	0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
+	0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+	0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908,
+	0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+	0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124,
+	0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+	0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908,
+	0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+	0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b,
+	0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+	0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
+	0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+	0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d,
+	0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+	0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5,
+	0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+	0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96,
+	0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+	0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca,
+	0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+	0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
+	0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+	0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054,
+	0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+	0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea,
+	0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+	0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646,
+	0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+	0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea,
+	0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+	0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
+	0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+	0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd,
+	0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+	0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
+}
+
+var s2 = [256]uint32{
+	0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7,
+	0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+	0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
+	0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+	0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4,
+	0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+	0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec,
+	0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+	0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332,
+	0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+	0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58,
+	0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+	0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
+	0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+	0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60,
+	0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+	0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
+	0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+	0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74,
+	0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+	0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
+	0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+	0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
+	0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+	0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
+	0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+	0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
+	0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+	0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
+	0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+	0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
+	0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+	0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
+	0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+	0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
+	0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+	0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0,
+	0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+	0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188,
+	0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+	0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8,
+	0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+	0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
+}
+
+var s3 = [256]uint32{
+	0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742,
+	0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+	0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79,
+	0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+	0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a,
+	0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+	0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
+	0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+	0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797,
+	0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+	0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6,
+	0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+	0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba,
+	0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+	0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5,
+	0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+	0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
+	0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+	0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd,
+	0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+	0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb,
+	0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+	0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc,
+	0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+	0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc,
+	0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+	0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
+	0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+	0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a,
+	0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+	0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b,
+	0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+	0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e,
+	0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+	0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623,
+	0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+	0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
+	0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+	0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3,
+	0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+	0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c,
+	0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+	0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6,
+}
+
+var p = [18]uint32{
+	0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
+	0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+	0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b,
+}
diff --git a/vendor/golang.org/x/crypto/sha3/doc.go b/vendor/golang.org/x/crypto/sha3/doc.go
new file mode 100644
index 000000000..a0ee3ae72
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/doc.go
@@ -0,0 +1,66 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package sha3 implements the SHA-3 fixed-output-length hash functions and
+// the SHAKE variable-output-length hash functions defined by FIPS-202.
+//
+// Both types of hash function use the "sponge" construction and the Keccak
+// permutation. For a detailed specification see http://keccak.noekeon.org/
+//
+//
+// Guidance
+//
+// If you aren't sure what function you need, use SHAKE256 with at least 64
+// bytes of output. The SHAKE instances are faster than the SHA3 instances;
+// the latter have to allocate memory to conform to the hash.Hash interface.
+//
+// If you need a secret-key MAC (message authentication code), prepend the
+// secret key to the input, hash with SHAKE256 and read at least 32 bytes of
+// output.
+//
+//
+// Security strengths
+//
+// The SHA3-x (x equals 224, 256, 384, or 512) functions have a security
+// strength against preimage attacks of x bits. Since they only produce "x"
+// bits of output, their collision-resistance is only "x/2" bits.
+//
+// The SHAKE-256 and -128 functions have a generic security strength of 256 and
+// 128 bits against all attacks, provided that at least 2x bits of their output
+// is used.  Requesting more than 64 or 32 bytes of output, respectively, does
+// not increase the collision-resistance of the SHAKE functions.
+//
+//
+// The sponge construction
+//
+// A sponge builds a pseudo-random function from a public pseudo-random
+// permutation, by applying the permutation to a state of "rate + capacity"
+// bytes, but hiding "capacity" of the bytes.
+//
+// A sponge starts out with a zero state. To hash an input using a sponge, up
+// to "rate" bytes of the input are XORed into the sponge's state. The sponge
+// is then "full" and the permutation is applied to "empty" it. This process is
+// repeated until all the input has been "absorbed". The input is then padded.
+// The digest is "squeezed" from the sponge in the same way, except that output
+// output is copied out instead of input being XORed in.
+//
+// A sponge is parameterized by its generic security strength, which is equal
+// to half its capacity; capacity + rate is equal to the permutation's width.
+// Since the KeccakF-1600 permutation is 1600 bits (200 bytes) wide, this means
+// that the security strength of a sponge instance is equal to (1600 - bitrate) / 2.
+//
+//
+// Recommendations
+//
+// The SHAKE functions are recommended for most new uses. They can produce
+// output of arbitrary length. SHAKE256, with an output length of at least
+// 64 bytes, provides 256-bit security against all attacks.  The Keccak team
+// recommends it for most applications upgrading from SHA2-512. (NIST chose a
+// much stronger, but much slower, sponge instance for SHA3-512.)
+//
+// The SHA-3 functions are "drop-in" replacements for the SHA-2 functions.
+// They produce output of the same length, with the same security strengths
+// against all attacks. This means, in particular, that SHA3-256 only has
+// 128-bit collision resistance, because its output length is 32 bytes.
+package sha3 // import "golang.org/x/crypto/sha3"
diff --git a/vendor/golang.org/x/crypto/sha3/hashes.go b/vendor/golang.org/x/crypto/sha3/hashes.go
new file mode 100644
index 000000000..2b51cf4e9
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/hashes.go
@@ -0,0 +1,65 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+// This file provides functions for creating instances of the SHA-3
+// and SHAKE hash functions, as well as utility functions for hashing
+// bytes.
+
+import (
+	"hash"
+)
+
+// New224 creates a new SHA3-224 hash.
+// Its generic security strength is 224 bits against preimage attacks,
+// and 112 bits against collision attacks.
+func New224() hash.Hash { return &state{rate: 144, outputLen: 28, dsbyte: 0x06} }
+
+// New256 creates a new SHA3-256 hash.
+// Its generic security strength is 256 bits against preimage attacks,
+// and 128 bits against collision attacks.
+func New256() hash.Hash { return &state{rate: 136, outputLen: 32, dsbyte: 0x06} }
+
+// New384 creates a new SHA3-384 hash.
+// Its generic security strength is 384 bits against preimage attacks,
+// and 192 bits against collision attacks.
+func New384() hash.Hash { return &state{rate: 104, outputLen: 48, dsbyte: 0x06} }
+
+// New512 creates a new SHA3-512 hash.
+// Its generic security strength is 512 bits against preimage attacks,
+// and 256 bits against collision attacks.
+func New512() hash.Hash { return &state{rate: 72, outputLen: 64, dsbyte: 0x06} }
+
+// Sum224 returns the SHA3-224 digest of the data.
+func Sum224(data []byte) (digest [28]byte) {
+	h := New224()
+	h.Write(data)
+	h.Sum(digest[:0])
+	return
+}
+
+// Sum256 returns the SHA3-256 digest of the data.
+func Sum256(data []byte) (digest [32]byte) {
+	h := New256()
+	h.Write(data)
+	h.Sum(digest[:0])
+	return
+}
+
+// Sum384 returns the SHA3-384 digest of the data.
+func Sum384(data []byte) (digest [48]byte) {
+	h := New384()
+	h.Write(data)
+	h.Sum(digest[:0])
+	return
+}
+
+// Sum512 returns the SHA3-512 digest of the data.
+func Sum512(data []byte) (digest [64]byte) {
+	h := New512()
+	h.Write(data)
+	h.Sum(digest[:0])
+	return
+}
diff --git a/vendor/golang.org/x/crypto/sha3/keccakf.go b/vendor/golang.org/x/crypto/sha3/keccakf.go
new file mode 100644
index 000000000..46d03ed38
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/keccakf.go
@@ -0,0 +1,412 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//  +build !amd64 appengine gccgo
+
+package sha3
+
+// rc stores the round constants for use in the ι step.
+var rc = [24]uint64{
+	0x0000000000000001,
+	0x0000000000008082,
+	0x800000000000808A,
+	0x8000000080008000,
+	0x000000000000808B,
+	0x0000000080000001,
+	0x8000000080008081,
+	0x8000000000008009,
+	0x000000000000008A,
+	0x0000000000000088,
+	0x0000000080008009,
+	0x000000008000000A,
+	0x000000008000808B,
+	0x800000000000008B,
+	0x8000000000008089,
+	0x8000000000008003,
+	0x8000000000008002,
+	0x8000000000000080,
+	0x000000000000800A,
+	0x800000008000000A,
+	0x8000000080008081,
+	0x8000000000008080,
+	0x0000000080000001,
+	0x8000000080008008,
+}
+
+// keccakF1600 applies the Keccak permutation to a 1600b-wide
+// state represented as a slice of 25 uint64s.
+func keccakF1600(a *[25]uint64) {
+	// Implementation translated from Keccak-inplace.c
+	// in the keccak reference code.
+	var t, bc0, bc1, bc2, bc3, bc4, d0, d1, d2, d3, d4 uint64
+
+	for i := 0; i < 24; i += 4 {
+		// Combines the 5 steps in each round into 2 steps.
+		// Unrolls 4 rounds per loop and spreads some steps across rounds.
+
+		// Round 1
+		bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
+		bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
+		bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
+		bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
+		bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
+		d0 = bc4 ^ (bc1<<1 | bc1>>63)
+		d1 = bc0 ^ (bc2<<1 | bc2>>63)
+		d2 = bc1 ^ (bc3<<1 | bc3>>63)
+		d3 = bc2 ^ (bc4<<1 | bc4>>63)
+		d4 = bc3 ^ (bc0<<1 | bc0>>63)
+
+		bc0 = a[0] ^ d0
+		t = a[6] ^ d1
+		bc1 = t<<44 | t>>(64-44)
+		t = a[12] ^ d2
+		bc2 = t<<43 | t>>(64-43)
+		t = a[18] ^ d3
+		bc3 = t<<21 | t>>(64-21)
+		t = a[24] ^ d4
+		bc4 = t<<14 | t>>(64-14)
+		a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i]
+		a[6] = bc1 ^ (bc3 &^ bc2)
+		a[12] = bc2 ^ (bc4 &^ bc3)
+		a[18] = bc3 ^ (bc0 &^ bc4)
+		a[24] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[10] ^ d0
+		bc2 = t<<3 | t>>(64-3)
+		t = a[16] ^ d1
+		bc3 = t<<45 | t>>(64-45)
+		t = a[22] ^ d2
+		bc4 = t<<61 | t>>(64-61)
+		t = a[3] ^ d3
+		bc0 = t<<28 | t>>(64-28)
+		t = a[9] ^ d4
+		bc1 = t<<20 | t>>(64-20)
+		a[10] = bc0 ^ (bc2 &^ bc1)
+		a[16] = bc1 ^ (bc3 &^ bc2)
+		a[22] = bc2 ^ (bc4 &^ bc3)
+		a[3] = bc3 ^ (bc0 &^ bc4)
+		a[9] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[20] ^ d0
+		bc4 = t<<18 | t>>(64-18)
+		t = a[1] ^ d1
+		bc0 = t<<1 | t>>(64-1)
+		t = a[7] ^ d2
+		bc1 = t<<6 | t>>(64-6)
+		t = a[13] ^ d3
+		bc2 = t<<25 | t>>(64-25)
+		t = a[19] ^ d4
+		bc3 = t<<8 | t>>(64-8)
+		a[20] = bc0 ^ (bc2 &^ bc1)
+		a[1] = bc1 ^ (bc3 &^ bc2)
+		a[7] = bc2 ^ (bc4 &^ bc3)
+		a[13] = bc3 ^ (bc0 &^ bc4)
+		a[19] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[5] ^ d0
+		bc1 = t<<36 | t>>(64-36)
+		t = a[11] ^ d1
+		bc2 = t<<10 | t>>(64-10)
+		t = a[17] ^ d2
+		bc3 = t<<15 | t>>(64-15)
+		t = a[23] ^ d3
+		bc4 = t<<56 | t>>(64-56)
+		t = a[4] ^ d4
+		bc0 = t<<27 | t>>(64-27)
+		a[5] = bc0 ^ (bc2 &^ bc1)
+		a[11] = bc1 ^ (bc3 &^ bc2)
+		a[17] = bc2 ^ (bc4 &^ bc3)
+		a[23] = bc3 ^ (bc0 &^ bc4)
+		a[4] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[15] ^ d0
+		bc3 = t<<41 | t>>(64-41)
+		t = a[21] ^ d1
+		bc4 = t<<2 | t>>(64-2)
+		t = a[2] ^ d2
+		bc0 = t<<62 | t>>(64-62)
+		t = a[8] ^ d3
+		bc1 = t<<55 | t>>(64-55)
+		t = a[14] ^ d4
+		bc2 = t<<39 | t>>(64-39)
+		a[15] = bc0 ^ (bc2 &^ bc1)
+		a[21] = bc1 ^ (bc3 &^ bc2)
+		a[2] = bc2 ^ (bc4 &^ bc3)
+		a[8] = bc3 ^ (bc0 &^ bc4)
+		a[14] = bc4 ^ (bc1 &^ bc0)
+
+		// Round 2
+		bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
+		bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
+		bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
+		bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
+		bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
+		d0 = bc4 ^ (bc1<<1 | bc1>>63)
+		d1 = bc0 ^ (bc2<<1 | bc2>>63)
+		d2 = bc1 ^ (bc3<<1 | bc3>>63)
+		d3 = bc2 ^ (bc4<<1 | bc4>>63)
+		d4 = bc3 ^ (bc0<<1 | bc0>>63)
+
+		bc0 = a[0] ^ d0
+		t = a[16] ^ d1
+		bc1 = t<<44 | t>>(64-44)
+		t = a[7] ^ d2
+		bc2 = t<<43 | t>>(64-43)
+		t = a[23] ^ d3
+		bc3 = t<<21 | t>>(64-21)
+		t = a[14] ^ d4
+		bc4 = t<<14 | t>>(64-14)
+		a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+1]
+		a[16] = bc1 ^ (bc3 &^ bc2)
+		a[7] = bc2 ^ (bc4 &^ bc3)
+		a[23] = bc3 ^ (bc0 &^ bc4)
+		a[14] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[20] ^ d0
+		bc2 = t<<3 | t>>(64-3)
+		t = a[11] ^ d1
+		bc3 = t<<45 | t>>(64-45)
+		t = a[2] ^ d2
+		bc4 = t<<61 | t>>(64-61)
+		t = a[18] ^ d3
+		bc0 = t<<28 | t>>(64-28)
+		t = a[9] ^ d4
+		bc1 = t<<20 | t>>(64-20)
+		a[20] = bc0 ^ (bc2 &^ bc1)
+		a[11] = bc1 ^ (bc3 &^ bc2)
+		a[2] = bc2 ^ (bc4 &^ bc3)
+		a[18] = bc3 ^ (bc0 &^ bc4)
+		a[9] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[15] ^ d0
+		bc4 = t<<18 | t>>(64-18)
+		t = a[6] ^ d1
+		bc0 = t<<1 | t>>(64-1)
+		t = a[22] ^ d2
+		bc1 = t<<6 | t>>(64-6)
+		t = a[13] ^ d3
+		bc2 = t<<25 | t>>(64-25)
+		t = a[4] ^ d4
+		bc3 = t<<8 | t>>(64-8)
+		a[15] = bc0 ^ (bc2 &^ bc1)
+		a[6] = bc1 ^ (bc3 &^ bc2)
+		a[22] = bc2 ^ (bc4 &^ bc3)
+		a[13] = bc3 ^ (bc0 &^ bc4)
+		a[4] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[10] ^ d0
+		bc1 = t<<36 | t>>(64-36)
+		t = a[1] ^ d1
+		bc2 = t<<10 | t>>(64-10)
+		t = a[17] ^ d2
+		bc3 = t<<15 | t>>(64-15)
+		t = a[8] ^ d3
+		bc4 = t<<56 | t>>(64-56)
+		t = a[24] ^ d4
+		bc0 = t<<27 | t>>(64-27)
+		a[10] = bc0 ^ (bc2 &^ bc1)
+		a[1] = bc1 ^ (bc3 &^ bc2)
+		a[17] = bc2 ^ (bc4 &^ bc3)
+		a[8] = bc3 ^ (bc0 &^ bc4)
+		a[24] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[5] ^ d0
+		bc3 = t<<41 | t>>(64-41)
+		t = a[21] ^ d1
+		bc4 = t<<2 | t>>(64-2)
+		t = a[12] ^ d2
+		bc0 = t<<62 | t>>(64-62)
+		t = a[3] ^ d3
+		bc1 = t<<55 | t>>(64-55)
+		t = a[19] ^ d4
+		bc2 = t<<39 | t>>(64-39)
+		a[5] = bc0 ^ (bc2 &^ bc1)
+		a[21] = bc1 ^ (bc3 &^ bc2)
+		a[12] = bc2 ^ (bc4 &^ bc3)
+		a[3] = bc3 ^ (bc0 &^ bc4)
+		a[19] = bc4 ^ (bc1 &^ bc0)
+
+		// Round 3
+		bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
+		bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
+		bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
+		bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
+		bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
+		d0 = bc4 ^ (bc1<<1 | bc1>>63)
+		d1 = bc0 ^ (bc2<<1 | bc2>>63)
+		d2 = bc1 ^ (bc3<<1 | bc3>>63)
+		d3 = bc2 ^ (bc4<<1 | bc4>>63)
+		d4 = bc3 ^ (bc0<<1 | bc0>>63)
+
+		bc0 = a[0] ^ d0
+		t = a[11] ^ d1
+		bc1 = t<<44 | t>>(64-44)
+		t = a[22] ^ d2
+		bc2 = t<<43 | t>>(64-43)
+		t = a[8] ^ d3
+		bc3 = t<<21 | t>>(64-21)
+		t = a[19] ^ d4
+		bc4 = t<<14 | t>>(64-14)
+		a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+2]
+		a[11] = bc1 ^ (bc3 &^ bc2)
+		a[22] = bc2 ^ (bc4 &^ bc3)
+		a[8] = bc3 ^ (bc0 &^ bc4)
+		a[19] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[15] ^ d0
+		bc2 = t<<3 | t>>(64-3)
+		t = a[1] ^ d1
+		bc3 = t<<45 | t>>(64-45)
+		t = a[12] ^ d2
+		bc4 = t<<61 | t>>(64-61)
+		t = a[23] ^ d3
+		bc0 = t<<28 | t>>(64-28)
+		t = a[9] ^ d4
+		bc1 = t<<20 | t>>(64-20)
+		a[15] = bc0 ^ (bc2 &^ bc1)
+		a[1] = bc1 ^ (bc3 &^ bc2)
+		a[12] = bc2 ^ (bc4 &^ bc3)
+		a[23] = bc3 ^ (bc0 &^ bc4)
+		a[9] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[5] ^ d0
+		bc4 = t<<18 | t>>(64-18)
+		t = a[16] ^ d1
+		bc0 = t<<1 | t>>(64-1)
+		t = a[2] ^ d2
+		bc1 = t<<6 | t>>(64-6)
+		t = a[13] ^ d3
+		bc2 = t<<25 | t>>(64-25)
+		t = a[24] ^ d4
+		bc3 = t<<8 | t>>(64-8)
+		a[5] = bc0 ^ (bc2 &^ bc1)
+		a[16] = bc1 ^ (bc3 &^ bc2)
+		a[2] = bc2 ^ (bc4 &^ bc3)
+		a[13] = bc3 ^ (bc0 &^ bc4)
+		a[24] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[20] ^ d0
+		bc1 = t<<36 | t>>(64-36)
+		t = a[6] ^ d1
+		bc2 = t<<10 | t>>(64-10)
+		t = a[17] ^ d2
+		bc3 = t<<15 | t>>(64-15)
+		t = a[3] ^ d3
+		bc4 = t<<56 | t>>(64-56)
+		t = a[14] ^ d4
+		bc0 = t<<27 | t>>(64-27)
+		a[20] = bc0 ^ (bc2 &^ bc1)
+		a[6] = bc1 ^ (bc3 &^ bc2)
+		a[17] = bc2 ^ (bc4 &^ bc3)
+		a[3] = bc3 ^ (bc0 &^ bc4)
+		a[14] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[10] ^ d0
+		bc3 = t<<41 | t>>(64-41)
+		t = a[21] ^ d1
+		bc4 = t<<2 | t>>(64-2)
+		t = a[7] ^ d2
+		bc0 = t<<62 | t>>(64-62)
+		t = a[18] ^ d3
+		bc1 = t<<55 | t>>(64-55)
+		t = a[4] ^ d4
+		bc2 = t<<39 | t>>(64-39)
+		a[10] = bc0 ^ (bc2 &^ bc1)
+		a[21] = bc1 ^ (bc3 &^ bc2)
+		a[7] = bc2 ^ (bc4 &^ bc3)
+		a[18] = bc3 ^ (bc0 &^ bc4)
+		a[4] = bc4 ^ (bc1 &^ bc0)
+
+		// Round 4
+		bc0 = a[0] ^ a[5] ^ a[10] ^ a[15] ^ a[20]
+		bc1 = a[1] ^ a[6] ^ a[11] ^ a[16] ^ a[21]
+		bc2 = a[2] ^ a[7] ^ a[12] ^ a[17] ^ a[22]
+		bc3 = a[3] ^ a[8] ^ a[13] ^ a[18] ^ a[23]
+		bc4 = a[4] ^ a[9] ^ a[14] ^ a[19] ^ a[24]
+		d0 = bc4 ^ (bc1<<1 | bc1>>63)
+		d1 = bc0 ^ (bc2<<1 | bc2>>63)
+		d2 = bc1 ^ (bc3<<1 | bc3>>63)
+		d3 = bc2 ^ (bc4<<1 | bc4>>63)
+		d4 = bc3 ^ (bc0<<1 | bc0>>63)
+
+		bc0 = a[0] ^ d0
+		t = a[1] ^ d1
+		bc1 = t<<44 | t>>(64-44)
+		t = a[2] ^ d2
+		bc2 = t<<43 | t>>(64-43)
+		t = a[3] ^ d3
+		bc3 = t<<21 | t>>(64-21)
+		t = a[4] ^ d4
+		bc4 = t<<14 | t>>(64-14)
+		a[0] = bc0 ^ (bc2 &^ bc1) ^ rc[i+3]
+		a[1] = bc1 ^ (bc3 &^ bc2)
+		a[2] = bc2 ^ (bc4 &^ bc3)
+		a[3] = bc3 ^ (bc0 &^ bc4)
+		a[4] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[5] ^ d0
+		bc2 = t<<3 | t>>(64-3)
+		t = a[6] ^ d1
+		bc3 = t<<45 | t>>(64-45)
+		t = a[7] ^ d2
+		bc4 = t<<61 | t>>(64-61)
+		t = a[8] ^ d3
+		bc0 = t<<28 | t>>(64-28)
+		t = a[9] ^ d4
+		bc1 = t<<20 | t>>(64-20)
+		a[5] = bc0 ^ (bc2 &^ bc1)
+		a[6] = bc1 ^ (bc3 &^ bc2)
+		a[7] = bc2 ^ (bc4 &^ bc3)
+		a[8] = bc3 ^ (bc0 &^ bc4)
+		a[9] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[10] ^ d0
+		bc4 = t<<18 | t>>(64-18)
+		t = a[11] ^ d1
+		bc0 = t<<1 | t>>(64-1)
+		t = a[12] ^ d2
+		bc1 = t<<6 | t>>(64-6)
+		t = a[13] ^ d3
+		bc2 = t<<25 | t>>(64-25)
+		t = a[14] ^ d4
+		bc3 = t<<8 | t>>(64-8)
+		a[10] = bc0 ^ (bc2 &^ bc1)
+		a[11] = bc1 ^ (bc3 &^ bc2)
+		a[12] = bc2 ^ (bc4 &^ bc3)
+		a[13] = bc3 ^ (bc0 &^ bc4)
+		a[14] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[15] ^ d0
+		bc1 = t<<36 | t>>(64-36)
+		t = a[16] ^ d1
+		bc2 = t<<10 | t>>(64-10)
+		t = a[17] ^ d2
+		bc3 = t<<15 | t>>(64-15)
+		t = a[18] ^ d3
+		bc4 = t<<56 | t>>(64-56)
+		t = a[19] ^ d4
+		bc0 = t<<27 | t>>(64-27)
+		a[15] = bc0 ^ (bc2 &^ bc1)
+		a[16] = bc1 ^ (bc3 &^ bc2)
+		a[17] = bc2 ^ (bc4 &^ bc3)
+		a[18] = bc3 ^ (bc0 &^ bc4)
+		a[19] = bc4 ^ (bc1 &^ bc0)
+
+		t = a[20] ^ d0
+		bc3 = t<<41 | t>>(64-41)
+		t = a[21] ^ d1
+		bc4 = t<<2 | t>>(64-2)
+		t = a[22] ^ d2
+		bc0 = t<<62 | t>>(64-62)
+		t = a[23] ^ d3
+		bc1 = t<<55 | t>>(64-55)
+		t = a[24] ^ d4
+		bc2 = t<<39 | t>>(64-39)
+		a[20] = bc0 ^ (bc2 &^ bc1)
+		a[21] = bc1 ^ (bc3 &^ bc2)
+		a[22] = bc2 ^ (bc4 &^ bc3)
+		a[23] = bc3 ^ (bc0 &^ bc4)
+		a[24] = bc4 ^ (bc1 &^ bc0)
+	}
+}
diff --git a/vendor/golang.org/x/crypto/sha3/keccakf_amd64.go b/vendor/golang.org/x/crypto/sha3/keccakf_amd64.go
new file mode 100644
index 000000000..788679585
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/keccakf_amd64.go
@@ -0,0 +1,13 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64,!appengine,!gccgo
+
+package sha3
+
+// This function is implemented in keccakf_amd64.s.
+
+//go:noescape
+
+func keccakF1600(a *[25]uint64)
diff --git a/vendor/golang.org/x/crypto/sha3/keccakf_amd64.s b/vendor/golang.org/x/crypto/sha3/keccakf_amd64.s
new file mode 100644
index 000000000..f88533acc
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/keccakf_amd64.s
@@ -0,0 +1,390 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64,!appengine,!gccgo
+
+// This code was translated into a form compatible with 6a from the public
+// domain sources at https://github.com/gvanas/KeccakCodePackage
+
+// Offsets in state
+#define _ba  (0*8)
+#define _be  (1*8)
+#define _bi  (2*8)
+#define _bo  (3*8)
+#define _bu  (4*8)
+#define _ga  (5*8)
+#define _ge  (6*8)
+#define _gi  (7*8)
+#define _go  (8*8)
+#define _gu  (9*8)
+#define _ka (10*8)
+#define _ke (11*8)
+#define _ki (12*8)
+#define _ko (13*8)
+#define _ku (14*8)
+#define _ma (15*8)
+#define _me (16*8)
+#define _mi (17*8)
+#define _mo (18*8)
+#define _mu (19*8)
+#define _sa (20*8)
+#define _se (21*8)
+#define _si (22*8)
+#define _so (23*8)
+#define _su (24*8)
+
+// Temporary registers
+#define rT1  AX
+
+// Round vars
+#define rpState DI
+#define rpStack SP
+
+#define rDa BX
+#define rDe CX
+#define rDi DX
+#define rDo R8
+#define rDu R9
+
+#define rBa R10
+#define rBe R11
+#define rBi R12
+#define rBo R13
+#define rBu R14
+
+#define rCa SI
+#define rCe BP
+#define rCi rBi
+#define rCo rBo
+#define rCu R15
+
+#define MOVQ_RBI_RCE MOVQ rBi, rCe
+#define XORQ_RT1_RCA XORQ rT1, rCa
+#define XORQ_RT1_RCE XORQ rT1, rCe
+#define XORQ_RBA_RCU XORQ rBa, rCu
+#define XORQ_RBE_RCU XORQ rBe, rCu
+#define XORQ_RDU_RCU XORQ rDu, rCu
+#define XORQ_RDA_RCA XORQ rDa, rCa
+#define XORQ_RDE_RCE XORQ rDe, rCe
+
+#define mKeccakRound(iState, oState, rc, B_RBI_RCE, G_RT1_RCA, G_RT1_RCE, G_RBA_RCU, K_RT1_RCA, K_RT1_RCE, K_RBA_RCU, M_RT1_RCA, M_RT1_RCE, M_RBE_RCU, S_RDU_RCU, S_RDA_RCA, S_RDE_RCE) \
+	/* Prepare round */    \
+	MOVQ rCe, rDa;         \
+	ROLQ $1, rDa;          \
+	                       \
+	MOVQ _bi(iState), rCi; \
+	XORQ _gi(iState), rDi; \
+	XORQ rCu, rDa;         \
+	XORQ _ki(iState), rCi; \
+	XORQ _mi(iState), rDi; \
+	XORQ rDi, rCi;         \
+	                       \
+	MOVQ rCi, rDe;         \
+	ROLQ $1, rDe;          \
+	                       \
+	MOVQ _bo(iState), rCo; \
+	XORQ _go(iState), rDo; \
+	XORQ rCa, rDe;         \
+	XORQ _ko(iState), rCo; \
+	XORQ _mo(iState), rDo; \
+	XORQ rDo, rCo;         \
+	                       \
+	MOVQ rCo, rDi;         \
+	ROLQ $1, rDi;          \
+	                       \
+	MOVQ rCu, rDo;         \
+	XORQ rCe, rDi;         \
+	ROLQ $1, rDo;          \
+	                       \
+	MOVQ rCa, rDu;         \
+	XORQ rCi, rDo;         \
+	ROLQ $1, rDu;          \
+	                       \
+	/* Result b */         \
+	MOVQ _ba(iState), rBa; \
+	MOVQ _ge(iState), rBe; \
+	XORQ rCo, rDu;         \
+	MOVQ _ki(iState), rBi; \
+	MOVQ _mo(iState), rBo; \
+	MOVQ _su(iState), rBu; \
+	XORQ rDe, rBe;         \
+	ROLQ $44, rBe;         \
+	XORQ rDi, rBi;         \
+	XORQ rDa, rBa;         \
+	ROLQ $43, rBi;         \
+	                       \
+	MOVQ rBe, rCa;         \
+	MOVQ rc, rT1;          \
+	ORQ  rBi, rCa;         \
+	XORQ rBa, rT1;         \
+	XORQ rT1, rCa;         \
+	MOVQ rCa, _ba(oState); \
+	                       \
+	XORQ rDu, rBu;         \
+	ROLQ $14, rBu;         \
+	MOVQ rBa, rCu;         \
+	ANDQ rBe, rCu;         \
+	XORQ rBu, rCu;         \
+	MOVQ rCu, _bu(oState); \
+	                       \
+	XORQ rDo, rBo;         \
+	ROLQ $21, rBo;         \
+	MOVQ rBo, rT1;         \
+	ANDQ rBu, rT1;         \
+	XORQ rBi, rT1;         \
+	MOVQ rT1, _bi(oState); \
+	                       \
+	NOTQ rBi;              \
+	ORQ  rBa, rBu;         \
+	ORQ  rBo, rBi;         \
+	XORQ rBo, rBu;         \
+	XORQ rBe, rBi;         \
+	MOVQ rBu, _bo(oState); \
+	MOVQ rBi, _be(oState); \
+	B_RBI_RCE;             \
+	                       \
+	/* Result g */         \
+	MOVQ _gu(iState), rBe; \
+	XORQ rDu, rBe;         \
+	MOVQ _ka(iState), rBi; \
+	ROLQ $20, rBe;         \
+	XORQ rDa, rBi;         \
+	ROLQ $3, rBi;          \
+	MOVQ _bo(iState), rBa; \
+	MOVQ rBe, rT1;         \
+	ORQ  rBi, rT1;         \
+	XORQ rDo, rBa;         \
+	MOVQ _me(iState), rBo; \
+	MOVQ _si(iState), rBu; \
+	ROLQ $28, rBa;         \
+	XORQ rBa, rT1;         \
+	MOVQ rT1, _ga(oState); \
+	G_RT1_RCA;             \
+	                       \
+	XORQ rDe, rBo;         \
+	ROLQ $45, rBo;         \
+	MOVQ rBi, rT1;         \
+	ANDQ rBo, rT1;         \
+	XORQ rBe, rT1;         \
+	MOVQ rT1, _ge(oState); \
+	G_RT1_RCE;             \
+	                       \
+	XORQ rDi, rBu;         \
+	ROLQ $61, rBu;         \
+	MOVQ rBu, rT1;         \
+	ORQ  rBa, rT1;         \
+	XORQ rBo, rT1;         \
+	MOVQ rT1, _go(oState); \
+	                       \
+	ANDQ rBe, rBa;         \
+	XORQ rBu, rBa;         \
+	MOVQ rBa, _gu(oState); \
+	NOTQ rBu;              \
+	G_RBA_RCU;             \
+	                       \
+	ORQ  rBu, rBo;         \
+	XORQ rBi, rBo;         \
+	MOVQ rBo, _gi(oState); \
+	                       \
+	/* Result k */         \
+	MOVQ _be(iState), rBa; \
+	MOVQ _gi(iState), rBe; \
+	MOVQ _ko(iState), rBi; \
+	MOVQ _mu(iState), rBo; \
+	MOVQ _sa(iState), rBu; \
+	XORQ rDi, rBe;         \
+	ROLQ $6, rBe;          \
+	XORQ rDo, rBi;         \
+	ROLQ $25, rBi;         \
+	MOVQ rBe, rT1;         \
+	ORQ  rBi, rT1;         \
+	XORQ rDe, rBa;         \
+	ROLQ $1, rBa;          \
+	XORQ rBa, rT1;         \
+	MOVQ rT1, _ka(oState); \
+	K_RT1_RCA;             \
+	                       \
+	XORQ rDu, rBo;         \
+	ROLQ $8, rBo;          \
+	MOVQ rBi, rT1;         \
+	ANDQ rBo, rT1;         \
+	XORQ rBe, rT1;         \
+	MOVQ rT1, _ke(oState); \
+	K_RT1_RCE;             \
+	                       \
+	XORQ rDa, rBu;         \
+	ROLQ $18, rBu;         \
+	NOTQ rBo;              \
+	MOVQ rBo, rT1;         \
+	ANDQ rBu, rT1;         \
+	XORQ rBi, rT1;         \
+	MOVQ rT1, _ki(oState); \
+	                       \
+	MOVQ rBu, rT1;         \
+	ORQ  rBa, rT1;         \
+	XORQ rBo, rT1;         \
+	MOVQ rT1, _ko(oState); \
+	                       \
+	ANDQ rBe, rBa;         \
+	XORQ rBu, rBa;         \
+	MOVQ rBa, _ku(oState); \
+	K_RBA_RCU;             \
+	                       \
+	/* Result m */         \
+	MOVQ _ga(iState), rBe; \
+	XORQ rDa, rBe;         \
+	MOVQ _ke(iState), rBi; \
+	ROLQ $36, rBe;         \
+	XORQ rDe, rBi;         \
+	MOVQ _bu(iState), rBa; \
+	ROLQ $10, rBi;         \
+	MOVQ rBe, rT1;         \
+	MOVQ _mi(iState), rBo; \
+	ANDQ rBi, rT1;         \
+	XORQ rDu, rBa;         \
+	MOVQ _so(iState), rBu; \
+	ROLQ $27, rBa;         \
+	XORQ rBa, rT1;         \
+	MOVQ rT1, _ma(oState); \
+	M_RT1_RCA;             \
+	                       \
+	XORQ rDi, rBo;         \
+	ROLQ $15, rBo;         \
+	MOVQ rBi, rT1;         \
+	ORQ  rBo, rT1;         \
+	XORQ rBe, rT1;         \
+	MOVQ rT1, _me(oState); \
+	M_RT1_RCE;             \
+	                       \
+	XORQ rDo, rBu;         \
+	ROLQ $56, rBu;         \
+	NOTQ rBo;              \
+	MOVQ rBo, rT1;         \
+	ORQ  rBu, rT1;         \
+	XORQ rBi, rT1;         \
+	MOVQ rT1, _mi(oState); \
+	                       \
+	ORQ  rBa, rBe;         \
+	XORQ rBu, rBe;         \
+	MOVQ rBe, _mu(oState); \
+	                       \
+	ANDQ rBa, rBu;         \
+	XORQ rBo, rBu;         \
+	MOVQ rBu, _mo(oState); \
+	M_RBE_RCU;             \
+	                       \
+	/* Result s */         \
+	MOVQ _bi(iState), rBa; \
+	MOVQ _go(iState), rBe; \
+	MOVQ _ku(iState), rBi; \
+	XORQ rDi, rBa;         \
+	MOVQ _ma(iState), rBo; \
+	ROLQ $62, rBa;         \
+	XORQ rDo, rBe;         \
+	MOVQ _se(iState), rBu; \
+	ROLQ $55, rBe;         \
+	                       \
+	XORQ rDu, rBi;         \
+	MOVQ rBa, rDu;         \
+	XORQ rDe, rBu;         \
+	ROLQ $2, rBu;          \
+	ANDQ rBe, rDu;         \
+	XORQ rBu, rDu;         \
+	MOVQ rDu, _su(oState); \
+	                       \
+	ROLQ $39, rBi;         \
+	S_RDU_RCU;             \
+	NOTQ rBe;              \
+	XORQ rDa, rBo;         \
+	MOVQ rBe, rDa;         \
+	ANDQ rBi, rDa;         \
+	XORQ rBa, rDa;         \
+	MOVQ rDa, _sa(oState); \
+	S_RDA_RCA;             \
+	                       \
+	ROLQ $41, rBo;         \
+	MOVQ rBi, rDe;         \
+	ORQ  rBo, rDe;         \
+	XORQ rBe, rDe;         \
+	MOVQ rDe, _se(oState); \
+	S_RDE_RCE;             \
+	                       \
+	MOVQ rBo, rDi;         \
+	MOVQ rBu, rDo;         \
+	ANDQ rBu, rDi;         \
+	ORQ  rBa, rDo;         \
+	XORQ rBi, rDi;         \
+	XORQ rBo, rDo;         \
+	MOVQ rDi, _si(oState); \
+	MOVQ rDo, _so(oState)  \
+
+// func keccakF1600(state *[25]uint64)
+TEXT ·keccakF1600(SB), 0, $200-8
+	MOVQ state+0(FP), rpState
+
+	// Convert the user state into an internal state
+	NOTQ _be(rpState)
+	NOTQ _bi(rpState)
+	NOTQ _go(rpState)
+	NOTQ _ki(rpState)
+	NOTQ _mi(rpState)
+	NOTQ _sa(rpState)
+
+	// Execute the KeccakF permutation
+	MOVQ _ba(rpState), rCa
+	MOVQ _be(rpState), rCe
+	MOVQ _bu(rpState), rCu
+
+	XORQ _ga(rpState), rCa
+	XORQ _ge(rpState), rCe
+	XORQ _gu(rpState), rCu
+
+	XORQ _ka(rpState), rCa
+	XORQ _ke(rpState), rCe
+	XORQ _ku(rpState), rCu
+
+	XORQ _ma(rpState), rCa
+	XORQ _me(rpState), rCe
+	XORQ _mu(rpState), rCu
+
+	XORQ _sa(rpState), rCa
+	XORQ _se(rpState), rCe
+	MOVQ _si(rpState), rDi
+	MOVQ _so(rpState), rDo
+	XORQ _su(rpState), rCu
+
+	mKeccakRound(rpState, rpStack, $0x0000000000000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x0000000000008082, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x800000000000808a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000080008000, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x000000000000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000000008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x000000000000008a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x0000000000000088, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x0000000080008009, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x000000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x000000008000808b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x800000000000008b, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x8000000000008089, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000000008003, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x8000000000008002, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000000000080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x000000000000800a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x800000008000000a, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x8000000080008081, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000000008080, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpState, rpStack, $0x0000000080000001, MOVQ_RBI_RCE, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBA_RCU, XORQ_RT1_RCA, XORQ_RT1_RCE, XORQ_RBE_RCU, XORQ_RDU_RCU, XORQ_RDA_RCA, XORQ_RDE_RCE)
+	mKeccakRound(rpStack, rpState, $0x8000000080008008, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP)
+
+	// Revert the internal state to the user state
+	NOTQ _be(rpState)
+	NOTQ _bi(rpState)
+	NOTQ _go(rpState)
+	NOTQ _ki(rpState)
+	NOTQ _mi(rpState)
+	NOTQ _sa(rpState)
+
+	RET
diff --git a/vendor/golang.org/x/crypto/sha3/register.go b/vendor/golang.org/x/crypto/sha3/register.go
new file mode 100644
index 000000000..3cf6a22e0
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/register.go
@@ -0,0 +1,18 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.4
+
+package sha3
+
+import (
+	"crypto"
+)
+
+func init() {
+	crypto.RegisterHash(crypto.SHA3_224, New224)
+	crypto.RegisterHash(crypto.SHA3_256, New256)
+	crypto.RegisterHash(crypto.SHA3_384, New384)
+	crypto.RegisterHash(crypto.SHA3_512, New512)
+}
diff --git a/vendor/golang.org/x/crypto/sha3/sha3.go b/vendor/golang.org/x/crypto/sha3/sha3.go
new file mode 100644
index 000000000..b12a35c87
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/sha3.go
@@ -0,0 +1,192 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+// spongeDirection indicates the direction bytes are flowing through the sponge.
+type spongeDirection int
+
+const (
+	// spongeAbsorbing indicates that the sponge is absorbing input.
+	spongeAbsorbing spongeDirection = iota
+	// spongeSqueezing indicates that the sponge is being squeezed.
+	spongeSqueezing
+)
+
+const (
+	// maxRate is the maximum size of the internal buffer. SHAKE-256
+	// currently needs the largest buffer.
+	maxRate = 168
+)
+
+type state struct {
+	// Generic sponge components.
+	a    [25]uint64 // main state of the hash
+	buf  []byte     // points into storage
+	rate int        // the number of bytes of state to use
+
+	// dsbyte contains the "domain separation" bits and the first bit of
+	// the padding. Sections 6.1 and 6.2 of [1] separate the outputs of the
+	// SHA-3 and SHAKE functions by appending bitstrings to the message.
+	// Using a little-endian bit-ordering convention, these are "01" for SHA-3
+	// and "1111" for SHAKE, or 00000010b and 00001111b, respectively. Then the
+	// padding rule from section 5.1 is applied to pad the message to a multiple
+	// of the rate, which involves adding a "1" bit, zero or more "0" bits, and
+	// a final "1" bit. We merge the first "1" bit from the padding into dsbyte,
+	// giving 00000110b (0x06) and 00011111b (0x1f).
+	// [1] http://csrc.nist.gov/publications/drafts/fips-202/fips_202_draft.pdf
+	//     "Draft FIPS 202: SHA-3 Standard: Permutation-Based Hash and
+	//      Extendable-Output Functions (May 2014)"
+	dsbyte  byte
+	storage [maxRate]byte
+
+	// Specific to SHA-3 and SHAKE.
+	outputLen int             // the default output size in bytes
+	state     spongeDirection // whether the sponge is absorbing or squeezing
+}
+
+// BlockSize returns the rate of sponge underlying this hash function.
+func (d *state) BlockSize() int { return d.rate }
+
+// Size returns the output size of the hash function in bytes.
+func (d *state) Size() int { return d.outputLen }
+
+// Reset clears the internal state by zeroing the sponge state and
+// the byte buffer, and setting Sponge.state to absorbing.
+func (d *state) Reset() {
+	// Zero the permutation's state.
+	for i := range d.a {
+		d.a[i] = 0
+	}
+	d.state = spongeAbsorbing
+	d.buf = d.storage[:0]
+}
+
+func (d *state) clone() *state {
+	ret := *d
+	if ret.state == spongeAbsorbing {
+		ret.buf = ret.storage[:len(ret.buf)]
+	} else {
+		ret.buf = ret.storage[d.rate-cap(d.buf) : d.rate]
+	}
+
+	return &ret
+}
+
+// permute applies the KeccakF-1600 permutation. It handles
+// any input-output buffering.
+func (d *state) permute() {
+	switch d.state {
+	case spongeAbsorbing:
+		// If we're absorbing, we need to xor the input into the state
+		// before applying the permutation.
+		xorIn(d, d.buf)
+		d.buf = d.storage[:0]
+		keccakF1600(&d.a)
+	case spongeSqueezing:
+		// If we're squeezing, we need to apply the permutatin before
+		// copying more output.
+		keccakF1600(&d.a)
+		d.buf = d.storage[:d.rate]
+		copyOut(d, d.buf)
+	}
+}
+
+// pads appends the domain separation bits in dsbyte, applies
+// the multi-bitrate 10..1 padding rule, and permutes the state.
+func (d *state) padAndPermute(dsbyte byte) {
+	if d.buf == nil {
+		d.buf = d.storage[:0]
+	}
+	// Pad with this instance's domain-separator bits. We know that there's
+	// at least one byte of space in d.buf because, if it were full,
+	// permute would have been called to empty it. dsbyte also contains the
+	// first one bit for the padding. See the comment in the state struct.
+	d.buf = append(d.buf, dsbyte)
+	zerosStart := len(d.buf)
+	d.buf = d.storage[:d.rate]
+	for i := zerosStart; i < d.rate; i++ {
+		d.buf[i] = 0
+	}
+	// This adds the final one bit for the padding. Because of the way that
+	// bits are numbered from the LSB upwards, the final bit is the MSB of
+	// the last byte.
+	d.buf[d.rate-1] ^= 0x80
+	// Apply the permutation
+	d.permute()
+	d.state = spongeSqueezing
+	d.buf = d.storage[:d.rate]
+	copyOut(d, d.buf)
+}
+
+// Write absorbs more data into the hash's state. It produces an error
+// if more data is written to the ShakeHash after writing
+func (d *state) Write(p []byte) (written int, err error) {
+	if d.state != spongeAbsorbing {
+		panic("sha3: write to sponge after read")
+	}
+	if d.buf == nil {
+		d.buf = d.storage[:0]
+	}
+	written = len(p)
+
+	for len(p) > 0 {
+		if len(d.buf) == 0 && len(p) >= d.rate {
+			// The fast path; absorb a full "rate" bytes of input and apply the permutation.
+			xorIn(d, p[:d.rate])
+			p = p[d.rate:]
+			keccakF1600(&d.a)
+		} else {
+			// The slow path; buffer the input until we can fill the sponge, and then xor it in.
+			todo := d.rate - len(d.buf)
+			if todo > len(p) {
+				todo = len(p)
+			}
+			d.buf = append(d.buf, p[:todo]...)
+			p = p[todo:]
+
+			// If the sponge is full, apply the permutation.
+			if len(d.buf) == d.rate {
+				d.permute()
+			}
+		}
+	}
+
+	return
+}
+
+// Read squeezes an arbitrary number of bytes from the sponge.
+func (d *state) Read(out []byte) (n int, err error) {
+	// If we're still absorbing, pad and apply the permutation.
+	if d.state == spongeAbsorbing {
+		d.padAndPermute(d.dsbyte)
+	}
+
+	n = len(out)
+
+	// Now, do the squeezing.
+	for len(out) > 0 {
+		n := copy(out, d.buf)
+		d.buf = d.buf[n:]
+		out = out[n:]
+
+		// Apply the permutation if we've squeezed the sponge dry.
+		if len(d.buf) == 0 {
+			d.permute()
+		}
+	}
+
+	return
+}
+
+// Sum applies padding to the hash state and then squeezes out the desired
+// number of output bytes.
+func (d *state) Sum(in []byte) []byte {
+	// Make a copy of the original hash so that caller can keep writing
+	// and summing.
+	dup := d.clone()
+	hash := make([]byte, dup.outputLen)
+	dup.Read(hash)
+	return append(in, hash...)
+}
diff --git a/vendor/golang.org/x/crypto/sha3/shake.go b/vendor/golang.org/x/crypto/sha3/shake.go
new file mode 100644
index 000000000..841f9860f
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/shake.go
@@ -0,0 +1,60 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+// This file defines the ShakeHash interface, and provides
+// functions for creating SHAKE instances, as well as utility
+// functions for hashing bytes to arbitrary-length output.
+
+import (
+	"io"
+)
+
+// ShakeHash defines the interface to hash functions that
+// support arbitrary-length output.
+type ShakeHash interface {
+	// Write absorbs more data into the hash's state. It panics if input is
+	// written to it after output has been read from it.
+	io.Writer
+
+	// Read reads more output from the hash; reading affects the hash's
+	// state. (ShakeHash.Read is thus very different from Hash.Sum)
+	// It never returns an error.
+	io.Reader
+
+	// Clone returns a copy of the ShakeHash in its current state.
+	Clone() ShakeHash
+
+	// Reset resets the ShakeHash to its initial state.
+	Reset()
+}
+
+func (d *state) Clone() ShakeHash {
+	return d.clone()
+}
+
+// NewShake128 creates a new SHAKE128 variable-output-length ShakeHash.
+// Its generic security strength is 128 bits against all attacks if at
+// least 32 bytes of its output are used.
+func NewShake128() ShakeHash { return &state{rate: 168, dsbyte: 0x1f} }
+
+// NewShake256 creates a new SHAKE128 variable-output-length ShakeHash.
+// Its generic security strength is 256 bits against all attacks if
+// at least 64 bytes of its output are used.
+func NewShake256() ShakeHash { return &state{rate: 136, dsbyte: 0x1f} }
+
+// ShakeSum128 writes an arbitrary-length digest of data into hash.
+func ShakeSum128(hash, data []byte) {
+	h := NewShake128()
+	h.Write(data)
+	h.Read(hash)
+}
+
+// ShakeSum256 writes an arbitrary-length digest of data into hash.
+func ShakeSum256(hash, data []byte) {
+	h := NewShake256()
+	h.Write(data)
+	h.Read(hash)
+}
diff --git a/vendor/golang.org/x/crypto/sha3/xor.go b/vendor/golang.org/x/crypto/sha3/xor.go
new file mode 100644
index 000000000..46a0d63a6
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/xor.go
@@ -0,0 +1,16 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !amd64,!386,!ppc64le appengine
+
+package sha3
+
+var (
+	xorIn            = xorInGeneric
+	copyOut          = copyOutGeneric
+	xorInUnaligned   = xorInGeneric
+	copyOutUnaligned = copyOutGeneric
+)
+
+const xorImplementationUnaligned = "generic"
diff --git a/vendor/golang.org/x/crypto/sha3/xor_generic.go b/vendor/golang.org/x/crypto/sha3/xor_generic.go
new file mode 100644
index 000000000..fd35f02ef
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/xor_generic.go
@@ -0,0 +1,28 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sha3
+
+import "encoding/binary"
+
+// xorInGeneric xors the bytes in buf into the state; it
+// makes no non-portable assumptions about memory layout
+// or alignment.
+func xorInGeneric(d *state, buf []byte) {
+	n := len(buf) / 8
+
+	for i := 0; i < n; i++ {
+		a := binary.LittleEndian.Uint64(buf)
+		d.a[i] ^= a
+		buf = buf[8:]
+	}
+}
+
+// copyOutGeneric copies ulint64s to a byte buffer.
+func copyOutGeneric(d *state, b []byte) {
+	for i := 0; len(b) >= 8; i++ {
+		binary.LittleEndian.PutUint64(b, d.a[i])
+		b = b[8:]
+	}
+}
diff --git a/vendor/golang.org/x/crypto/sha3/xor_unaligned.go b/vendor/golang.org/x/crypto/sha3/xor_unaligned.go
new file mode 100644
index 000000000..929a486a7
--- /dev/null
+++ b/vendor/golang.org/x/crypto/sha3/xor_unaligned.go
@@ -0,0 +1,58 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build amd64 386 ppc64le
+// +build !appengine
+
+package sha3
+
+import "unsafe"
+
+func xorInUnaligned(d *state, buf []byte) {
+	bw := (*[maxRate / 8]uint64)(unsafe.Pointer(&buf[0]))
+	n := len(buf)
+	if n >= 72 {
+		d.a[0] ^= bw[0]
+		d.a[1] ^= bw[1]
+		d.a[2] ^= bw[2]
+		d.a[3] ^= bw[3]
+		d.a[4] ^= bw[4]
+		d.a[5] ^= bw[5]
+		d.a[6] ^= bw[6]
+		d.a[7] ^= bw[7]
+		d.a[8] ^= bw[8]
+	}
+	if n >= 104 {
+		d.a[9] ^= bw[9]
+		d.a[10] ^= bw[10]
+		d.a[11] ^= bw[11]
+		d.a[12] ^= bw[12]
+	}
+	if n >= 136 {
+		d.a[13] ^= bw[13]
+		d.a[14] ^= bw[14]
+		d.a[15] ^= bw[15]
+		d.a[16] ^= bw[16]
+	}
+	if n >= 144 {
+		d.a[17] ^= bw[17]
+	}
+	if n >= 168 {
+		d.a[18] ^= bw[18]
+		d.a[19] ^= bw[19]
+		d.a[20] ^= bw[20]
+	}
+}
+
+func copyOutUnaligned(d *state, buf []byte) {
+	ab := (*[maxRate]uint8)(unsafe.Pointer(&d.a[0]))
+	copy(buf, ab[:])
+}
+
+var (
+	xorIn   = xorInUnaligned
+	copyOut = copyOutUnaligned
+)
+
+const xorImplementationUnaligned = "unaligned"