Index: trunk/vendor/github.com/valyala/bytebufferpool/.travis.yml
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/.travis.yml	(revision 145)
+++ 	(revision )
@@ -1,15 +1,0 @@
-language: go
-
-go:
-  - 1.6
-
-script:
-  # build test for supported platforms
-  - GOOS=linux go build
-  - GOOS=darwin go build
-  - GOOS=freebsd go build
-  - GOOS=windows go build
-  - GOARCH=386 go build
-
-  # run tests on a standard platform
-  - go test -v ./...
Index: trunk/vendor/github.com/valyala/bytebufferpool/LICENSE
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/LICENSE	(revision 145)
+++ 	(revision )
@@ -1,22 +1,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Aliaksandr Valialkin, VertaMedia
-
-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.
-
Index: trunk/vendor/github.com/valyala/bytebufferpool/README.md
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/README.md	(revision 145)
+++ 	(revision )
@@ -1,21 +1,0 @@
-[![Build Status](https://travis-ci.org/valyala/bytebufferpool.svg)](https://travis-ci.org/valyala/bytebufferpool)
-[![GoDoc](https://godoc.org/github.com/valyala/bytebufferpool?status.svg)](http://godoc.org/github.com/valyala/bytebufferpool)
-[![Go Report](http://goreportcard.com/badge/valyala/bytebufferpool)](http://goreportcard.com/report/valyala/bytebufferpool)
-
-# bytebufferpool
-
-An implementation of a pool of byte buffers with anti-memory-waste protection.
-
-The pool may waste limited amount of memory due to fragmentation.
-This amount equals to the maximum total size of the byte buffers
-in concurrent use.
-
-# Benchmark results
-Currently bytebufferpool is fastest and most effective buffer pool written in Go.
-
-You can find results [here](https://omgnull.github.io/go-benchmark/buffer/).
-
-# bytebufferpool users
-
-* [fasthttp](https://github.com/valyala/fasthttp)
-* [quicktemplate](https://github.com/valyala/quicktemplate)
Index: trunk/vendor/github.com/valyala/bytebufferpool/bytebuffer.go
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/bytebuffer.go	(revision 145)
+++ 	(revision )
@@ -1,111 +1,0 @@
-package bytebufferpool
-
-import "io"
-
-// ByteBuffer provides byte buffer, which can be used for minimizing
-// memory allocations.
-//
-// ByteBuffer may be used with functions appending data to the given []byte
-// slice. See example code for details.
-//
-// Use Get for obtaining an empty byte buffer.
-type ByteBuffer struct {
-
-	// B is a byte buffer to use in append-like workloads.
-	// See example code for details.
-	B []byte
-}
-
-// Len returns the size of the byte buffer.
-func (b *ByteBuffer) Len() int {
-	return len(b.B)
-}
-
-// ReadFrom implements io.ReaderFrom.
-//
-// The function appends all the data read from r to b.
-func (b *ByteBuffer) ReadFrom(r io.Reader) (int64, error) {
-	p := b.B
-	nStart := int64(len(p))
-	nMax := int64(cap(p))
-	n := nStart
-	if nMax == 0 {
-		nMax = 64
-		p = make([]byte, nMax)
-	} else {
-		p = p[:nMax]
-	}
-	for {
-		if n == nMax {
-			nMax *= 2
-			bNew := make([]byte, nMax)
-			copy(bNew, p)
-			p = bNew
-		}
-		nn, err := r.Read(p[n:])
-		n += int64(nn)
-		if err != nil {
-			b.B = p[:n]
-			n -= nStart
-			if err == io.EOF {
-				return n, nil
-			}
-			return n, err
-		}
-	}
-}
-
-// WriteTo implements io.WriterTo.
-func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
-	n, err := w.Write(b.B)
-	return int64(n), err
-}
-
-// Bytes returns b.B, i.e. all the bytes accumulated in the buffer.
-//
-// The purpose of this function is bytes.Buffer compatibility.
-func (b *ByteBuffer) Bytes() []byte {
-	return b.B
-}
-
-// Write implements io.Writer - it appends p to ByteBuffer.B
-func (b *ByteBuffer) Write(p []byte) (int, error) {
-	b.B = append(b.B, p...)
-	return len(p), nil
-}
-
-// WriteByte appends the byte c to the buffer.
-//
-// The purpose of this function is bytes.Buffer compatibility.
-//
-// The function always returns nil.
-func (b *ByteBuffer) WriteByte(c byte) error {
-	b.B = append(b.B, c)
-	return nil
-}
-
-// WriteString appends s to ByteBuffer.B.
-func (b *ByteBuffer) WriteString(s string) (int, error) {
-	b.B = append(b.B, s...)
-	return len(s), nil
-}
-
-// Set sets ByteBuffer.B to p.
-func (b *ByteBuffer) Set(p []byte) {
-	b.B = append(b.B[:0], p...)
-}
-
-// SetString sets ByteBuffer.B to s.
-func (b *ByteBuffer) SetString(s string) {
-	b.B = append(b.B[:0], s...)
-}
-
-// String returns string representation of ByteBuffer.B.
-func (b *ByteBuffer) String() string {
-	return string(b.B)
-}
-
-// Reset makes ByteBuffer.B empty.
-func (b *ByteBuffer) Reset() {
-	b.B = b.B[:0]
-}
Index: trunk/vendor/github.com/valyala/bytebufferpool/doc.go
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/doc.go	(revision 145)
+++ 	(revision )
@@ -1,7 +1,0 @@
-// Package bytebufferpool implements a pool of byte buffers
-// with anti-fragmentation protection.
-//
-// The pool may waste limited amount of memory due to fragmentation.
-// This amount equals to the maximum total size of the byte buffers
-// in concurrent use.
-package bytebufferpool
Index: trunk/vendor/github.com/valyala/bytebufferpool/pool.go
===================================================================
--- trunk/vendor/github.com/valyala/bytebufferpool/pool.go	(revision 145)
+++ 	(revision )
@@ -1,151 +1,0 @@
-package bytebufferpool
-
-import (
-	"sort"
-	"sync"
-	"sync/atomic"
-)
-
-const (
-	minBitSize = 6 // 2**6=64 is a CPU cache line size
-	steps      = 20
-
-	minSize = 1 << minBitSize
-	maxSize = 1 << (minBitSize + steps - 1)
-
-	calibrateCallsThreshold = 42000
-	maxPercentile           = 0.95
-)
-
-// Pool represents byte buffer pool.
-//
-// Distinct pools may be used for distinct types of byte buffers.
-// Properly determined byte buffer types with their own pools may help reducing
-// memory waste.
-type Pool struct {
-	calls       [steps]uint64
-	calibrating uint64
-
-	defaultSize uint64
-	maxSize     uint64
-
-	pool sync.Pool
-}
-
-var defaultPool Pool
-
-// Get returns an empty byte buffer from the pool.
-//
-// Got byte buffer may be returned to the pool via Put call.
-// This reduces the number of memory allocations required for byte buffer
-// management.
-func Get() *ByteBuffer { return defaultPool.Get() }
-
-// Get returns new byte buffer with zero length.
-//
-// The byte buffer may be returned to the pool via Put after the use
-// in order to minimize GC overhead.
-func (p *Pool) Get() *ByteBuffer {
-	v := p.pool.Get()
-	if v != nil {
-		return v.(*ByteBuffer)
-	}
-	return &ByteBuffer{
-		B: make([]byte, 0, atomic.LoadUint64(&p.defaultSize)),
-	}
-}
-
-// Put returns byte buffer to the pool.
-//
-// ByteBuffer.B mustn't be touched after returning it to the pool.
-// Otherwise data races will occur.
-func Put(b *ByteBuffer) { defaultPool.Put(b) }
-
-// Put releases byte buffer obtained via Get to the pool.
-//
-// The buffer mustn't be accessed after returning to the pool.
-func (p *Pool) Put(b *ByteBuffer) {
-	idx := index(len(b.B))
-
-	if atomic.AddUint64(&p.calls[idx], 1) > calibrateCallsThreshold {
-		p.calibrate()
-	}
-
-	maxSize := int(atomic.LoadUint64(&p.maxSize))
-	if maxSize == 0 || cap(b.B) <= maxSize {
-		b.Reset()
-		p.pool.Put(b)
-	}
-}
-
-func (p *Pool) calibrate() {
-	if !atomic.CompareAndSwapUint64(&p.calibrating, 0, 1) {
-		return
-	}
-
-	a := make(callSizes, 0, steps)
-	var callsSum uint64
-	for i := uint64(0); i < steps; i++ {
-		calls := atomic.SwapUint64(&p.calls[i], 0)
-		callsSum += calls
-		a = append(a, callSize{
-			calls: calls,
-			size:  minSize << i,
-		})
-	}
-	sort.Sort(a)
-
-	defaultSize := a[0].size
-	maxSize := defaultSize
-
-	maxSum := uint64(float64(callsSum) * maxPercentile)
-	callsSum = 0
-	for i := 0; i < steps; i++ {
-		if callsSum > maxSum {
-			break
-		}
-		callsSum += a[i].calls
-		size := a[i].size
-		if size > maxSize {
-			maxSize = size
-		}
-	}
-
-	atomic.StoreUint64(&p.defaultSize, defaultSize)
-	atomic.StoreUint64(&p.maxSize, maxSize)
-
-	atomic.StoreUint64(&p.calibrating, 0)
-}
-
-type callSize struct {
-	calls uint64
-	size  uint64
-}
-
-type callSizes []callSize
-
-func (ci callSizes) Len() int {
-	return len(ci)
-}
-
-func (ci callSizes) Less(i, j int) bool {
-	return ci[i].calls > ci[j].calls
-}
-
-func (ci callSizes) Swap(i, j int) {
-	ci[i], ci[j] = ci[j], ci[i]
-}
-
-func index(n int) int {
-	n--
-	n >>= minBitSize
-	idx := 0
-	for n > 0 {
-		n >>= 1
-		idx++
-	}
-	if idx >= steps {
-		idx = steps - 1
-	}
-	return idx
-}
