Imported Upstream version 60

21 files changed, 0 insertions, 3930 deletions

diff --git a/src/pkg/encoding/ascii85/Makefile b/src/pkg/encoding/ascii85/Makefile
deleted file mode 100644
index 412383efd..000000000
--- a/src/pkg/encoding/ascii85/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/ascii85
-GOFILES=\
-	ascii85.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/ascii85/ascii85.go b/src/pkg/encoding/ascii85/ascii85.go
deleted file mode 100644
index ead0c2475..000000000
--- a/src/pkg/encoding/ascii85/ascii85.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package ascii85 implements the ascii85 data encoding
-// as used in the btoa tool and Adobe's PostScript and PDF document formats.
-package ascii85
-
-import (
-	"io"
-	"os"
-	"strconv"
-)
-
-/*
- * Encoder
- */
-
-// Encode encodes src into at most MaxEncodedLen(len(src))
-// bytes of dst, returning the actual number of bytes written.
-//
-// The encoding handles 4-byte chunks, using a special encoding
-// for the last fragment, so Encode is not appropriate for use on
-// individual blocks of a large data stream.  Use NewEncoder() instead.
-//
-// Often, ascii85-encoded data is wrapped in <~ and ~> symbols.
-// Encode does not add these.
-func Encode(dst, src []byte) int {
-	if len(src) == 0 {
-		return 0
-	}
-
-	n := 0
-	for len(src) > 0 {
-		dst[0] = 0
-		dst[1] = 0
-		dst[2] = 0
-		dst[3] = 0
-		dst[4] = 0
-
-		// Unpack 4 bytes into uint32 to repack into base 85 5-byte.
-		var v uint32
-		switch len(src) {
-		default:
-			v |= uint32(src[3])
-			fallthrough
-		case 3:
-			v |= uint32(src[2]) << 8
-			fallthrough
-		case 2:
-			v |= uint32(src[1]) << 16
-			fallthrough
-		case 1:
-			v |= uint32(src[0]) << 24
-		}
-
-		// Special case: zero (!!!!!) shortens to z.
-		if v == 0 && len(src) >= 4 {
-			dst[0] = 'z'
-			dst = dst[1:]
-			n++
-			continue
-		}
-
-		// Otherwise, 5 base 85 digits starting at !.
-		for i := 4; i >= 0; i-- {
-			dst[i] = '!' + byte(v%85)
-			v /= 85
-		}
-
-		// If src was short, discard the low destination bytes.
-		m := 5
-		if len(src) < 4 {
-			m -= 4 - len(src)
-			src = nil
-		} else {
-			src = src[4:]
-		}
-		dst = dst[m:]
-		n += m
-	}
-	return n
-}
-
-// MaxEncodedLen returns the maximum length of an encoding of n source bytes.
-func MaxEncodedLen(n int) int { return (n + 3) / 4 * 5 }
-
-// NewEncoder returns a new ascii85 stream encoder.  Data written to
-// the returned writer will be encoded and then written to w.
-// Ascii85 encodings operate in 32-bit blocks; when finished
-// writing, the caller must Close the returned encoder to flush any
-// trailing partial block.
-func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} }
-
-type encoder struct {
-	err  os.Error
-	w    io.Writer
-	buf  [4]byte    // buffered data waiting to be encoded
-	nbuf int        // number of bytes in buf
-	out  [1024]byte // output buffer
-}
-
-func (e *encoder) Write(p []byte) (n int, err os.Error) {
-	if e.err != nil {
-		return 0, e.err
-	}
-
-	// Leading fringe.
-	if e.nbuf > 0 {
-		var i int
-		for i = 0; i < len(p) && e.nbuf < 4; i++ {
-			e.buf[e.nbuf] = p[i]
-			e.nbuf++
-		}
-		n += i
-		p = p[i:]
-		if e.nbuf < 4 {
-			return
-		}
-		nout := Encode(e.out[0:], e.buf[0:])
-		if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
-			return n, e.err
-		}
-		e.nbuf = 0
-	}
-
-	// Large interior chunks.
-	for len(p) >= 4 {
-		nn := len(e.out) / 5 * 4
-		if nn > len(p) {
-			nn = len(p)
-		}
-		nn -= nn % 4
-		if nn > 0 {
-			nout := Encode(e.out[0:], p[0:nn])
-			if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
-				return n, e.err
-			}
-		}
-		n += nn
-		p = p[nn:]
-	}
-
-	// Trailing fringe.
-	for i := 0; i < len(p); i++ {
-		e.buf[i] = p[i]
-	}
-	e.nbuf = len(p)
-	n += len(p)
-	return
-}
-
-// Close flushes any pending output from the encoder.
-// It is an error to call Write after calling Close.
-func (e *encoder) Close() os.Error {
-	// If there's anything left in the buffer, flush it out
-	if e.err == nil && e.nbuf > 0 {
-		nout := Encode(e.out[0:], e.buf[0:e.nbuf])
-		e.nbuf = 0
-		_, e.err = e.w.Write(e.out[0:nout])
-	}
-	return e.err
-}
-
-/*
- * Decoder
- */
-
-type CorruptInputError int64
-
-func (e CorruptInputError) String() string {
-	return "illegal ascii85 data at input byte " + strconv.Itoa64(int64(e))
-}
-
-// Decode decodes src into dst, returning both the number
-// of bytes written to dst and the number consumed from src.
-// If src contains invalid ascii85 data, Decode will return the
-// number of bytes successfully written and a CorruptInputError.
-// Decode ignores space and control characters in src.
-// Often, ascii85-encoded data is wrapped in <~ and ~> symbols.
-// Decode expects these to have been stripped by the caller.
-//
-// If flush is true, Decode assumes that src represents the
-// end of the input stream and processes it completely rather
-// than wait for the completion of another 32-bit block.
-//
-// NewDecoder wraps an io.Reader interface around Decode.
-//
-func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
-	var v uint32
-	var nb int
-	for i, b := range src {
-		if len(dst)-ndst < 4 {
-			return
-		}
-		switch {
-		case b <= ' ':
-			continue
-		case b == 'z' && nb == 0:
-			nb = 5
-			v = 0
-		case '!' <= b && b <= 'u':
-			v = v*85 + uint32(b-'!')
-			nb++
-		default:
-			return 0, 0, CorruptInputError(i)
-		}
-		if nb == 5 {
-			nsrc = i + 1
-			dst[ndst] = byte(v >> 24)
-			dst[ndst+1] = byte(v >> 16)
-			dst[ndst+2] = byte(v >> 8)
-			dst[ndst+3] = byte(v)
-			ndst += 4
-			nb = 0
-			v = 0
-		}
-	}
-	if flush {
-		nsrc = len(src)
-		if nb > 0 {
-			// The number of output bytes in the last fragment
-			// is the number of leftover input bytes - 1:
-			// the extra byte provides enough bits to cover
-			// the inefficiency of the encoding for the block.
-			if nb == 1 {
-				return 0, 0, CorruptInputError(len(src))
-			}
-			for i := nb; i < 5; i++ {
-				// The short encoding truncated the output value.
-				// We have to assume the worst case values (digit 84)
-				// in order to ensure that the top bits are correct.
-				v = v*85 + 84
-			}
-			for i := 0; i < nb-1; i++ {
-				dst[ndst] = byte(v >> 24)
-				v <<= 8
-				ndst++
-			}
-		}
-	}
-	return
-}
-
-// NewDecoder constructs a new ascii85 stream decoder.
-func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
-
-type decoder struct {
-	err     os.Error
-	readErr os.Error
-	r       io.Reader
-	end     bool       // saw end of message
-	buf     [1024]byte // leftover input
-	nbuf    int
-	out     []byte // leftover decoded output
-	outbuf  [1024]byte
-}
-
-func (d *decoder) Read(p []byte) (n int, err os.Error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if d.err != nil {
-		return 0, d.err
-	}
-
-	for {
-		// Copy leftover output from last decode.
-		if len(d.out) > 0 {
-			n = copy(p, d.out)
-			d.out = d.out[n:]
-			return
-		}
-
-		// Decode leftover input from last read.
-		var nn, nsrc, ndst int
-		if d.nbuf > 0 {
-			ndst, nsrc, d.err = Decode(d.outbuf[0:], d.buf[0:d.nbuf], d.readErr != nil)
-			if ndst > 0 {
-				d.out = d.outbuf[0:ndst]
-				d.nbuf = copy(d.buf[0:], d.buf[nsrc:d.nbuf])
-				continue // copy out and return
-			}
-		}
-
-		// Out of input, out of decoded output.  Check errors.
-		if d.err != nil {
-			return 0, d.err
-		}
-		if d.readErr != nil {
-			d.err = d.readErr
-			return 0, d.err
-		}
-
-		// Read more data.
-		nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
-		d.nbuf += nn
-	}
-	panic("unreachable")
-}
diff --git a/src/pkg/encoding/ascii85/ascii85_test.go b/src/pkg/encoding/ascii85/ascii85_test.go
deleted file mode 100644
index fdfeb889f..000000000
--- a/src/pkg/encoding/ascii85/ascii85_test.go
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ascii85
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-type testpair struct {
-	decoded, encoded string
-}
-
-var pairs = []testpair{
-	// Wikipedia example
-	{
-		"Man is distinguished, not only by his reason, but by this singular passion from " +
-			"other animals, which is a lust of the mind, that by a perseverance of delight in " +
-			"the continued and indefatigable generation of knowledge, exceeds the short " +
-			"vehemence of any carnal pleasure.",
-		"9jqo^BlbD-BleB1DJ+*+F(f,q/0JhKF<GL>Cj@.4Gp$d7F!,L7@<6@)/0JDEF<G%<+EV:2F!,\n" +
-			"O<DJ+*.@<*K0@<6L(Df-\\0Ec5e;DffZ(EZee.Bl.9pF\"AGXBPCsi+DGm>@3BB/F*&OCAfu2/AKY\n" +
-			"i(DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF<G:8+EV:.+Cf>-FD5W8ARlolDIa\n" +
-			"l(DId<j@<?3r@:F%a+D58'ATD4$Bl@l3De:,-DJs`8ARoFb/0JMK@qB4^F!,R<AKZ&-DfTqBG%G\n" +
-			">uD.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c\n",
-	},
-}
-
-var bigtest = pairs[len(pairs)-1]
-
-func testEqual(t *testing.T, msg string, args ...interface{}) bool {
-	if args[len(args)-2] != args[len(args)-1] {
-		t.Errorf(msg, args...)
-		return false
-	}
-	return true
-}
-
-func strip85(s string) string {
-	t := make([]byte, len(s))
-	w := 0
-	for r := 0; r < len(s); r++ {
-		c := s[r]
-		if c > ' ' {
-			t[w] = c
-			w++
-		}
-	}
-	return string(t[0:w])
-}
-
-func TestEncode(t *testing.T) {
-	for _, p := range pairs {
-		buf := make([]byte, MaxEncodedLen(len(p.decoded)))
-		n := Encode(buf, []byte(p.decoded))
-		buf = buf[0:n]
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded))
-	}
-}
-
-func TestEncoder(t *testing.T) {
-	for _, p := range pairs {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(bb)
-		encoder.Write([]byte(p.decoded))
-		encoder.Close()
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded))
-	}
-}
-
-func TestEncoderBuffering(t *testing.T) {
-	input := []byte(bigtest.decoded)
-	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(bb)
-		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs
-			if end > len(input) {
-				end = len(input)
-			}
-			n, err := encoder.Write(input[pos:end])
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
-		}
-		err := encoder.Close()
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded))
-	}
-}
-
-func TestDecode(t *testing.T) {
-	for _, p := range pairs {
-		dbuf := make([]byte, 4*len(p.encoded))
-		ndst, nsrc, err := Decode(dbuf, []byte(p.encoded), true)
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
-		testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded))
-		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
-	}
-}
-
-func TestDecoder(t *testing.T) {
-	for _, p := range pairs {
-		decoder := NewDecoder(bytes.NewBufferString(p.encoded))
-		dbuf, err := ioutil.ReadAll(decoder)
-		if err != nil {
-			t.Fatal("Read failed", err)
-		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
-		if err != nil {
-			testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
-		}
-	}
-}
-
-func TestDecoderBuffering(t *testing.T) {
-	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded))
-		buf := make([]byte, len(bigtest.decoded)+12)
-		var total int
-		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs])
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
-			total += n
-		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
-	}
-}
-
-func TestDecodeCorrupt(t *testing.T) {
-	type corrupt struct {
-		e string
-		p int
-	}
-	examples := []corrupt{
-		{"v", 0},
-		{"!z!!!!!!!!!", 1},
-	}
-
-	for _, e := range examples {
-		dbuf := make([]byte, 4*len(e.e))
-		_, _, err := Decode(dbuf, []byte(e.e), true)
-		switch err := err.(type) {
-		case CorruptInputError:
-			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
-		default:
-			t.Error("Decoder failed to detect corruption in", e)
-		}
-	}
-}
-
-func TestBig(t *testing.T) {
-	n := 3*1000 + 1
-	raw := make([]byte, n)
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	for i := 0; i < n; i++ {
-		raw[i] = alpha[i%len(alpha)]
-	}
-	encoded := new(bytes.Buffer)
-	w := NewEncoder(encoded)
-	nn, err := w.Write(raw)
-	if nn != n || err != nil {
-		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
-	}
-	err = w.Close()
-	if err != nil {
-		t.Fatalf("Encoder.Close() = %v want nil", err)
-	}
-	decoded, err := ioutil.ReadAll(NewDecoder(encoded))
-	if err != nil {
-		t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err)
-	}
-
-	if !bytes.Equal(raw, decoded) {
-		var i int
-		for i = 0; i < len(decoded) && i < len(raw); i++ {
-			if decoded[i] != raw[i] {
-				break
-			}
-		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
-	}
-}
diff --git a/src/pkg/encoding/base32/Makefile b/src/pkg/encoding/base32/Makefile
deleted file mode 100644
index c0e85b644..000000000
--- a/src/pkg/encoding/base32/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include $(GOROOT)/src/Make.inc
-
-TARG=encoding/base32
-GOFILES=\
-	base32.go\
-
-include $(GOROOT)/src/Make.pkg
diff --git a/src/pkg/encoding/base32/base32.go b/src/pkg/encoding/base32/base32.go
deleted file mode 100644
index acace30d6..000000000
--- a/src/pkg/encoding/base32/base32.go
+++ /dev/null
@@ -1,368 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package base32 implements base32 encoding as specified by RFC 4648.
-package base32
-
-import (
-	"io"
-	"os"
-	"strconv"
-)
-
-/*
- * Encodings
- */
-
-// An Encoding is a radix 32 encoding/decoding scheme, defined by a
-// 32-character alphabet.  The most common is the "base32" encoding
-// introduced for SASL GSSAPI and standardized in RFC 4648.
-// The alternate "base32hex" encoding is used in DNSSEC.
-type Encoding struct {
-	encode    string
-	decodeMap [256]byte
-}
-
-const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
-const encodeHex = "0123456789ABCDEFGHIJKLMNOPQRSTUV"
-
-// NewEncoding returns a new Encoding defined by the given alphabet,
-// which must be a 32-byte string.
-func NewEncoding(encoder string) *Encoding {
-	e := new(Encoding)
-	e.encode = encoder
-	for i := 0; i < len(e.decodeMap); i++ {
-		e.decodeMap[i] = 0xFF
-	}
-	for i := 0; i < len(encoder); i++ {
-		e.decodeMap[encoder[i]] = byte(i)
-	}
-	return e
-}
-
-// StdEncoding is the standard base32 encoding, as defined in
-// RFC 4648.
-var StdEncoding = NewEncoding(encodeStd)
-
-// HexEncoding is the ``Extended Hex Alphabet'' defined in RFC 4648.
-// It is typically used in DNS.
-var HexEncoding = NewEncoding(encodeHex)
-
-/*
- * Encoder
- */
-
-// Encode encodes src using the encoding enc, writing
-// EncodedLen(len(src)) bytes to dst.
-//
-// The encoding pads the output to a multiple of 8 bytes,
-// so Encode is not appropriate for use on individual blocks
-// of a large data stream.  Use NewEncoder() instead.
-func (enc *Encoding) Encode(dst, src []byte) {
-	if len(src) == 0 {
-		return
-	}
-
-	for len(src) > 0 {
-		dst[0] = 0
-		dst[1] = 0
-		dst[2] = 0
-		dst[3] = 0
-		dst[4] = 0
-		dst[5] = 0
-		dst[6] = 0
-		dst[7] = 0
-
-		// Unpack 8x 5-bit source blocks into a 5 byte
-		// destination quantum
-		switch len(src) {
-		default:
-			dst[7] |= src[4] & 0x1F
-			dst[6] |= src[4] >> 5
-			fallthrough
-		case 4:
-			dst[6] |= (src[3] << 3) & 0x1F
-			dst[5] |= (src[3] >> 2) & 0x1F
-			dst[4] |= src[3] >> 7
-			fallthrough
-		case 3:
-			dst[4] |= (src[2] << 1) & 0x1F
-			dst[3] |= (src[2] >> 4) & 0x1F
-			fallthrough
-		case 2:
-			dst[3] |= (src[1] << 4) & 0x1F
-			dst[2] |= (src[1] >> 1) & 0x1F
-			dst[1] |= (src[1] >> 6) & 0x1F
-			fallthrough
-		case 1:
-			dst[1] |= (src[0] << 2) & 0x1F
-			dst[0] |= src[0] >> 3
-		}
-
-		// Encode 5-bit blocks using the base32 alphabet
-		for j := 0; j < 8; j++ {
-			dst[j] = enc.encode[dst[j]]
-		}
-
-		// Pad the final quantum
-		if len(src) < 5 {
-			dst[7] = '='
-			if len(src) < 4 {
-				dst[6] = '='
-				dst[5] = '='
-				if len(src) < 3 {
-					dst[4] = '='
-					if len(src) < 2 {
-						dst[3] = '='
-						dst[2] = '='
-					}
-				}
-			}
-			break
-		}
-		src = src[5:]
-		dst = dst[8:]
-	}
-}
-
-type encoder struct {
-	err  os.Error
-	enc  *Encoding
-	w    io.Writer
-	buf  [5]byte    // buffered data waiting to be encoded
-	nbuf int        // number of bytes in buf
-	out  [1024]byte // output buffer
-}
-
-func (e *encoder) Write(p []byte) (n int, err os.Error) {
-	if e.err != nil {
-		return 0, e.err
-	}
-
-	// Leading fringe.
-	if e.nbuf > 0 {
-		var i int
-		for i = 0; i < len(p) && e.nbuf < 5; i++ {
-			e.buf[e.nbuf] = p[i]
-			e.nbuf++
-		}
-		n += i
-		p = p[i:]
-		if e.nbuf < 5 {
-			return
-		}
-		e.enc.Encode(e.out[0:], e.buf[0:])
-		if _, e.err = e.w.Write(e.out[0:8]); e.err != nil {
-			return n, e.err
-		}
-		e.nbuf = 0
-	}
-
-	// Large interior chunks.
-	for len(p) >= 5 {
-		nn := len(e.out) / 8 * 5
-		if nn > len(p) {
-			nn = len(p)
-		}
-		nn -= nn % 5
-		if nn > 0 {
-			e.enc.Encode(e.out[0:], p[0:nn])
-			if _, e.err = e.w.Write(e.out[0 : nn/5*8]); e.err != nil {
-				return n, e.err
-			}
-		}
-		n += nn
-		p = p[nn:]
-	}
-
-	// Trailing fringe.
-	for i := 0; i < len(p); i++ {
-		e.buf[i] = p[i]
-	}
-	e.nbuf = len(p)
-	n += len(p)
-	return
-}
-
-// Close flushes any pending output from the encoder.
-// It is an error to call Write after calling Close.
-func (e *encoder) Close() os.Error {
-	// If there's anything left in the buffer, flush it out
-	if e.err == nil && e.nbuf > 0 {
-		e.enc.Encode(e.out[0:], e.buf[0:e.nbuf])
-		e.nbuf = 0
-		_, e.err = e.w.Write(e.out[0:8])
-	}
-	return e.err
-}
-
-// NewEncoder returns a new base32 stream encoder.  Data written to
-// the returned writer will be encoded using enc and then written to w.
-// Base32 encodings operate in 5-byte blocks; when finished
-// writing, the caller must Close the returned encoder to flush any
-// partially written blocks.
-func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser {
-	return &encoder{enc: enc, w: w}
-}
-
-// EncodedLen returns the length in bytes of the base32 encoding
-// of an input buffer of length n.
-func (enc *Encoding) EncodedLen(n int) int { return (n + 4) / 5 * 8 }
-
-/*
- * Decoder
- */
-
-type CorruptInputError int64
-
-func (e CorruptInputError) String() string {
-	return "illegal base32 data at input byte " + strconv.Itoa64(int64(e))
-}
-
-// decode is like Decode but returns an additional 'end' value, which
-// indicates if end-of-message padding was encountered and thus any
-// additional data is an error.  decode also assumes len(src)%8==0,
-// since it is meant for internal use.
-func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) {
-	for i := 0; i < len(src)/8 && !end; i++ {
-		// Decode quantum using the base32 alphabet
-		var dbuf [8]byte
-		dlen := 8
-
-		// do the top bytes contain any data?
-	dbufloop:
-		for j := 0; j < 8; j++ {
-			in := src[i*8+j]
-			if in == '=' && j >= 2 && i == len(src)/8-1 {
-				// We've reached the end and there's
-				// padding, the rest should be padded
-				for k := j; k < 8; k++ {
-					if src[i*8+k] != '=' {
-						return n, false, CorruptInputError(i*8 + j)
-					}
-				}
-				dlen = j
-				end = true
-				break dbufloop
-			}
-			dbuf[j] = enc.decodeMap[in]
-			if dbuf[j] == 0xFF {
-				return n, false, CorruptInputError(i*8 + j)
-			}
-		}
-
-		// Pack 8x 5-bit source blocks into 5 byte destination
-		// quantum
-		switch dlen {
-		case 7, 8:
-			dst[i*5+4] = dbuf[6]<<5 | dbuf[7]
-			fallthrough
-		case 6, 5:
-			dst[i*5+3] = dbuf[4]<<7 | dbuf[5]<<2 | dbuf[6]>>3
-			fallthrough
-		case 4:
-			dst[i*5+2] = dbuf[3]<<4 | dbuf[4]>>1
-			fallthrough
-		case 3:
-			dst[i*5+1] = dbuf[1]<<6 | dbuf[2]<<1 | dbuf[3]>>4
-			fallthrough
-		case 2:
-			dst[i*5+0] = dbuf[0]<<3 | dbuf[1]>>2
-		}
-		switch dlen {
-		case 2:
-			n += 1
-		case 3, 4:
-			n += 2
-		case 5:
-			n += 3
-		case 6, 7:
-			n += 4
-		case 8:
-			n += 5
-		}
-	}
-	return n, end, nil
-}
-
-// Decode decodes src using the encoding enc.  It writes at most
-// DecodedLen(len(src)) bytes to dst and returns the number of bytes
-// written.  If src contains invalid base32 data, it will return the
-// number of bytes successfully written and CorruptInputError.
-func (enc *Encoding) Decode(dst, src []byte) (n int, err os.Error) {
-	if len(src)%8 != 0 {
-		return 0, CorruptInputError(len(src) / 8 * 8)
-	}
-
-	n, _, err = enc.decode(dst, src)
-	return
-}
-
-type decoder struct {
-	err    os.Error
-	enc    *Encoding
-	r      io.Reader
-	end    bool       // saw end of message
-	buf    [1024]byte // leftover input
-	nbuf   int
-	out    []byte // leftover decoded output
-	outbuf [1024 / 8 * 5]byte
-}
-
-func (d *decoder) Read(p []byte) (n int, err os.Error) {
-	if d.err != nil {
-		return 0, d.err
-	}
-
-	// Use leftover decoded output from last read.
-	if len(d.out) > 0 {
-		n = copy(p, d.out)
-		d.out = d.out[n:]
-		return n, nil
-	}
-
-	// Read a chunk.
-	nn := len(p) / 5 * 8
-	if nn < 8 {
-		nn = 8
-	}
-	if nn > len(d.buf) {
-		nn = len(d.buf)
-	}
-	nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 8-d.nbuf)
-	d.nbuf += nn
-	if d.nbuf < 8 {
-		return 0, d.err
-	}
-
-	// Decode chunk into p, or d.out and then p if p is too small.
-	nr := d.nbuf / 8 * 8
-	nw := d.nbuf / 8 * 5
-	if nw > len(p) {
-		nw, d.end, d.err = d.enc.decode(d.outbuf[0:], d.buf[0:nr])
-		d.out = d.outbuf[0:nw]
-		n = copy(p, d.out)
-		d.out = d.out[n:]
-	} else {
-		n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
-	}
-	d.nbuf -= nr
-	for i := 0; i < d.nbuf; i++ {
-		d.buf[i] = d.buf[i+nr]
-	}
-
-	if d.err == nil {
-		d.err = err
-	}
-	return n, d.err
-}
-
-// NewDecoder constructs a new base32 stream decoder.
-func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
-	return &decoder{enc: enc, r: r}
-}
-
-// DecodedLen returns the maximum length in bytes of the decoded data
-// corresponding to n bytes of base32-encoded data.
-func (enc *Encoding) DecodedLen(n int) int { return n / 8 * 5 }
diff --git a/src/pkg/encoding/base32/base32_test.go b/src/pkg/encoding/base32/base32_test.go
deleted file mode 100644
index 792e4dc63..000000000
--- a/src/pkg/encoding/base32/base32_test.go
+++ /dev/null
@@ -1,194 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package base32
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-type testpair struct {
-	decoded, encoded string
-}
-
-var pairs = []testpair{
-	// RFC 4648 examples
-	{"", ""},
-	{"f", "MY======"},
-	{"fo", "MZXQ===="},
-	{"foo", "MZXW6==="},
-	{"foob", "MZXW6YQ="},
-	{"fooba", "MZXW6YTB"},
-	{"foobar", "MZXW6YTBOI======"},
-
-
-	// Wikipedia examples, converted to base32
-	{"sure.", "ON2XEZJO"},
-	{"sure", "ON2XEZI="},
-	{"sur", "ON2XE==="},
-	{"su", "ON2Q===="},
-	{"leasure.", "NRSWC43VOJSS4==="},
-	{"easure.", "MVQXG5LSMUXA===="},
-	{"asure.", "MFZXK4TFFY======"},
-	{"sure.", "ON2XEZJO"},
-}
-
-var bigtest = testpair{
-	"Twas brillig, and the slithy toves",
-	"KR3WC4ZAMJZGS3DMNFTSYIDBNZSCA5DIMUQHG3DJORUHSIDUN53GK4Y=",
-}
-
-func testEqual(t *testing.T, msg string, args ...interface{}) bool {
-	if args[len(args)-2] != args[len(args)-1] {
-		t.Errorf(msg, args...)
-		return false
-	}
-	return true
-}
-
-func TestEncode(t *testing.T) {
-	for _, p := range pairs {
-		buf := make([]byte, StdEncoding.EncodedLen(len(p.decoded)))
-		StdEncoding.Encode(buf, []byte(p.decoded))
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded)
-	}
-}
-
-func TestEncoder(t *testing.T) {
-	for _, p := range pairs {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(StdEncoding, bb)
-		encoder.Write([]byte(p.decoded))
-		encoder.Close()
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
-	}
-}
-
-func TestEncoderBuffering(t *testing.T) {
-	input := []byte(bigtest.decoded)
-	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(StdEncoding, bb)
-		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs
-			if end > len(input) {
-				end = len(input)
-			}
-			n, err := encoder.Write(input[pos:end])
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
-		}
-		err := encoder.Close()
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded)
-	}
-}
-
-func TestDecode(t *testing.T) {
-	for _, p := range pairs {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
-		count, end, err := StdEncoding.decode(dbuf, []byte(p.encoded))
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
-		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded))
-		if len(p.encoded) > 0 {
-			testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '='))
-		}
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded,
-			string(dbuf[0:count]),
-			p.decoded)
-	}
-}
-
-func TestDecoder(t *testing.T) {
-	for _, p := range pairs {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded))
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
-		count, err := decoder.Read(dbuf)
-		if err != nil && err != os.EOF {
-			t.Fatal("Read failed", err)
-		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded))
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
-		if err != os.EOF {
-			count, err = decoder.Read(dbuf)
-		}
-		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
-	}
-}
-
-func TestDecoderBuffering(t *testing.T) {
-	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded))
-		buf := make([]byte, len(bigtest.decoded)+12)
-		var total int
-		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs])
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
-			total += n
-		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
-	}
-}
-
-func TestDecodeCorrupt(t *testing.T) {
-	type corrupt struct {
-		e string
-		p int
-	}
-	examples := []corrupt{
-		{"!!!!", 0},
-		{"x===", 0},
-		{"AA=A====", 2},
-		{"AAA=AAAA", 3},
-		{"MMMMMMMMM", 8},
-		{"MMMMMM", 0},
-	}
-
-	for _, e := range examples {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e)))
-		_, err := StdEncoding.Decode(dbuf, []byte(e.e))
-		switch err := err.(type) {
-		case CorruptInputError:
-			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
-		default:
-			t.Error("Decoder failed to detect corruption in", e)
-		}
-	}
-}
-
-func TestBig(t *testing.T) {
-	n := 3*1000 + 1
-	raw := make([]byte, n)
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	for i := 0; i < n; i++ {
-		raw[i] = alpha[i%len(alpha)]
-	}
-	encoded := new(bytes.Buffer)
-	w := NewEncoder(StdEncoding, encoded)
-	nn, err := w.Write(raw)
-	if nn != n || err != nil {
-		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
-	}
-	err = w.Close()
-	if err != nil {
-		t.Fatalf("Encoder.Close() = %v want nil", err)
-	}
-	decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded))
-	if err != nil {
-		t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
-	}
-
-	if !bytes.Equal(raw, decoded) {
-		var i int
-		for i = 0; i < len(decoded) && i < len(raw); i++ {
-			if decoded[i] != raw[i] {
-				break
-			}
-		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
-	}
-}
diff --git a/src/pkg/encoding/base64/Makefile b/src/pkg/encoding/base64/Makefile
deleted file mode 100644
index 2f54ed839..000000000
--- a/src/pkg/encoding/base64/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/base64
-GOFILES=\
-	base64.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/base64/base64.go b/src/pkg/encoding/base64/base64.go
deleted file mode 100644
index c6b2a13e4..000000000
--- a/src/pkg/encoding/base64/base64.go
+++ /dev/null
@@ -1,343 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package base64 implements base64 encoding as specified by RFC 4648.
-package base64
-
-import (
-	"io"
-	"os"
-	"strconv"
-)
-
-/*
- * Encodings
- */
-
-// An Encoding is a radix 64 encoding/decoding scheme, defined by a
-// 64-character alphabet.  The most common encoding is the "base64"
-// encoding defined in RFC 4648 and used in MIME (RFC 2045) and PEM
-// (RFC 1421).  RFC 4648 also defines an alternate encoding, which is
-// the standard encoding with - and _ substituted for + and /.
-type Encoding struct {
-	encode    string
-	decodeMap [256]byte
-}
-
-const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-const encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-
-// NewEncoding returns a new Encoding defined by the given alphabet,
-// which must be a 64-byte string.
-func NewEncoding(encoder string) *Encoding {
-	e := new(Encoding)
-	e.encode = encoder
-	for i := 0; i < len(e.decodeMap); i++ {
-		e.decodeMap[i] = 0xFF
-	}
-	for i := 0; i < len(encoder); i++ {
-		e.decodeMap[encoder[i]] = byte(i)
-	}
-	return e
-}
-
-// StdEncoding is the standard base64 encoding, as defined in
-// RFC 4648.
-var StdEncoding = NewEncoding(encodeStd)
-
-// URLEncoding is the alternate base64 encoding defined in RFC 4648.
-// It is typically used in URLs and file names.
-var URLEncoding = NewEncoding(encodeURL)
-
-/*
- * Encoder
- */
-
-// Encode encodes src using the encoding enc, writing
-// EncodedLen(len(src)) bytes to dst.
-//
-// The encoding pads the output to a multiple of 4 bytes,
-// so Encode is not appropriate for use on individual blocks
-// of a large data stream.  Use NewEncoder() instead.
-func (enc *Encoding) Encode(dst, src []byte) {
-	if len(src) == 0 {
-		return
-	}
-
-	for len(src) > 0 {
-		dst[0] = 0
-		dst[1] = 0
-		dst[2] = 0
-		dst[3] = 0
-
-		// Unpack 4x 6-bit source blocks into a 4 byte
-		// destination quantum
-		switch len(src) {
-		default:
-			dst[3] |= src[2] & 0x3F
-			dst[2] |= src[2] >> 6
-			fallthrough
-		case 2:
-			dst[2] |= (src[1] << 2) & 0x3F
-			dst[1] |= src[1] >> 4
-			fallthrough
-		case 1:
-			dst[1] |= (src[0] << 4) & 0x3F
-			dst[0] |= src[0] >> 2
-		}
-
-		// Encode 6-bit blocks using the base64 alphabet
-		for j := 0; j < 4; j++ {
-			dst[j] = enc.encode[dst[j]]
-		}
-
-		// Pad the final quantum
-		if len(src) < 3 {
-			dst[3] = '='
-			if len(src) < 2 {
-				dst[2] = '='
-			}
-			break
-		}
-
-		src = src[3:]
-		dst = dst[4:]
-	}
-}
-
-// EncodeToString returns the base64 encoding of src.
-func (enc *Encoding) EncodeToString(src []byte) string {
-	buf := make([]byte, enc.EncodedLen(len(src)))
-	enc.Encode(buf, src)
-	return string(buf)
-}
-
-type encoder struct {
-	err  os.Error
-	enc  *Encoding
-	w    io.Writer
-	buf  [3]byte    // buffered data waiting to be encoded
-	nbuf int        // number of bytes in buf
-	out  [1024]byte // output buffer
-}
-
-func (e *encoder) Write(p []byte) (n int, err os.Error) {
-	if e.err != nil {
-		return 0, e.err
-	}
-
-	// Leading fringe.
-	if e.nbuf > 0 {
-		var i int
-		for i = 0; i < len(p) && e.nbuf < 3; i++ {
-			e.buf[e.nbuf] = p[i]
-			e.nbuf++
-		}
-		n += i
-		p = p[i:]
-		if e.nbuf < 3 {
-			return
-		}
-		e.enc.Encode(e.out[0:], e.buf[0:])
-		if _, e.err = e.w.Write(e.out[0:4]); e.err != nil {
-			return n, e.err
-		}
-		e.nbuf = 0
-	}
-
-	// Large interior chunks.
-	for len(p) >= 3 {
-		nn := len(e.out) / 4 * 3
-		if nn > len(p) {
-			nn = len(p)
-		}
-		nn -= nn % 3
-		if nn > 0 {
-			e.enc.Encode(e.out[0:], p[0:nn])
-			if _, e.err = e.w.Write(e.out[0 : nn/3*4]); e.err != nil {
-				return n, e.err
-			}
-		}
-		n += nn
-		p = p[nn:]
-	}
-
-	// Trailing fringe.
-	for i := 0; i < len(p); i++ {
-		e.buf[i] = p[i]
-	}
-	e.nbuf = len(p)
-	n += len(p)
-	return
-}
-
-// Close flushes any pending output from the encoder.
-// It is an error to call Write after calling Close.
-func (e *encoder) Close() os.Error {
-	// If there's anything left in the buffer, flush it out
-	if e.err == nil && e.nbuf > 0 {
-		e.enc.Encode(e.out[0:], e.buf[0:e.nbuf])
-		e.nbuf = 0
-		_, e.err = e.w.Write(e.out[0:4])
-	}
-	return e.err
-}
-
-// NewEncoder returns a new base64 stream encoder.  Data written to
-// the returned writer will be encoded using enc and then written to w.
-// Base64 encodings operate in 4-byte blocks; when finished
-// writing, the caller must Close the returned encoder to flush any
-// partially written blocks.
-func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser {
-	return &encoder{enc: enc, w: w}
-}
-
-// EncodedLen returns the length in bytes of the base64 encoding
-// of an input buffer of length n.
-func (enc *Encoding) EncodedLen(n int) int { return (n + 2) / 3 * 4 }
-
-/*
- * Decoder
- */
-
-type CorruptInputError int64
-
-func (e CorruptInputError) String() string {
-	return "illegal base64 data at input byte " + strconv.Itoa64(int64(e))
-}
-
-// decode is like Decode but returns an additional 'end' value, which
-// indicates if end-of-message padding was encountered and thus any
-// additional data is an error.  decode also assumes len(src)%4==0,
-// since it is meant for internal use.
-func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) {
-	for i := 0; i < len(src)/4 && !end; i++ {
-		// Decode quantum using the base64 alphabet
-		var dbuf [4]byte
-		dlen := 4
-
-	dbufloop:
-		for j := 0; j < 4; j++ {
-			in := src[i*4+j]
-			if in == '=' && j >= 2 && i == len(src)/4-1 {
-				// We've reached the end and there's
-				// padding
-				if src[i*4+3] != '=' {
-					return n, false, CorruptInputError(i*4 + 2)
-				}
-				dlen = j
-				end = true
-				break dbufloop
-			}
-			dbuf[j] = enc.decodeMap[in]
-			if dbuf[j] == 0xFF {
-				return n, false, CorruptInputError(i*4 + j)
-			}
-		}
-
-		// Pack 4x 6-bit source blocks into 3 byte destination
-		// quantum
-		switch dlen {
-		case 4:
-			dst[i*3+2] = dbuf[2]<<6 | dbuf[3]
-			fallthrough
-		case 3:
-			dst[i*3+1] = dbuf[1]<<4 | dbuf[2]>>2
-			fallthrough
-		case 2:
-			dst[i*3+0] = dbuf[0]<<2 | dbuf[1]>>4
-		}
-		n += dlen - 1
-	}
-
-	return n, end, nil
-}
-
-// Decode decodes src using the encoding enc.  It writes at most
-// DecodedLen(len(src)) bytes to dst and returns the number of bytes
-// written.  If src contains invalid base64 data, it will return the
-// number of bytes successfully written and CorruptInputError.
-func (enc *Encoding) Decode(dst, src []byte) (n int, err os.Error) {
-	if len(src)%4 != 0 {
-		return 0, CorruptInputError(len(src) / 4 * 4)
-	}
-
-	n, _, err = enc.decode(dst, src)
-	return
-}
-
-// DecodeString returns the bytes represented by the base64 string s.
-func (enc *Encoding) DecodeString(s string) ([]byte, os.Error) {
-	dbuf := make([]byte, enc.DecodedLen(len(s)))
-	n, err := enc.Decode(dbuf, []byte(s))
-	return dbuf[:n], err
-}
-
-type decoder struct {
-	err    os.Error
-	enc    *Encoding
-	r      io.Reader
-	end    bool       // saw end of message
-	buf    [1024]byte // leftover input
-	nbuf   int
-	out    []byte // leftover decoded output
-	outbuf [1024 / 4 * 3]byte
-}
-
-func (d *decoder) Read(p []byte) (n int, err os.Error) {
-	if d.err != nil {
-		return 0, d.err
-	}
-
-	// Use leftover decoded output from last read.
-	if len(d.out) > 0 {
-		n = copy(p, d.out)
-		d.out = d.out[n:]
-		return n, nil
-	}
-
-	// Read a chunk.
-	nn := len(p) / 3 * 4
-	if nn < 4 {
-		nn = 4
-	}
-	if nn > len(d.buf) {
-		nn = len(d.buf)
-	}
-	nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf)
-	d.nbuf += nn
-	if d.nbuf < 4 {
-		return 0, d.err
-	}
-
-	// Decode chunk into p, or d.out and then p if p is too small.
-	nr := d.nbuf / 4 * 4
-	nw := d.nbuf / 4 * 3
-	if nw > len(p) {
-		nw, d.end, d.err = d.enc.decode(d.outbuf[0:], d.buf[0:nr])
-		d.out = d.outbuf[0:nw]
-		n = copy(p, d.out)
-		d.out = d.out[n:]
-	} else {
-		n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
-	}
-	d.nbuf -= nr
-	for i := 0; i < d.nbuf; i++ {
-		d.buf[i] = d.buf[i+nr]
-	}
-
-	if d.err == nil {
-		d.err = err
-	}
-	return n, d.err
-}
-
-// NewDecoder constructs a new base64 stream decoder.
-func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
-	return &decoder{enc: enc, r: r}
-}
-
-// DecodedLen returns the maximum length in bytes of the decoded data
-// corresponding to n bytes of base64-encoded data.
-func (enc *Encoding) DecodedLen(n int) int { return n / 4 * 3 }
diff --git a/src/pkg/encoding/base64/base64_test.go b/src/pkg/encoding/base64/base64_test.go
deleted file mode 100644
index c163dae84..000000000
--- a/src/pkg/encoding/base64/base64_test.go
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package base64
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-type testpair struct {
-	decoded, encoded string
-}
-
-var pairs = []testpair{
-	// RFC 3548 examples
-	{"\x14\xfb\x9c\x03\xd9\x7e", "FPucA9l+"},
-	{"\x14\xfb\x9c\x03\xd9", "FPucA9k="},
-	{"\x14\xfb\x9c\x03", "FPucAw=="},
-
-	// RFC 4648 examples
-	{"", ""},
-	{"f", "Zg=="},
-	{"fo", "Zm8="},
-	{"foo", "Zm9v"},
-	{"foob", "Zm9vYg=="},
-	{"fooba", "Zm9vYmE="},
-	{"foobar", "Zm9vYmFy"},
-
-	// Wikipedia examples
-	{"sure.", "c3VyZS4="},
-	{"sure", "c3VyZQ=="},
-	{"sur", "c3Vy"},
-	{"su", "c3U="},
-	{"leasure.", "bGVhc3VyZS4="},
-	{"easure.", "ZWFzdXJlLg=="},
-	{"asure.", "YXN1cmUu"},
-	{"sure.", "c3VyZS4="},
-}
-
-var bigtest = testpair{
-	"Twas brillig, and the slithy toves",
-	"VHdhcyBicmlsbGlnLCBhbmQgdGhlIHNsaXRoeSB0b3Zlcw==",
-}
-
-func testEqual(t *testing.T, msg string, args ...interface{}) bool {
-	if args[len(args)-2] != args[len(args)-1] {
-		t.Errorf(msg, args...)
-		return false
-	}
-	return true
-}
-
-func TestEncode(t *testing.T) {
-	for _, p := range pairs {
-		got := StdEncoding.EncodeToString([]byte(p.decoded))
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, got, p.encoded)
-	}
-}
-
-func TestEncoder(t *testing.T) {
-	for _, p := range pairs {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(StdEncoding, bb)
-		encoder.Write([]byte(p.decoded))
-		encoder.Close()
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
-	}
-}
-
-func TestEncoderBuffering(t *testing.T) {
-	input := []byte(bigtest.decoded)
-	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(StdEncoding, bb)
-		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs
-			if end > len(input) {
-				end = len(input)
-			}
-			n, err := encoder.Write(input[pos:end])
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
-		}
-		err := encoder.Close()
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded)
-	}
-}
-
-func TestDecode(t *testing.T) {
-	for _, p := range pairs {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
-		count, end, err := StdEncoding.decode(dbuf, []byte(p.encoded))
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
-		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded))
-		if len(p.encoded) > 0 {
-			testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '='))
-		}
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
-
-		dbuf, err = StdEncoding.DecodeString(p.encoded)
-		testEqual(t, "DecodeString(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
-		testEqual(t, "DecodeString(%q) = %q, want %q", string(dbuf), p.decoded)
-	}
-}
-
-func TestDecoder(t *testing.T) {
-	for _, p := range pairs {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded))
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
-		count, err := decoder.Read(dbuf)
-		if err != nil && err != os.EOF {
-			t.Fatal("Read failed", err)
-		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded))
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
-		if err != os.EOF {
-			count, err = decoder.Read(dbuf)
-		}
-		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
-	}
-}
-
-func TestDecoderBuffering(t *testing.T) {
-	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded))
-		buf := make([]byte, len(bigtest.decoded)+12)
-		var total int
-		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs])
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
-			total += n
-		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
-	}
-}
-
-func TestDecodeCorrupt(t *testing.T) {
-	type corrupt struct {
-		e string
-		p int
-	}
-	examples := []corrupt{
-		{"!!!!", 0},
-		{"x===", 1},
-		{"AA=A", 2},
-		{"AAA=AAAA", 3},
-		{"AAAAA", 4},
-		{"AAAAAA", 4},
-	}
-
-	for _, e := range examples {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e)))
-		_, err := StdEncoding.Decode(dbuf, []byte(e.e))
-		switch err := err.(type) {
-		case CorruptInputError:
-			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
-		default:
-			t.Error("Decoder failed to detect corruption in", e)
-		}
-	}
-}
-
-func TestBig(t *testing.T) {
-	n := 3*1000 + 1
-	raw := make([]byte, n)
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	for i := 0; i < n; i++ {
-		raw[i] = alpha[i%len(alpha)]
-	}
-	encoded := new(bytes.Buffer)
-	w := NewEncoder(StdEncoding, encoded)
-	nn, err := w.Write(raw)
-	if nn != n || err != nil {
-		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
-	}
-	err = w.Close()
-	if err != nil {
-		t.Fatalf("Encoder.Close() = %v want nil", err)
-	}
-	decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded))
-	if err != nil {
-		t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
-	}
-
-	if !bytes.Equal(raw, decoded) {
-		var i int
-		for i = 0; i < len(decoded) && i < len(raw); i++ {
-			if decoded[i] != raw[i] {
-				break
-			}
-		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
-	}
-}
diff --git a/src/pkg/encoding/binary/Makefile b/src/pkg/encoding/binary/Makefile
deleted file mode 100644
index dc46abe90..000000000
--- a/src/pkg/encoding/binary/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/binary
-GOFILES=\
-	binary.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go
deleted file mode 100644
index 8e55cb23b..000000000
--- a/src/pkg/encoding/binary/binary.go
+++ /dev/null
@@ -1,498 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package binary implements translation between
-// unsigned integer values and byte sequences
-// and the reading and writing of fixed-size values.
-package binary
-
-import (
-	"math"
-	"io"
-	"os"
-	"reflect"
-)
-
-// A ByteOrder specifies how to convert byte sequences into
-// 16-, 32-, or 64-bit unsigned integers.
-type ByteOrder interface {
-	Uint16(b []byte) uint16
-	Uint32(b []byte) uint32
-	Uint64(b []byte) uint64
-	PutUint16([]byte, uint16)
-	PutUint32([]byte, uint32)
-	PutUint64([]byte, uint64)
-	String() string
-}
-
-// This is byte instead of struct{} so that it can be compared,
-// allowing, e.g., order == binary.LittleEndian.
-type unused byte
-
-// LittleEndian is the little-endian implementation of ByteOrder.
-var LittleEndian littleEndian
-
-// BigEndian is the big-endian implementation of ByteOrder.
-var BigEndian bigEndian
-
-type littleEndian unused
-
-func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 }
-
-func (littleEndian) PutUint16(b []byte, v uint16) {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-}
-
-func (littleEndian) Uint32(b []byte) uint32 {
-	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-}
-
-func (littleEndian) PutUint32(b []byte, v uint32) {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-	b[2] = byte(v >> 16)
-	b[3] = byte(v >> 24)
-}
-
-func (littleEndian) Uint64(b []byte) uint64 {
-	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
-		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-}
-
-func (littleEndian) PutUint64(b []byte, v uint64) {
-	b[0] = byte(v)
-	b[1] = byte(v >> 8)
-	b[2] = byte(v >> 16)
-	b[3] = byte(v >> 24)
-	b[4] = byte(v >> 32)
-	b[5] = byte(v >> 40)
-	b[6] = byte(v >> 48)
-	b[7] = byte(v >> 56)
-}
-
-func (littleEndian) String() string { return "LittleEndian" }
-
-func (littleEndian) GoString() string { return "binary.LittleEndian" }
-
-type bigEndian unused
-
-func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 }
-
-func (bigEndian) PutUint16(b []byte, v uint16) {
-	b[0] = byte(v >> 8)
-	b[1] = byte(v)
-}
-
-func (bigEndian) Uint32(b []byte) uint32 {
-	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
-}
-
-func (bigEndian) PutUint32(b []byte, v uint32) {
-	b[0] = byte(v >> 24)
-	b[1] = byte(v >> 16)
-	b[2] = byte(v >> 8)
-	b[3] = byte(v)
-}
-
-func (bigEndian) Uint64(b []byte) uint64 {
-	return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
-		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
-}
-
-func (bigEndian) PutUint64(b []byte, v uint64) {
-	b[0] = byte(v >> 56)
-	b[1] = byte(v >> 48)
-	b[2] = byte(v >> 40)
-	b[3] = byte(v >> 32)
-	b[4] = byte(v >> 24)
-	b[5] = byte(v >> 16)
-	b[6] = byte(v >> 8)
-	b[7] = byte(v)
-}
-
-func (bigEndian) String() string { return "BigEndian" }
-
-func (bigEndian) GoString() string { return "binary.BigEndian" }
-
-// Read reads structured binary data from r into data.
-// Data must be a pointer to a fixed-size value or a slice
-// of fixed-size values.
-// A fixed-size value is either a fixed-size arithmetic
-// type (int8, uint8, int16, float32, complex64, ...)
-// or an array or struct containing only fixed-size values.
-// Bytes read from r are decoded using the specified byte order
-// and written to successive fields of the data.
-func Read(r io.Reader, order ByteOrder, data interface{}) os.Error {
-	// Fast path for basic types.
-	if n := intDestSize(data); n != 0 {
-		var b [8]byte
-		bs := b[:n]
-		if _, err := io.ReadFull(r, bs); err != nil {
-			return err
-		}
-		switch v := data.(type) {
-		case *int8:
-			*v = int8(b[0])
-		case *uint8:
-			*v = b[0]
-		case *int16:
-			*v = int16(order.Uint16(bs))
-		case *uint16:
-			*v = order.Uint16(bs)
-		case *int32:
-			*v = int32(order.Uint32(bs))
-		case *uint32:
-			*v = order.Uint32(bs)
-		case *int64:
-			*v = int64(order.Uint64(bs))
-		case *uint64:
-			*v = order.Uint64(bs)
-		}
-		return nil
-	}
-
-	// Fallback to reflect-based.
-	var v reflect.Value
-	switch d := reflect.ValueOf(data); d.Kind() {
-	case reflect.Ptr:
-		v = d.Elem()
-	case reflect.Slice:
-		v = d
-	default:
-		return os.NewError("binary.Read: invalid type " + d.Type().String())
-	}
-	size := TotalSize(v)
-	if size < 0 {
-		return os.NewError("binary.Read: invalid type " + v.Type().String())
-	}
-	d := &decoder{order: order, buf: make([]byte, size)}
-	if _, err := io.ReadFull(r, d.buf); err != nil {
-		return err
-	}
-	d.value(v)
-	return nil
-}
-
-// Write writes the binary representation of data into w.
-// Data must be a fixed-size value or a pointer to
-// a fixed-size value.
-// A fixed-size value is either a fixed-size arithmetic
-// type (int8, uint8, int16, float32, complex64, ...)
-// or an array or struct containing only fixed-size values.
-// Bytes written to w are encoded using the specified byte order
-// and read from successive fields of the data.
-func Write(w io.Writer, order ByteOrder, data interface{}) os.Error {
-	// Fast path for basic types.
-	var b [8]byte
-	var bs []byte
-	switch v := data.(type) {
-	case *int8:
-		bs = b[:1]
-		b[0] = byte(*v)
-	case int8:
-		bs = b[:1]
-		b[0] = byte(v)
-	case *uint8:
-		bs = b[:1]
-		b[0] = *v
-	case uint8:
-		bs = b[:1]
-		b[0] = byte(v)
-	case *int16:
-		bs = b[:2]
-		order.PutUint16(bs, uint16(*v))
-	case int16:
-		bs = b[:2]
-		order.PutUint16(bs, uint16(v))
-	case *uint16:
-		bs = b[:2]
-		order.PutUint16(bs, *v)
-	case uint16:
-		bs = b[:2]
-		order.PutUint16(bs, v)
-	case *int32:
-		bs = b[:4]
-		order.PutUint32(bs, uint32(*v))
-	case int32:
-		bs = b[:4]
-		order.PutUint32(bs, uint32(v))
-	case *uint32:
-		bs = b[:4]
-		order.PutUint32(bs, *v)
-	case uint32:
-		bs = b[:4]
-		order.PutUint32(bs, v)
-	case *int64:
-		bs = b[:8]
-		order.PutUint64(bs, uint64(*v))
-	case int64:
-		bs = b[:8]
-		order.PutUint64(bs, uint64(v))
-	case *uint64:
-		bs = b[:8]
-		order.PutUint64(bs, *v)
-	case uint64:
-		bs = b[:8]
-		order.PutUint64(bs, v)
-	}
-	if bs != nil {
-		_, err := w.Write(bs)
-		return err
-	}
-	v := reflect.Indirect(reflect.ValueOf(data))
-	size := TotalSize(v)
-	if size < 0 {
-		return os.NewError("binary.Write: invalid type " + v.Type().String())
-	}
-	buf := make([]byte, size)
-	e := &encoder{order: order, buf: buf}
-	e.value(v)
-	_, err := w.Write(buf)
-	return err
-}
-
-func TotalSize(v reflect.Value) int {
-	if v.Kind() == reflect.Slice {
-		elem := sizeof(v.Type().Elem())
-		if elem < 0 {
-			return -1
-		}
-		return v.Len() * elem
-	}
-	return sizeof(v.Type())
-}
-
-func sizeof(t reflect.Type) int {
-	switch t.Kind() {
-	case reflect.Array:
-		n := sizeof(t.Elem())
-		if n < 0 {
-			return -1
-		}
-		return t.Len() * n
-
-	case reflect.Struct:
-		sum := 0
-		for i, n := 0, t.NumField(); i < n; i++ {
-			s := sizeof(t.Field(i).Type)
-			if s < 0 {
-				return -1
-			}
-			sum += s
-		}
-		return sum
-
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
-		return int(t.Size())
-	}
-	return -1
-}
-
-type decoder struct {
-	order ByteOrder
-	buf   []byte
-}
-
-type encoder struct {
-	order ByteOrder
-	buf   []byte
-}
-
-func (d *decoder) uint8() uint8 {
-	x := d.buf[0]
-	d.buf = d.buf[1:]
-	return x
-}
-
-func (e *encoder) uint8(x uint8) {
-	e.buf[0] = x
-	e.buf = e.buf[1:]
-}
-
-func (d *decoder) uint16() uint16 {
-	x := d.order.Uint16(d.buf[0:2])
-	d.buf = d.buf[2:]
-	return x
-}
-
-func (e *encoder) uint16(x uint16) {
-	e.order.PutUint16(e.buf[0:2], x)
-	e.buf = e.buf[2:]
-}
-
-func (d *decoder) uint32() uint32 {
-	x := d.order.Uint32(d.buf[0:4])
-	d.buf = d.buf[4:]
-	return x
-}
-
-func (e *encoder) uint32(x uint32) {
-	e.order.PutUint32(e.buf[0:4], x)
-	e.buf = e.buf[4:]
-}
-
-func (d *decoder) uint64() uint64 {
-	x := d.order.Uint64(d.buf[0:8])
-	d.buf = d.buf[8:]
-	return x
-}
-
-func (e *encoder) uint64(x uint64) {
-	e.order.PutUint64(e.buf[0:8], x)
-	e.buf = e.buf[8:]
-}
-
-func (d *decoder) int8() int8 { return int8(d.uint8()) }
-
-func (e *encoder) int8(x int8) { e.uint8(uint8(x)) }
-
-func (d *decoder) int16() int16 { return int16(d.uint16()) }
-
-func (e *encoder) int16(x int16) { e.uint16(uint16(x)) }
-
-func (d *decoder) int32() int32 { return int32(d.uint32()) }
-
-func (e *encoder) int32(x int32) { e.uint32(uint32(x)) }
-
-func (d *decoder) int64() int64 { return int64(d.uint64()) }
-
-func (e *encoder) int64(x int64) { e.uint64(uint64(x)) }
-
-func (d *decoder) value(v reflect.Value) {
-	switch v.Kind() {
-	case reflect.Array:
-		l := v.Len()
-		for i := 0; i < l; i++ {
-			d.value(v.Index(i))
-		}
-	case reflect.Struct:
-		l := v.NumField()
-		for i := 0; i < l; i++ {
-			d.value(v.Field(i))
-		}
-
-	case reflect.Slice:
-		l := v.Len()
-		for i := 0; i < l; i++ {
-			d.value(v.Index(i))
-		}
-
-	case reflect.Int8:
-		v.SetInt(int64(d.int8()))
-	case reflect.Int16:
-		v.SetInt(int64(d.int16()))
-	case reflect.Int32:
-		v.SetInt(int64(d.int32()))
-	case reflect.Int64:
-		v.SetInt(d.int64())
-
-	case reflect.Uint8:
-		v.SetUint(uint64(d.uint8()))
-	case reflect.Uint16:
-		v.SetUint(uint64(d.uint16()))
-	case reflect.Uint32:
-		v.SetUint(uint64(d.uint32()))
-	case reflect.Uint64:
-		v.SetUint(d.uint64())
-
-	case reflect.Float32:
-		v.SetFloat(float64(math.Float32frombits(d.uint32())))
-	case reflect.Float64:
-		v.SetFloat(math.Float64frombits(d.uint64()))
-
-	case reflect.Complex64:
-		v.SetComplex(complex(
-			float64(math.Float32frombits(d.uint32())),
-			float64(math.Float32frombits(d.uint32())),
-		))
-	case reflect.Complex128:
-		v.SetComplex(complex(
-			math.Float64frombits(d.uint64()),
-			math.Float64frombits(d.uint64()),
-		))
-	}
-}
-
-func (e *encoder) value(v reflect.Value) {
-	switch v.Kind() {
-	case reflect.Array:
-		l := v.Len()
-		for i := 0; i < l; i++ {
-			e.value(v.Index(i))
-		}
-	case reflect.Struct:
-		l := v.NumField()
-		for i := 0; i < l; i++ {
-			e.value(v.Field(i))
-		}
-	case reflect.Slice:
-		l := v.Len()
-		for i := 0; i < l; i++ {
-			e.value(v.Index(i))
-		}
-
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		switch v.Type().Kind() {
-		case reflect.Int8:
-			e.int8(int8(v.Int()))
-		case reflect.Int16:
-			e.int16(int16(v.Int()))
-		case reflect.Int32:
-			e.int32(int32(v.Int()))
-		case reflect.Int64:
-			e.int64(v.Int())
-		}
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		switch v.Type().Kind() {
-		case reflect.Uint8:
-			e.uint8(uint8(v.Uint()))
-		case reflect.Uint16:
-			e.uint16(uint16(v.Uint()))
-		case reflect.Uint32:
-			e.uint32(uint32(v.Uint()))
-		case reflect.Uint64:
-			e.uint64(v.Uint())
-		}
-
-	case reflect.Float32, reflect.Float64:
-		switch v.Type().Kind() {
-		case reflect.Float32:
-			e.uint32(math.Float32bits(float32(v.Float())))
-		case reflect.Float64:
-			e.uint64(math.Float64bits(v.Float()))
-		}
-
-	case reflect.Complex64, reflect.Complex128:
-		switch v.Type().Kind() {
-		case reflect.Complex64:
-			x := v.Complex()
-			e.uint32(math.Float32bits(float32(real(x))))
-			e.uint32(math.Float32bits(float32(imag(x))))
-		case reflect.Complex128:
-			x := v.Complex()
-			e.uint64(math.Float64bits(real(x)))
-			e.uint64(math.Float64bits(imag(x)))
-		}
-	}
-}
-
-// intDestSize returns the size of the integer that ptrType points to,
-// or 0 if the type is not supported.
-func intDestSize(ptrType interface{}) int {
-	switch ptrType.(type) {
-	case *int8, *uint8:
-		return 1
-	case *int16, *uint16:
-		return 2
-	case *int32, *uint32:
-		return 4
-	case *int64, *uint64:
-		return 8
-	}
-	return 0
-}
diff --git a/src/pkg/encoding/binary/binary_test.go b/src/pkg/encoding/binary/binary_test.go
deleted file mode 100644
index b266996f6..000000000
--- a/src/pkg/encoding/binary/binary_test.go
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package binary
-
-import (
-	"io"
-	"os"
-	"bytes"
-	"math"
-	"reflect"
-	"testing"
-)
-
-type Struct struct {
-	Int8       int8
-	Int16      int16
-	Int32      int32
-	Int64      int64
-	Uint8      uint8
-	Uint16     uint16
-	Uint32     uint32
-	Uint64     uint64
-	Float32    float32
-	Float64    float64
-	Complex64  complex64
-	Complex128 complex128
-	Array      [4]uint8
-}
-
-type T struct {
-	Int     int
-	Uint    uint
-	Uintptr uintptr
-	Array   [4]int
-}
-
-var s = Struct{
-	0x01,
-	0x0203,
-	0x04050607,
-	0x08090a0b0c0d0e0f,
-	0x10,
-	0x1112,
-	0x13141516,
-	0x1718191a1b1c1d1e,
-
-	math.Float32frombits(0x1f202122),
-	math.Float64frombits(0x232425262728292a),
-	complex(
-		math.Float32frombits(0x2b2c2d2e),
-		math.Float32frombits(0x2f303132),
-	),
-	complex(
-		math.Float64frombits(0x333435363738393a),
-		math.Float64frombits(0x3b3c3d3e3f404142),
-	),
-
-	[4]uint8{0x43, 0x44, 0x45, 0x46},
-}
-
-var big = []byte{
-	1,
-	2, 3,
-	4, 5, 6, 7,
-	8, 9, 10, 11, 12, 13, 14, 15,
-	16,
-	17, 18,
-	19, 20, 21, 22,
-	23, 24, 25, 26, 27, 28, 29, 30,
-
-	31, 32, 33, 34,
-	35, 36, 37, 38, 39, 40, 41, 42,
-	43, 44, 45, 46, 47, 48, 49, 50,
-	51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
-
-	67, 68, 69, 70,
-}
-
-var little = []byte{
-	1,
-	3, 2,
-	7, 6, 5, 4,
-	15, 14, 13, 12, 11, 10, 9, 8,
-	16,
-	18, 17,
-	22, 21, 20, 19,
-	30, 29, 28, 27, 26, 25, 24, 23,
-
-	34, 33, 32, 31,
-	42, 41, 40, 39, 38, 37, 36, 35,
-	46, 45, 44, 43, 50, 49, 48, 47,
-	58, 57, 56, 55, 54, 53, 52, 51, 66, 65, 64, 63, 62, 61, 60, 59,
-
-	67, 68, 69, 70,
-}
-
-var src = []byte{1, 2, 3, 4, 5, 6, 7, 8}
-var res = []int32{0x01020304, 0x05060708}
-
-func checkResult(t *testing.T, dir string, order, err os.Error, have, want interface{}) {
-	if err != nil {
-		t.Errorf("%v %v: %v", dir, order, err)
-		return
-	}
-	if !reflect.DeepEqual(have, want) {
-		t.Errorf("%v %v:\n\thave %+v\n\twant %+v", dir, order, have, want)
-	}
-}
-
-func testRead(t *testing.T, order ByteOrder, b []byte, s1 interface{}) {
-	var s2 Struct
-	err := Read(bytes.NewBuffer(b), order, &s2)
-	checkResult(t, "Read", order, err, s2, s1)
-}
-
-func testWrite(t *testing.T, order ByteOrder, b []byte, s1 interface{}) {
-	buf := new(bytes.Buffer)
-	err := Write(buf, order, s1)
-	checkResult(t, "Write", order, err, buf.Bytes(), b)
-}
-
-func TestBigEndianRead(t *testing.T) { testRead(t, BigEndian, big, s) }
-
-func TestLittleEndianRead(t *testing.T) { testRead(t, LittleEndian, little, s) }
-
-func TestBigEndianWrite(t *testing.T) { testWrite(t, BigEndian, big, s) }
-
-func TestLittleEndianWrite(t *testing.T) { testWrite(t, LittleEndian, little, s) }
-
-func TestBigEndianPtrWrite(t *testing.T) { testWrite(t, BigEndian, big, &s) }
-
-func TestLittleEndianPtrWrite(t *testing.T) { testWrite(t, LittleEndian, little, &s) }
-
-func TestReadSlice(t *testing.T) {
-	slice := make([]int32, 2)
-	err := Read(bytes.NewBuffer(src), BigEndian, slice)
-	checkResult(t, "ReadSlice", BigEndian, err, slice, res)
-}
-
-func TestWriteSlice(t *testing.T) {
-	buf := new(bytes.Buffer)
-	err := Write(buf, BigEndian, res)
-	checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src)
-}
-
-func TestWriteT(t *testing.T) {
-	buf := new(bytes.Buffer)
-	ts := T{}
-	err := Write(buf, BigEndian, ts)
-	if err == nil {
-		t.Errorf("WriteT: have nil, want non-nil")
-	}
-
-	tv := reflect.Indirect(reflect.ValueOf(ts))
-	for i, n := 0, tv.NumField(); i < n; i++ {
-		err = Write(buf, BigEndian, tv.Field(i).Interface())
-		if err == nil {
-			t.Errorf("WriteT.%v: have nil, want non-nil", tv.Field(i).Type())
-		}
-	}
-}
-
-type byteSliceReader struct {
-	remain []byte
-}
-
-func (br *byteSliceReader) Read(p []byte) (int, os.Error) {
-	n := copy(p, br.remain)
-	br.remain = br.remain[n:]
-	return n, nil
-}
-
-func BenchmarkRead(b *testing.B) {
-	var ls Struct
-	bsr := &byteSliceReader{}
-	var r io.Reader = bsr
-
-	for i := 0; i < b.N; i++ {
-		bsr.remain = big
-		Read(r, BigEndian, &ls.Int8)
-		Read(r, BigEndian, &ls.Int16)
-		Read(r, BigEndian, &ls.Int32)
-		Read(r, BigEndian, &ls.Int64)
-		Read(r, BigEndian, &ls.Uint8)
-		Read(r, BigEndian, &ls.Uint16)
-		Read(r, BigEndian, &ls.Uint32)
-		Read(r, BigEndian, &ls.Uint64)
-	}
-
-	want := s
-	want.Float32 = 0
-	want.Float64 = 0
-	want.Complex64 = 0
-	want.Complex128 = 0
-	for i := range want.Array {
-		want.Array[i] = 0
-	}
-	if !reflect.DeepEqual(ls, want) {
-		panic("no match")
-	}
-}
-
-func BenchmarkWrite(b *testing.B) {
-	buf := new(bytes.Buffer)
-	var w io.Writer = buf
-
-	for i := 0; i < b.N; i++ {
-		buf.Reset()
-		Write(w, BigEndian, &s.Int8)
-		Write(w, BigEndian, &s.Int16)
-		Write(w, BigEndian, &s.Int32)
-		Write(w, BigEndian, &s.Int64)
-		Write(w, BigEndian, &s.Uint8)
-		Write(w, BigEndian, &s.Uint16)
-		Write(w, BigEndian, &s.Uint32)
-		Write(w, BigEndian, &s.Uint64)
-		Write(w, BigEndian, s.Int8)
-		Write(w, BigEndian, s.Int16)
-		Write(w, BigEndian, s.Int32)
-		Write(w, BigEndian, s.Int64)
-		Write(w, BigEndian, s.Uint8)
-		Write(w, BigEndian, s.Uint16)
-		Write(w, BigEndian, s.Uint32)
-		Write(w, BigEndian, s.Uint64)
-	}
-
-	if !bytes.Equal(buf.Bytes()[:30], big[:30]) {
-		panic("first half doesn't match")
-	}
-	if !bytes.Equal(buf.Bytes()[30:], big[:30]) {
-		panic("second half doesn't match")
-	}
-}
diff --git a/src/pkg/encoding/git85/Makefile b/src/pkg/encoding/git85/Makefile
deleted file mode 100644
index fbd003454..000000000
--- a/src/pkg/encoding/git85/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/git85
-GOFILES=\
-	git.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/git85/git.go b/src/pkg/encoding/git85/git.go
deleted file mode 100644
index 6bb74f46c..000000000
--- a/src/pkg/encoding/git85/git.go
+++ /dev/null
@@ -1,277 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package git85 implements the radix 85 data encoding
-// used in the Git version control system.
-package git85
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"strconv"
-)
-
-type CorruptInputError int64
-
-func (e CorruptInputError) String() string {
-	return "illegal git85 data at input byte " + strconv.Itoa64(int64(e))
-}
-
-const encode = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
-
-// The decodings are 1+ the actual value, so that the
-// default zero value can be used to mean "not valid".
-var decode = [256]uint8{
-	'0': 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-	'A': 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-	24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
-	'a': 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
-	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
-	'!': 63,
-	'#': 64, 65, 66, 67,
-	'(': 68, 69, 70, 71,
-	'-': 72,
-	';': 73,
-	'<': 74, 75, 76, 77,
-	'@': 78,
-	'^': 79, 80, 81,
-	'{': 82, 83, 84, 85,
-}
-
-// Encode encodes src into EncodedLen(len(src))
-// bytes of dst.  As a convenience, it returns the number
-// of bytes written to dst, but this value is always EncodedLen(len(src)).
-// Encode implements the radix 85 encoding used in the
-// Git version control tool.
-//
-// The encoding splits src into chunks of at most 52 bytes
-// and encodes each chunk on its own line.
-func Encode(dst, src []byte) int {
-	ndst := 0
-	for len(src) > 0 {
-		n := len(src)
-		if n > 52 {
-			n = 52
-		}
-		if n <= 27 {
-			dst[ndst] = byte('A' + n - 1)
-		} else {
-			dst[ndst] = byte('a' + n - 26 - 1)
-		}
-		ndst++
-		for i := 0; i < n; i += 4 {
-			var v uint32
-			for j := 0; j < 4 && i+j < n; j++ {
-				v |= uint32(src[i+j]) << uint(24-j*8)
-			}
-			for j := 4; j >= 0; j-- {
-				dst[ndst+j] = encode[v%85]
-				v /= 85
-			}
-			ndst += 5
-		}
-		dst[ndst] = '\n'
-		ndst++
-		src = src[n:]
-	}
-	return ndst
-}
-
-// EncodedLen returns the length of an encoding of n source bytes.
-func EncodedLen(n int) int {
-	if n == 0 {
-		return 0
-	}
-	// 5 bytes per 4 bytes of input, rounded up.
-	// 2 extra bytes for each line of 52 src bytes, rounded up.
-	return (n+3)/4*5 + (n+51)/52*2
-}
-
-var newline = []byte{'\n'}
-
-// Decode decodes src into at most MaxDecodedLen(len(src))
-// bytes, returning the actual number of bytes written to dst.
-//
-// If Decode encounters invalid input, it returns a CorruptInputError.
-//
-func Decode(dst, src []byte) (n int, err os.Error) {
-	ndst := 0
-	nsrc := 0
-	for nsrc < len(src) {
-		var l int
-		switch ch := int(src[nsrc]); {
-		case 'A' <= ch && ch <= 'Z':
-			l = ch - 'A' + 1
-		case 'a' <= ch && ch <= 'z':
-			l = ch - 'a' + 26 + 1
-		default:
-			return ndst, CorruptInputError(nsrc)
-		}
-		if nsrc+1+l > len(src) {
-			return ndst, CorruptInputError(nsrc)
-		}
-		el := (l + 3) / 4 * 5 // encoded len
-		if nsrc+1+el+1 > len(src) || src[nsrc+1+el] != '\n' {
-			return ndst, CorruptInputError(nsrc)
-		}
-		line := src[nsrc+1 : nsrc+1+el]
-		for i := 0; i < el; i += 5 {
-			var v uint32
-			for j := 0; j < 5; j++ {
-				ch := decode[line[i+j]]
-				if ch == 0 {
-					return ndst, CorruptInputError(nsrc + 1 + i + j)
-				}
-				v = v*85 + uint32(ch-1)
-			}
-			for j := 0; j < 4; j++ {
-				dst[ndst] = byte(v >> 24)
-				v <<= 8
-				ndst++
-			}
-		}
-		// Last fragment may have run too far (but there was room in dst).
-		// Back up.
-		if l%4 != 0 {
-			ndst -= 4 - l%4
-		}
-		nsrc += 1 + el + 1
-	}
-	return ndst, nil
-}
-
-func MaxDecodedLen(n int) int { return n / 5 * 4 }
-
-// NewEncoder returns a new Git base85 stream encoder.  Data written to
-// the returned writer will be encoded and then written to w.
-// The Git encoding operates on 52-byte blocks; when finished
-// writing, the caller must Close the returned encoder to flush any
-// partially written blocks.
-func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} }
-
-type encoder struct {
-	w    io.Writer
-	err  os.Error
-	buf  [52]byte
-	nbuf int
-	out  [1024]byte
-	nout int
-}
-
-func (e *encoder) Write(p []byte) (n int, err os.Error) {
-	if e.err != nil {
-		return 0, e.err
-	}
-
-	// Leading fringe.
-	if e.nbuf > 0 {
-		var i int
-		for i = 0; i < len(p) && e.nbuf < 52; i++ {
-			e.buf[e.nbuf] = p[i]
-			e.nbuf++
-		}
-		n += i
-		p = p[i:]
-		if e.nbuf < 52 {
-			return
-		}
-		nout := Encode(e.out[0:], e.buf[0:])
-		if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
-			return n, e.err
-		}
-		e.nbuf = 0
-	}
-
-	// Large interior chunks.
-	for len(p) >= 52 {
-		nn := len(e.out) / (1 + 52/4*5 + 1) * 52
-		if nn > len(p) {
-			nn = len(p) / 52 * 52
-		}
-		if nn > 0 {
-			nout := Encode(e.out[0:], p[0:nn])
-			if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
-				return n, e.err
-			}
-		}
-		n += nn
-		p = p[nn:]
-	}
-
-	// Trailing fringe.
-	for i := 0; i < len(p); i++ {
-		e.buf[i] = p[i]
-	}
-	e.nbuf = len(p)
-	n += len(p)
-	return
-}
-
-func (e *encoder) Close() os.Error {
-	// If there's anything left in the buffer, flush it out
-	if e.err == nil && e.nbuf > 0 {
-		nout := Encode(e.out[0:], e.buf[0:e.nbuf])
-		e.nbuf = 0
-		_, e.err = e.w.Write(e.out[0:nout])
-	}
-	return e.err
-}
-
-// NewDecoder returns a new Git base85 stream decoder.
-func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
-
-type decoder struct {
-	r       io.Reader
-	err     os.Error
-	readErr os.Error
-	buf     [1024]byte
-	nbuf    int
-	out     []byte
-	outbuf  [1024]byte
-	off     int64
-}
-
-func (d *decoder) Read(p []byte) (n int, err os.Error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-
-	for {
-		// Copy leftover output from last decode.
-		if len(d.out) > 0 {
-			n = copy(p, d.out)
-			d.out = d.out[n:]
-			return
-		}
-
-		// Out of decoded output.  Check errors.
-		if d.err != nil {
-			return 0, d.err
-		}
-		if d.readErr != nil {
-			d.err = d.readErr
-			return 0, d.err
-		}
-
-		// Read and decode more input.
-		var nn int
-		nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
-		d.nbuf += nn
-
-		// Send complete lines to Decode.
-		nl := bytes.LastIndex(d.buf[0:d.nbuf], newline)
-		if nl < 0 {
-			continue
-		}
-		nn, d.err = Decode(d.outbuf[0:], d.buf[0:nl+1])
-		if e, ok := d.err.(CorruptInputError); ok {
-			d.err = CorruptInputError(int64(e) + d.off)
-		}
-		d.out = d.outbuf[0:nn]
-		d.nbuf = copy(d.buf[0:], d.buf[nl+1:d.nbuf])
-		d.off += int64(nl + 1)
-	}
-	panic("unreachable")
-}
diff --git a/src/pkg/encoding/git85/git_test.go b/src/pkg/encoding/git85/git_test.go
deleted file mode 100644
index c76385c35..000000000
--- a/src/pkg/encoding/git85/git_test.go
+++ /dev/null
@@ -1,194 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package git85
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-type testpair struct {
-	decoded, encoded string
-}
-
-func testEqual(t *testing.T, msg string, args ...interface{}) bool {
-	if args[len(args)-2] != args[len(args)-1] {
-		t.Errorf(msg, args...)
-		return false
-	}
-	return true
-}
-
-func TestGitTable(t *testing.T) {
-	var saw [256]bool
-	for i, c := range encode {
-		if decode[c] != uint8(i+1) {
-			t.Errorf("decode['%c'] = %d, want %d", c, decode[c], i+1)
-		}
-		saw[c] = true
-	}
-	for i, b := range saw {
-		if !b && decode[i] != 0 {
-			t.Errorf("decode[%d] = %d, want 0", i, decode[i])
-		}
-	}
-}
-
-var gitPairs = []testpair{
-	// Wikipedia example, adapted.
-	{
-		"Man is distinguished, not only by his reason, but by this singular passion from " +
-			"other animals, which is a lust of the mind, that by a perseverance of delight in " +
-			"the continued and indefatigable generation of knowledge, exceeds the short " +
-			"vehemence of any carnal pleasure.",
-
-		"zO<`^zX>%ZCX>)XGZfA9Ab7*B`EFf-gbRchTY<VDJc_3(Mb0BhMVRLV8EFfZabRc4R\n" +
-			"zAarPHb0BkRZfA9DVR9gFVRLh7Z*CxFa&K)QZ**v7av))DX>DO_b1WctXlY|;AZc?T\n" +
-			"zVIXXEb95kYW*~HEWgu;7Ze%PVbZB98AYyqSVIXj2a&u*NWpZI|V`U(3W*}r`Y-wj`\n" +
-			"zbRcPNAarPDAY*TCbZKsNWn>^>Ze$>7Ze(R<VRUI{VPb4$AZKN6WpZJ3X>V>IZ)PBC\n" +
-			"zZf|#NWn^b%EFfigV`XJzb0BnRWgv5CZ*p`Xc4cT~ZDnp_Wgu^6AYpEKAY);2ZeeU7\n" +
-			"IaBO8^b9HiME&u=k\n",
-	},
-}
-
-var gitBigtest = gitPairs[len(gitPairs)-1]
-
-func TestEncode(t *testing.T) {
-	for _, p := range gitPairs {
-		buf := make([]byte, EncodedLen(len(p.decoded)))
-		n := Encode(buf, []byte(p.decoded))
-		if n != len(buf) {
-			t.Errorf("EncodedLen does not agree with Encode")
-		}
-		buf = buf[0:n]
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded)
-	}
-}
-
-func TestEncoder(t *testing.T) {
-	for _, p := range gitPairs {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(bb)
-		encoder.Write([]byte(p.decoded))
-		encoder.Close()
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
-	}
-}
-
-func TestEncoderBuffering(t *testing.T) {
-	input := []byte(gitBigtest.decoded)
-	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{}
-		encoder := NewEncoder(bb)
-		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs
-			if end > len(input) {
-				end = len(input)
-			}
-			n, err := encoder.Write(input[pos:end])
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
-		}
-		err := encoder.Close()
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded)
-	}
-}
-
-func TestDecode(t *testing.T) {
-	for _, p := range gitPairs {
-		dbuf := make([]byte, 4*len(p.encoded))
-		ndst, err := Decode(dbuf, []byte(p.encoded))
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
-		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
-	}
-}
-
-func TestDecoder(t *testing.T) {
-	for _, p := range gitPairs {
-		decoder := NewDecoder(bytes.NewBufferString(p.encoded))
-		dbuf, err := ioutil.ReadAll(decoder)
-		if err != nil {
-			t.Fatal("Read failed", err)
-		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
-		if err != nil {
-			testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
-		}
-	}
-}
-
-func TestDecoderBuffering(t *testing.T) {
-	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded))
-		buf := make([]byte, len(gitBigtest.decoded)+12)
-		var total int
-		for total = 0; total < len(gitBigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs])
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil))
-			total += n
-		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded)
-	}
-}
-
-func TestDecodeCorrupt(t *testing.T) {
-	type corrupt struct {
-		e string
-		p int
-	}
-	examples := []corrupt{
-		{"v", 0},
-		{"!z!!!!!!!!!", 0},
-	}
-
-	for _, e := range examples {
-		dbuf := make([]byte, 2*len(e.e))
-		_, err := Decode(dbuf, []byte(e.e))
-		switch err := err.(type) {
-		case CorruptInputError:
-			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
-		default:
-			t.Error("Decoder failed to detect corruption in", e)
-		}
-	}
-}
-
-func TestGitBig(t *testing.T) {
-	n := 3*1000 + 1
-	raw := make([]byte, n)
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	for i := 0; i < n; i++ {
-		raw[i] = alpha[i%len(alpha)]
-	}
-	encoded := new(bytes.Buffer)
-	w := NewEncoder(encoded)
-	nn, err := w.Write(raw)
-	if nn != n || err != nil {
-		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
-	}
-	err = w.Close()
-	if err != nil {
-		t.Fatalf("Encoder.Close() = %v want nil", err)
-	}
-	decoded, err := ioutil.ReadAll(NewDecoder(encoded))
-	if err != nil {
-		t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
-	}
-
-	if !bytes.Equal(raw, decoded) {
-		var i int
-		for i = 0; i < len(decoded) && i < len(raw); i++ {
-			if decoded[i] != raw[i] {
-				break
-			}
-		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
-	}
-}
diff --git a/src/pkg/encoding/hex/Makefile b/src/pkg/encoding/hex/Makefile
deleted file mode 100644
index 22049f43b..000000000
--- a/src/pkg/encoding/hex/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/hex
-GOFILES=\
-	hex.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/hex/hex.go b/src/pkg/encoding/hex/hex.go
deleted file mode 100644
index 47cdedd60..000000000
--- a/src/pkg/encoding/hex/hex.go
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package hex implements hexadecimal encoding and decoding.
-package hex
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"strconv"
-)
-
-const hextable = "0123456789abcdef"
-
-// EncodedLen returns the length of an encoding of n source bytes.
-func EncodedLen(n int) int { return n * 2 }
-
-// Encode encodes src into EncodedLen(len(src))
-// bytes of dst.  As a convenience, it returns the number
-// of bytes written to dst, but this value is always EncodedLen(len(src)).
-// Encode implements hexadecimal encoding.
-func Encode(dst, src []byte) int {
-	for i, v := range src {
-		dst[i*2] = hextable[v>>4]
-		dst[i*2+1] = hextable[v&0x0f]
-	}
-
-	return len(src) * 2
-}
-
-// OddLengthInputError results from decoding an odd length slice.
-type OddLengthInputError struct{}
-
-func (OddLengthInputError) String() string { return "odd length hex string" }
-
-// InvalidHexCharError results from finding an invalid character in a hex string.
-type InvalidHexCharError byte
-
-func (e InvalidHexCharError) String() string {
-	return "invalid hex char: " + strconv.Itoa(int(e))
-}
-
-
-func DecodedLen(x int) int { return x / 2 }
-
-// Decode decodes src into DecodedLen(len(src)) bytes, returning the actual
-// number of bytes written to dst.
-//
-// If Decode encounters invalid input, it returns an OddLengthInputError or an
-// InvalidHexCharError.
-func Decode(dst, src []byte) (int, os.Error) {
-	if len(src)%2 == 1 {
-		return 0, OddLengthInputError{}
-	}
-
-	for i := 0; i < len(src)/2; i++ {
-		a, ok := fromHexChar(src[i*2])
-		if !ok {
-			return 0, InvalidHexCharError(src[i*2])
-		}
-		b, ok := fromHexChar(src[i*2+1])
-		if !ok {
-			return 0, InvalidHexCharError(src[i*2+1])
-		}
-		dst[i] = (a << 4) | b
-	}
-
-	return len(src) / 2, nil
-}
-
-// fromHexChar converts a hex character into its value and a success flag.
-func fromHexChar(c byte) (byte, bool) {
-	switch {
-	case '0' <= c && c <= '9':
-		return c - '0', true
-	case 'a' <= c && c <= 'f':
-		return c - 'a' + 10, true
-	case 'A' <= c && c <= 'F':
-		return c - 'A' + 10, true
-	}
-
-	return 0, false
-}
-
-// EncodeToString returns the hexadecimal encoding of src.
-func EncodeToString(src []byte) string {
-	dst := make([]byte, EncodedLen(len(src)))
-	Encode(dst, src)
-	return string(dst)
-}
-
-// DecodeString returns the bytes represented by the hexadecimal string s.
-func DecodeString(s string) ([]byte, os.Error) {
-	src := []byte(s)
-	dst := make([]byte, DecodedLen(len(src)))
-	_, err := Decode(dst, src)
-	if err != nil {
-		return nil, err
-	}
-	return dst, nil
-}
-
-// Dump returns a string that contains a hex dump of the given data. The format
-// of the hex dump matches the output of `hexdump -C` on the command line.
-func Dump(data []byte) string {
-	buf := bytes.NewBuffer(nil)
-	dumper := Dumper(buf)
-	dumper.Write(data)
-	dumper.Close()
-	return string(buf.Bytes())
-}
-
-// Dumper returns a WriteCloser that writes a hex dump of all written data to
-// w. The format of the dump matches the output of `hexdump -C` on the command
-// line.
-func Dumper(w io.Writer) io.WriteCloser {
-	return &dumper{w: w}
-}
-
-type dumper struct {
-	w          io.Writer
-	rightChars [18]byte
-	buf        [14]byte
-	used       int  // number of bytes in the current line
-	n          uint // number of bytes, total
-}
-
-func toChar(b byte) byte {
-	if b < 32 || b > 126 {
-		return '.'
-	}
-	return b
-}
-
-func (h *dumper) Write(data []byte) (n int, err os.Error) {
-	// Output lines look like:
-	// 00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
-	// ^ offset                          ^ extra space              ^ ASCII of line.
-	for i := range data {
-		if h.used == 0 {
-			// At the beginning of a line we print the current
-			// offset in hex.
-			h.buf[0] = byte(h.n >> 24)
-			h.buf[1] = byte(h.n >> 16)
-			h.buf[2] = byte(h.n >> 8)
-			h.buf[3] = byte(h.n)
-			Encode(h.buf[4:], h.buf[:4])
-			h.buf[12] = ' '
-			h.buf[13] = ' '
-			_, err = h.w.Write(h.buf[4:])
-		}
-		Encode(h.buf[:], data[i:i+1])
-		h.buf[2] = ' '
-		l := 3
-		if h.used == 7 {
-			// There's an additional space after the 8th byte.
-			h.buf[3] = ' '
-			l = 4
-		} else if h.used == 15 {
-			// At the end of the line there's an extra space and
-			// the bar for the right column.
-			h.buf[3] = ' '
-			h.buf[4] = '|'
-			l = 5
-		}
-		_, err = h.w.Write(h.buf[:l])
-		if err != nil {
-			return
-		}
-		n++
-		h.rightChars[h.used] = toChar(data[i])
-		h.used++
-		h.n++
-		if h.used == 16 {
-			h.rightChars[16] = '|'
-			h.rightChars[17] = '\n'
-			_, err = h.w.Write(h.rightChars[:])
-			if err != nil {
-				return
-			}
-			h.used = 0
-		}
-	}
-	return
-}
-
-func (h *dumper) Close() (err os.Error) {
-	// See the comments in Write() for the details of this format.
-	if h.used == 0 {
-		return
-	}
-	h.buf[0] = ' '
-	h.buf[1] = ' '
-	h.buf[2] = ' '
-	h.buf[3] = ' '
-	h.buf[4] = '|'
-	nBytes := h.used
-	for h.used < 16 {
-		l := 3
-		if h.used == 7 {
-			l = 4
-		} else if h.used == 15 {
-			l = 5
-		}
-		_, err = h.w.Write(h.buf[:l])
-		if err != nil {
-			return
-		}
-		h.used++
-	}
-	h.rightChars[nBytes] = '|'
-	h.rightChars[nBytes+1] = '\n'
-	_, err = h.w.Write(h.rightChars[:nBytes+2])
-	return
-}
diff --git a/src/pkg/encoding/hex/hex_test.go b/src/pkg/encoding/hex/hex_test.go
deleted file mode 100644
index 8e1838e51..000000000
--- a/src/pkg/encoding/hex/hex_test.go
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package hex
-
-import (
-	"bytes"
-	"testing"
-)
-
-type encodeTest struct {
-	in, out []byte
-}
-
-var encodeTests = []encodeTest{
-	{[]byte{}, []byte{}},
-	{[]byte{0x01}, []byte{'0', '1'}},
-	{[]byte{0xff}, []byte{'f', 'f'}},
-	{[]byte{0xff, 00}, []byte{'f', 'f', '0', '0'}},
-	{[]byte{0}, []byte{'0', '0'}},
-	{[]byte{1}, []byte{'0', '1'}},
-	{[]byte{2}, []byte{'0', '2'}},
-	{[]byte{3}, []byte{'0', '3'}},
-	{[]byte{4}, []byte{'0', '4'}},
-	{[]byte{5}, []byte{'0', '5'}},
-	{[]byte{6}, []byte{'0', '6'}},
-	{[]byte{7}, []byte{'0', '7'}},
-	{[]byte{8}, []byte{'0', '8'}},
-	{[]byte{9}, []byte{'0', '9'}},
-	{[]byte{10}, []byte{'0', 'a'}},
-	{[]byte{11}, []byte{'0', 'b'}},
-	{[]byte{12}, []byte{'0', 'c'}},
-	{[]byte{13}, []byte{'0', 'd'}},
-	{[]byte{14}, []byte{'0', 'e'}},
-	{[]byte{15}, []byte{'0', 'f'}},
-}
-
-func TestEncode(t *testing.T) {
-	for i, test := range encodeTests {
-		dst := make([]byte, EncodedLen(len(test.in)))
-		n := Encode(dst, test.in)
-		if n != len(dst) {
-			t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst))
-		}
-		if bytes.Compare(dst, test.out) != 0 {
-			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.out)
-		}
-	}
-}
-
-type decodeTest struct {
-	in, out []byte
-	ok      bool
-}
-
-var decodeTests = []decodeTest{
-	{[]byte{}, []byte{}, true},
-	{[]byte{'0'}, []byte{}, false},
-	{[]byte{'0', 'g'}, []byte{}, false},
-	{[]byte{'0', '\x01'}, []byte{}, false},
-	{[]byte{'0', '0'}, []byte{0}, true},
-	{[]byte{'0', '1'}, []byte{1}, true},
-	{[]byte{'0', '2'}, []byte{2}, true},
-	{[]byte{'0', '3'}, []byte{3}, true},
-	{[]byte{'0', '4'}, []byte{4}, true},
-	{[]byte{'0', '5'}, []byte{5}, true},
-	{[]byte{'0', '6'}, []byte{6}, true},
-	{[]byte{'0', '7'}, []byte{7}, true},
-	{[]byte{'0', '8'}, []byte{8}, true},
-	{[]byte{'0', '9'}, []byte{9}, true},
-	{[]byte{'0', 'a'}, []byte{10}, true},
-	{[]byte{'0', 'b'}, []byte{11}, true},
-	{[]byte{'0', 'c'}, []byte{12}, true},
-	{[]byte{'0', 'd'}, []byte{13}, true},
-	{[]byte{'0', 'e'}, []byte{14}, true},
-	{[]byte{'0', 'f'}, []byte{15}, true},
-	{[]byte{'0', 'A'}, []byte{10}, true},
-	{[]byte{'0', 'B'}, []byte{11}, true},
-	{[]byte{'0', 'C'}, []byte{12}, true},
-	{[]byte{'0', 'D'}, []byte{13}, true},
-	{[]byte{'0', 'E'}, []byte{14}, true},
-	{[]byte{'0', 'F'}, []byte{15}, true},
-}
-
-func TestDecode(t *testing.T) {
-	for i, test := range decodeTests {
-		dst := make([]byte, DecodedLen(len(test.in)))
-		n, err := Decode(dst, test.in)
-		if err == nil && n != len(dst) {
-			t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst))
-		}
-		if test.ok != (err == nil) {
-			t.Errorf("#%d: unexpected err value: %s", i, err)
-		}
-		if err == nil && bytes.Compare(dst, test.out) != 0 {
-			t.Errorf("#%d: got: %#v want: %#v", i, dst, test.out)
-		}
-	}
-}
-
-type encodeStringTest struct {
-	in  []byte
-	out string
-}
-
-var encodeStringTests = []encodeStringTest{
-	{[]byte{}, ""},
-	{[]byte{0}, "00"},
-	{[]byte{0, 1}, "0001"},
-	{[]byte{0, 1, 255}, "0001ff"},
-}
-
-func TestEncodeToString(t *testing.T) {
-	for i, test := range encodeStringTests {
-		s := EncodeToString(test.in)
-		if s != test.out {
-			t.Errorf("#%d got:%s want:%s", i, s, test.out)
-		}
-	}
-}
-
-type decodeStringTest struct {
-	in  string
-	out []byte
-	ok  bool
-}
-
-var decodeStringTests = []decodeStringTest{
-	{"", []byte{}, true},
-	{"0", []byte{}, false},
-	{"00", []byte{0}, true},
-	{"0\x01", []byte{}, false},
-	{"0g", []byte{}, false},
-	{"00ff00", []byte{0, 255, 0}, true},
-	{"0000ff", []byte{0, 0, 255}, true},
-}
-
-func TestDecodeString(t *testing.T) {
-	for i, test := range decodeStringTests {
-		dst, err := DecodeString(test.in)
-		if test.ok != (err == nil) {
-			t.Errorf("#%d: unexpected err value: %s", i, err)
-		}
-		if err == nil && bytes.Compare(dst, test.out) != 0 {
-			t.Errorf("#%d: got: %#v want: #%v", i, dst, test.out)
-		}
-	}
-}
-
-func TestDumper(t *testing.T) {
-	var in [40]byte
-	for i := range in {
-		in[i] = byte(i + 30)
-	}
-
-	for stride := 1; stride < len(in); stride++ {
-		out := bytes.NewBuffer(nil)
-		dumper := Dumper(out)
-		done := 0
-		for done < len(in) {
-			todo := done + stride
-			if todo > len(in) {
-				todo = len(in)
-			}
-			dumper.Write(in[done:todo])
-			done = todo
-		}
-
-		dumper.Close()
-		if !bytes.Equal(out.Bytes(), expectedHexDump) {
-			t.Errorf("stride: %d failed. got:\n%s\nwant:\n%s", stride, out.Bytes(), expectedHexDump)
-		}
-	}
-}
-
-func TestDump(t *testing.T) {
-	var in [40]byte
-	for i := range in {
-		in[i] = byte(i + 30)
-	}
-
-	out := []byte(Dump(in[:]))
-	if !bytes.Equal(out, expectedHexDump) {
-		t.Errorf("got:\n%s\nwant:\n%s", out, expectedHexDump)
-	}
-}
-
-var expectedHexDump = []byte(`00000000  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
-00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
-00000020  3e 3f 40 41 42 43 44 45                           |>?@ABCDE|
-`)
diff --git a/src/pkg/encoding/pem/Makefile b/src/pkg/encoding/pem/Makefile
deleted file mode 100644
index 527670380..000000000
--- a/src/pkg/encoding/pem/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-include ../../../Make.inc
-
-TARG=encoding/pem
-GOFILES=\
-	pem.go\
-
-include ../../../Make.pkg
diff --git a/src/pkg/encoding/pem/pem.go b/src/pkg/encoding/pem/pem.go
deleted file mode 100644
index ebe57edc0..000000000
--- a/src/pkg/encoding/pem/pem.go
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package pem implements the PEM data encoding, which originated in Privacy
-// Enhanced Mail. The most common use of PEM encoding today is in TLS keys and
-// certificates. See RFC 1421.
-package pem
-
-import (
-	"bytes"
-	"encoding/base64"
-	"io"
-	"os"
-)
-
-// A Block represents a PEM encoded structure.
-//
-// The encoded form is:
-//    -----BEGIN Type-----
-//    Headers
-//    base64-encoded Bytes
-//    -----END Type-----
-// where Headers is a possibly empty sequence of Key: Value lines.
-type Block struct {
-	Type    string            // The type, taken from the preamble (i.e. "RSA PRIVATE KEY").
-	Headers map[string]string // Optional headers.
-	Bytes   []byte            // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.
-}
-
-// getLine results the first \r\n or \n delineated line from the given byte
-// array. The line does not include the \r\n or \n. The remainder of the byte
-// array (also not including the new line bytes) is also returned and this will
-// always be smaller than the original argument.
-func getLine(data []byte) (line, rest []byte) {
-	i := bytes.Index(data, []byte{'\n'})
-	var j int
-	if i < 0 {
-		i = len(data)
-		j = i
-	} else {
-		j = i + 1
-		if i > 0 && data[i-1] == '\r' {
-			i--
-		}
-	}
-	return data[0:i], data[j:]
-}
-
-// removeWhitespace returns a copy of its input with all spaces, tab and
-// newline characters removed.
-func removeWhitespace(data []byte) []byte {
-	result := make([]byte, len(data))
-	n := 0
-
-	for _, b := range data {
-		if b == ' ' || b == '\t' || b == '\r' || b == '\n' {
-			continue
-		}
-		result[n] = b
-		n++
-	}
-
-	return result[0:n]
-}
-
-var pemStart = []byte("\n-----BEGIN ")
-var pemEnd = []byte("\n-----END ")
-var pemEndOfLine = []byte("-----")
-
-// Decode will find the next PEM formatted block (certificate, private key
-// etc) in the input. It returns that block and the remainder of the input. If
-// no PEM data is found, p is nil and the whole of the input is returned in
-// rest.
-func Decode(data []byte) (p *Block, rest []byte) {
-	// pemStart begins with a newline. However, at the very beginning of
-	// the byte array, we'll accept the start string without it.
-	rest = data
-	if bytes.HasPrefix(data, pemStart[1:]) {
-		rest = rest[len(pemStart)-1 : len(data)]
-	} else if i := bytes.Index(data, pemStart); i >= 0 {
-		rest = rest[i+len(pemStart) : len(data)]
-	} else {
-		return nil, data
-	}
-
-	typeLine, rest := getLine(rest)
-	if !bytes.HasSuffix(typeLine, pemEndOfLine) {
-		return decodeError(data, rest)
-	}
-	typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]
-
-	p = &Block{
-		Headers: make(map[string]string),
-		Type:    string(typeLine),
-	}
-
-	for {
-		// This loop terminates because getLine's second result is
-		// always smaller than it's argument.
-		if len(rest) == 0 {
-			return nil, data
-		}
-		line, next := getLine(rest)
-
-		i := bytes.Index(line, []byte{':'})
-		if i == -1 {
-			break
-		}
-
-		// TODO(agl): need to cope with values that spread across lines.
-		key, val := line[0:i], line[i+1:]
-		key = bytes.TrimSpace(key)
-		val = bytes.TrimSpace(val)
-		p.Headers[string(key)] = string(val)
-		rest = next
-	}
-
-	i := bytes.Index(rest, pemEnd)
-	if i < 0 {
-		return decodeError(data, rest)
-	}
-	base64Data := removeWhitespace(rest[0:i])
-
-	p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data)))
-	n, err := base64.StdEncoding.Decode(p.Bytes, base64Data)
-	if err != nil {
-		return decodeError(data, rest)
-	}
-	p.Bytes = p.Bytes[0:n]
-
-	_, rest = getLine(rest[i+len(pemEnd):])
-
-	return
-}
-
-func decodeError(data, rest []byte) (*Block, []byte) {
-	// If we get here then we have rejected a likely looking, but
-	// ultimately invalid PEM block. We need to start over from a new
-	// position.  We have consumed the preamble line and will have consumed
-	// any lines which could be header lines. However, a valid preamble
-	// line is not a valid header line, therefore we cannot have consumed
-	// the preamble line for the any subsequent block. Thus, we will always
-	// find any valid block, no matter what bytes precede it.
-	//
-	// For example, if the input is
-	//
-	//    -----BEGIN MALFORMED BLOCK-----
-	//    junk that may look like header lines
-	//   or data lines, but no END line
-	//
-	//    -----BEGIN ACTUAL BLOCK-----
-	//    realdata
-	//    -----END ACTUAL BLOCK-----
-	//
-	// we've failed to parse using the first BEGIN line
-	// and now will try again, using the second BEGIN line.
-	p, rest := Decode(rest)
-	if p == nil {
-		rest = data
-	}
-	return p, rest
-}
-
-const pemLineLength = 64
-
-type lineBreaker struct {
-	line [pemLineLength]byte
-	used int
-	out  io.Writer
-}
-
-func (l *lineBreaker) Write(b []byte) (n int, err os.Error) {
-	if l.used+len(b) < pemLineLength {
-		copy(l.line[l.used:], b)
-		l.used += len(b)
-		return len(b), nil
-	}
-
-	n, err = l.out.Write(l.line[0:l.used])
-	if err != nil {
-		return
-	}
-	excess := pemLineLength - l.used
-	l.used = 0
-
-	n, err = l.out.Write(b[0:excess])
-	if err != nil {
-		return
-	}
-
-	n, err = l.out.Write([]byte{'\n'})
-	if err != nil {
-		return
-	}
-
-	return l.Write(b[excess:])
-}
-
-func (l *lineBreaker) Close() (err os.Error) {
-	if l.used > 0 {
-		_, err = l.out.Write(l.line[0:l.used])
-		if err != nil {
-			return
-		}
-		_, err = l.out.Write([]byte{'\n'})
-	}
-
-	return
-}
-
-func Encode(out io.Writer, b *Block) (err os.Error) {
-	_, err = out.Write(pemStart[1:])
-	if err != nil {
-		return
-	}
-	_, err = out.Write([]byte(b.Type + "-----\n"))
-	if err != nil {
-		return
-	}
-
-	if len(b.Headers) > 0 {
-		for k, v := range b.Headers {
-			_, err = out.Write([]byte(k + ": " + v + "\n"))
-			if err != nil {
-				return
-			}
-		}
-		_, err = out.Write([]byte{'\n'})
-		if err != nil {
-			return
-		}
-	}
-
-	var breaker lineBreaker
-	breaker.out = out
-
-	b64 := base64.NewEncoder(base64.StdEncoding, &breaker)
-	_, err = b64.Write(b.Bytes)
-	if err != nil {
-		return
-	}
-	b64.Close()
-	breaker.Close()
-
-	_, err = out.Write(pemEnd[1:])
-	if err != nil {
-		return
-	}
-	_, err = out.Write([]byte(b.Type + "-----\n"))
-	return
-}
-
-func EncodeToMemory(b *Block) []byte {
-	buf := bytes.NewBuffer(nil)
-	Encode(buf, b)
-	return buf.Bytes()
-}
diff --git a/src/pkg/encoding/pem/pem_test.go b/src/pkg/encoding/pem/pem_test.go
deleted file mode 100644
index 11efe5544..000000000
--- a/src/pkg/encoding/pem/pem_test.go
+++ /dev/null
@@ -1,390 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pem
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-)
-
-type GetLineTest struct {
-	in, out1, out2 string
-}
-
-var getLineTests = []GetLineTest{
-	{"abc", "abc", ""},
-	{"abc\r", "abc\r", ""},
-	{"abc\n", "abc", ""},
-	{"abc\r\n", "abc", ""},
-	{"abc\nd", "abc", "d"},
-	{"abc\r\nd", "abc", "d"},
-	{"\nabc", "", "abc"},
-	{"\r\nabc", "", "abc"},
-}
-
-func TestGetLine(t *testing.T) {
-	for i, test := range getLineTests {
-		x, y := getLine([]byte(test.in))
-		if string(x) != test.out1 || string(y) != test.out2 {
-			t.Errorf("#%d got:%+v,%+v want:%s,%s", i, x, y, test.out1, test.out2)
-		}
-	}
-}
-
-func TestDecode(t *testing.T) {
-	result, remainder := Decode([]byte(pemData))
-	if !reflect.DeepEqual(result, certificate) {
-		t.Errorf("#0 got:%#v want:%#v", result, certificate)
-	}
-	result, remainder = Decode(remainder)
-	if !reflect.DeepEqual(result, privateKey) {
-		t.Errorf("#1 got:%#v want:%#v", result, privateKey)
-	}
-	result, _ = Decode([]byte(pemPrivateKey))
-	if !reflect.DeepEqual(result, privateKey2) {
-		t.Errorf("#2 got:%#v want:%#v", result, privateKey2)
-	}
-}
-
-func TestEncode(t *testing.T) {
-	r := EncodeToMemory(privateKey2)
-	if string(r) != pemPrivateKey {
-		t.Errorf("got:%s want:%s", r, pemPrivateKey)
-	}
-}
-
-type lineBreakerTest struct {
-	in, out string
-}
-
-const sixtyFourCharString = "0123456789012345678901234567890123456789012345678901234567890123"
-
-var lineBreakerTests = []lineBreakerTest{
-	{"", ""},
-	{"a", "a\n"},
-	{"ab", "ab\n"},
-	{sixtyFourCharString, sixtyFourCharString + "\n"},
-	{sixtyFourCharString + "X", sixtyFourCharString + "\nX\n"},
-	{sixtyFourCharString + sixtyFourCharString, sixtyFourCharString + "\n" + sixtyFourCharString + "\n"},
-}
-
-func TestLineBreaker(t *testing.T) {
-	for i, test := range lineBreakerTests {
-		buf := bytes.NewBuffer(nil)
-		var breaker lineBreaker
-		breaker.out = buf
-		_, err := breaker.Write([]byte(test.in))
-		if err != nil {
-			t.Errorf("#%d: error from Write: %s", i, err)
-			continue
-		}
-		err = breaker.Close()
-		if err != nil {
-			t.Errorf("#%d: error from Close: %s", i, err)
-			continue
-		}
-
-		if string(buf.Bytes()) != test.out {
-			t.Errorf("#%d: got:%s want:%s", i, string(buf.Bytes()), test.out)
-		}
-	}
-
-	for i, test := range lineBreakerTests {
-		buf := bytes.NewBuffer(nil)
-		var breaker lineBreaker
-		breaker.out = buf
-
-		for i := 0; i < len(test.in); i++ {
-			_, err := breaker.Write([]byte(test.in[i : i+1]))
-			if err != nil {
-				t.Errorf("#%d: error from Write (byte by byte): %s", i, err)
-				continue
-			}
-		}
-		err := breaker.Close()
-		if err != nil {
-			t.Errorf("#%d: error from Close (byte by byte): %s", i, err)
-			continue
-		}
-
-		if string(buf.Bytes()) != test.out {
-			t.Errorf("#%d: (byte by byte) got:%s want:%s", i, string(buf.Bytes()), test.out)
-		}
-	}
-}
-
-var pemData = `verify return:0
------BEGIN CERTIFICATE-----
-sdlfkjskldfj
-  -----BEGIN CERTIFICATE-----
----
-Certificate chain
- 0 s:/C=AU/ST=Somewhere/L=Someplace/O=Foo Bar/CN=foo.example.com
-   i:/C=ZA/O=CA Inc./CN=CA Inc
------BEGIN CERTIFICATE-----
-testing
------BEGIN CERTIFICATE-----
------BEGIN CERTIFICATE-----
-MIID6TCCA1ICAQEwDQYJKoZIhvcNAQEFBQAwgYsxCzAJBgNVBAYTAlVTMRMwEQYD
-VQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQK
-EwtHb29nbGUgSW5jLjEMMAoGA1UECxMDRW5nMQwwCgYDVQQDEwNhZ2wxHTAbBgkq
-hkiG9w0BCQEWDmFnbEBnb29nbGUuY29tMB4XDTA5MDkwOTIyMDU0M1oXDTEwMDkw
-OTIyMDU0M1owajELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAf
-BgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEjMCEGA1UEAxMaZXVyb3Bh
-LnNmby5jb3JwLmdvb2dsZS5jb20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQC6pgYt7/EibBDumASF+S0qvqdL/f+nouJw2T1Qc8GmXF/iiUcrsgzh/Fd8
-pDhz/T96Qg9IyR4ztuc2MXrmPra+zAuSf5bevFReSqvpIt8Duv0HbDbcqs/XKPfB
-uMDe+of7a9GCywvAZ4ZUJcp0thqD9fKTTjUWOBzHY1uNE4RitrhmJCrbBGXbJ249
-bvgmb7jgdInH2PU7PT55hujvOoIsQW2osXBFRur4pF1wmVh4W4lTLD6pjfIMUcML
-ICHEXEN73PDic8KS3EtNYCwoIld+tpIBjE1QOb1KOyuJBNW6Esw9ALZn7stWdYcE
-qAwvv20egN2tEXqj7Q4/1ccyPZc3PQgC3FJ8Be2mtllM+80qf4dAaQ/fWvCtOrQ5
-pnfe9juQvCo8Y0VGlFcrSys/MzSg9LJ/24jZVgzQved/Qupsp89wVidwIzjt+WdS
-fyWfH0/v1aQLvu5cMYuW//C0W2nlYziL5blETntM8My2ybNARy3ICHxCBv2RNtPI
-WQVm+E9/W5rwh2IJR4DHn2LHwUVmT/hHNTdBLl5Uhwr4Wc7JhE7AVqb14pVNz1lr
-5jxsp//ncIwftb7mZQ3DF03Yna+jJhpzx8CQoeLT6aQCHyzmH68MrHHT4MALPyUs
-Pomjn71GNTtDeWAXibjCgdL6iHACCF6Htbl0zGlG0OAK+bdn0QIDAQABMA0GCSqG
-SIb3DQEBBQUAA4GBAOKnQDtqBV24vVqvesL5dnmyFpFPXBn3WdFfwD6DzEb21UVG
-5krmJiu+ViipORJPGMkgoL6BjU21XI95VQbun5P8vvg8Z+FnFsvRFY3e1CCzAVQY
-ZsUkLw2I7zI/dNlWdB8Xp7v+3w9sX5N3J/WuJ1KOO5m26kRlHQo7EzT3974g
------END CERTIFICATE-----
- 1 s:/C=ZA/O=Ca Inc./CN=CA Inc
-
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,80C7C7A09690757A
-
-eQp5ZkH6CyHBz7BZfUPxyLCCmftsBJ7HlqGb8Ld21cSwnzWZ4/SIlhyrUtsfw7VR
-2TTwA+odo9ex7GdxOTaH8oZFumIRoiEjHsk8U7Bhntp+ekkPP79xunnN7hb7hkhr
-yGDQZgA7s2cQHQ71v3gwT2BACAft26jCjbM1wgNzBnJ8M0Rzn68YWqaPtdBu8qb/
-zVR5JB1mnqvTSbFsfF5yMc6o2WQ9jJCl6KypnMl+BpL+dlvdjYVK4l9lYsB1Hs3d
-+zDBbWxos818zzhS8/y6eIfiSG27cqrbhURbmgiSfDXjncK4m/pLcQ7mmBL6mFOr
-3Pj4jepzgOiFRL6MKE//h62fZvI1ErYr8VunHEykgKNhChDvb1RO6LEfqKBu+Ivw
-TB6fBhW3TCLMnVPYVoYwA+fHNTmZZm8BEonlIMfI+KktjWUg4Oia+NI6vKcPpFox
-hSnlGgCtvfEaq5/H4kHJp95eOpnFsLviw2seHNkz/LxJMRP1X428+DpYW/QD/0JU
-tJSuC/q9FUHL6RI3u/Asrv8pCb4+D7i1jW/AMIdJTtycOGsbPxQA7yHMWujHmeb1
-BTiHcL3s3KrJu1vDVrshvxfnz71KTeNnZH8UbOqT5i7fPGyXtY1XJddcbI/Q6tXf
-wHFsZc20TzSdsVLBtwksUacpbDogcEVMctnNrB8FIrB3vZEv9Q0Z1VeY7nmTpF+6
-a+z2P7acL7j6A6Pr3+q8P9CPiPC7zFonVzuVPyB8GchGR2hytyiOVpuD9+k8hcuw
-ZWAaUoVtWIQ52aKS0p19G99hhb+IVANC4akkdHV4SP8i7MVNZhfUmg==
------END RSA PRIVATE KEY-----`
-
-var certificate = &Block{Type: "CERTIFICATE",
-	Headers: map[string]string{},
-	Bytes: []uint8{0x30, 0x82, 0x3, 0xe9, 0x30, 0x82, 0x3, 0x52, 0x2, 0x1,
-		0x1, 0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd,
-		0x1, 0x1, 0x5, 0x5, 0x0, 0x30, 0x81, 0x8b, 0x31, 0xb, 0x30,
-		0x9, 0x6, 0x3, 0x55, 0x4, 0x6, 0x13, 0x2, 0x55, 0x53, 0x31,
-		0x13, 0x30, 0x11, 0x6, 0x3, 0x55, 0x4, 0x8, 0x13, 0xa, 0x43,
-		0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31,
-		0x16, 0x30, 0x14, 0x6, 0x3, 0x55, 0x4, 0x7, 0x13, 0xd, 0x53,
-		0x61, 0x6e, 0x20, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73,
-		0x63, 0x6f, 0x31, 0x14, 0x30, 0x12, 0x6, 0x3, 0x55, 0x4, 0xa,
-		0x13, 0xb, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x49,
-		0x6e, 0x63, 0x2e, 0x31, 0xc, 0x30, 0xa, 0x6, 0x3, 0x55, 0x4,
-		0xb, 0x13, 0x3, 0x45, 0x6e, 0x67, 0x31, 0xc, 0x30, 0xa, 0x6,
-		0x3, 0x55, 0x4, 0x3, 0x13, 0x3, 0x61, 0x67, 0x6c, 0x31, 0x1d,
-		0x30, 0x1b, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1,
-		0x9, 0x1, 0x16, 0xe, 0x61, 0x67, 0x6c, 0x40, 0x67, 0x6f, 0x6f,
-		0x67, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17,
-		0xd, 0x30, 0x39, 0x30, 0x39, 0x30, 0x39, 0x32, 0x32, 0x30,
-		0x35, 0x34, 0x33, 0x5a, 0x17, 0xd, 0x31, 0x30, 0x30, 0x39,
-		0x30, 0x39, 0x32, 0x32, 0x30, 0x35, 0x34, 0x33, 0x5a, 0x30,
-		0x6a, 0x31, 0xb, 0x30, 0x9, 0x6, 0x3, 0x55, 0x4, 0x6, 0x13,
-		0x2, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x6, 0x3, 0x55, 0x4,
-		0x8, 0x13, 0xa, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61,
-		0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x6, 0x3, 0x55, 0x4, 0xa,
-		0x13, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
-		0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20, 0x50,
-		0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x31, 0x23, 0x30, 0x21,
-		0x6, 0x3, 0x55, 0x4, 0x3, 0x13, 0x1a, 0x65, 0x75, 0x72, 0x6f,
-		0x70, 0x61, 0x2e, 0x73, 0x66, 0x6f, 0x2e, 0x63, 0x6f, 0x72,
-		0x70, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x63,
-		0x6f, 0x6d, 0x30, 0x82, 0x2, 0x22, 0x30, 0xd, 0x6, 0x9, 0x2a,
-		0x86, 0x48, 0x86, 0xf7, 0xd, 0x1, 0x1, 0x1, 0x5, 0x0, 0x3,
-		0x82, 0x2, 0xf, 0x0, 0x30, 0x82, 0x2, 0xa, 0x2, 0x82, 0x2, 0x1,
-		0x0, 0xba, 0xa6, 0x6, 0x2d, 0xef, 0xf1, 0x22, 0x6c, 0x10, 0xee,
-		0x98, 0x4, 0x85, 0xf9, 0x2d, 0x2a, 0xbe, 0xa7, 0x4b, 0xfd,
-		0xff, 0xa7, 0xa2, 0xe2, 0x70, 0xd9, 0x3d, 0x50, 0x73, 0xc1,
-		0xa6, 0x5c, 0x5f, 0xe2, 0x89, 0x47, 0x2b, 0xb2, 0xc, 0xe1,
-		0xfc, 0x57, 0x7c, 0xa4, 0x38, 0x73, 0xfd, 0x3f, 0x7a, 0x42,
-		0xf, 0x48, 0xc9, 0x1e, 0x33, 0xb6, 0xe7, 0x36, 0x31, 0x7a,
-		0xe6, 0x3e, 0xb6, 0xbe, 0xcc, 0xb, 0x92, 0x7f, 0x96, 0xde,
-		0xbc, 0x54, 0x5e, 0x4a, 0xab, 0xe9, 0x22, 0xdf, 0x3, 0xba,
-		0xfd, 0x7, 0x6c, 0x36, 0xdc, 0xaa, 0xcf, 0xd7, 0x28, 0xf7,
-		0xc1, 0xb8, 0xc0, 0xde, 0xfa, 0x87, 0xfb, 0x6b, 0xd1, 0x82,
-		0xcb, 0xb, 0xc0, 0x67, 0x86, 0x54, 0x25, 0xca, 0x74, 0xb6,
-		0x1a, 0x83, 0xf5, 0xf2, 0x93, 0x4e, 0x35, 0x16, 0x38, 0x1c,
-		0xc7, 0x63, 0x5b, 0x8d, 0x13, 0x84, 0x62, 0xb6, 0xb8, 0x66,
-		0x24, 0x2a, 0xdb, 0x4, 0x65, 0xdb, 0x27, 0x6e, 0x3d, 0x6e,
-		0xf8, 0x26, 0x6f, 0xb8, 0xe0, 0x74, 0x89, 0xc7, 0xd8, 0xf5,
-		0x3b, 0x3d, 0x3e, 0x79, 0x86, 0xe8, 0xef, 0x3a, 0x82, 0x2c,
-		0x41, 0x6d, 0xa8, 0xb1, 0x70, 0x45, 0x46, 0xea, 0xf8, 0xa4,
-		0x5d, 0x70, 0x99, 0x58, 0x78, 0x5b, 0x89, 0x53, 0x2c, 0x3e,
-		0xa9, 0x8d, 0xf2, 0xc, 0x51, 0xc3, 0xb, 0x20, 0x21, 0xc4, 0x5c,
-		0x43, 0x7b, 0xdc, 0xf0, 0xe2, 0x73, 0xc2, 0x92, 0xdc, 0x4b,
-		0x4d, 0x60, 0x2c, 0x28, 0x22, 0x57, 0x7e, 0xb6, 0x92, 0x1,
-		0x8c, 0x4d, 0x50, 0x39, 0xbd, 0x4a, 0x3b, 0x2b, 0x89, 0x4,
-		0xd5, 0xba, 0x12, 0xcc, 0x3d, 0x0, 0xb6, 0x67, 0xee, 0xcb,
-		0x56, 0x75, 0x87, 0x4, 0xa8, 0xc, 0x2f, 0xbf, 0x6d, 0x1e, 0x80,
-		0xdd, 0xad, 0x11, 0x7a, 0xa3, 0xed, 0xe, 0x3f, 0xd5, 0xc7,
-		0x32, 0x3d, 0x97, 0x37, 0x3d, 0x8, 0x2, 0xdc, 0x52, 0x7c, 0x5,
-		0xed, 0xa6, 0xb6, 0x59, 0x4c, 0xfb, 0xcd, 0x2a, 0x7f, 0x87,
-		0x40, 0x69, 0xf, 0xdf, 0x5a, 0xf0, 0xad, 0x3a, 0xb4, 0x39,
-		0xa6, 0x77, 0xde, 0xf6, 0x3b, 0x90, 0xbc, 0x2a, 0x3c, 0x63,
-		0x45, 0x46, 0x94, 0x57, 0x2b, 0x4b, 0x2b, 0x3f, 0x33, 0x34,
-		0xa0, 0xf4, 0xb2, 0x7f, 0xdb, 0x88, 0xd9, 0x56, 0xc, 0xd0,
-		0xbd, 0xe7, 0x7f, 0x42, 0xea, 0x6c, 0xa7, 0xcf, 0x70, 0x56,
-		0x27, 0x70, 0x23, 0x38, 0xed, 0xf9, 0x67, 0x52, 0x7f, 0x25,
-		0x9f, 0x1f, 0x4f, 0xef, 0xd5, 0xa4, 0xb, 0xbe, 0xee, 0x5c,
-		0x31, 0x8b, 0x96, 0xff, 0xf0, 0xb4, 0x5b, 0x69, 0xe5, 0x63,
-		0x38, 0x8b, 0xe5, 0xb9, 0x44, 0x4e, 0x7b, 0x4c, 0xf0, 0xcc,
-		0xb6, 0xc9, 0xb3, 0x40, 0x47, 0x2d, 0xc8, 0x8, 0x7c, 0x42, 0x6,
-		0xfd, 0x91, 0x36, 0xd3, 0xc8, 0x59, 0x5, 0x66, 0xf8, 0x4f,
-		0x7f, 0x5b, 0x9a, 0xf0, 0x87, 0x62, 0x9, 0x47, 0x80, 0xc7,
-		0x9f, 0x62, 0xc7, 0xc1, 0x45, 0x66, 0x4f, 0xf8, 0x47, 0x35,
-		0x37, 0x41, 0x2e, 0x5e, 0x54, 0x87, 0xa, 0xf8, 0x59, 0xce,
-		0xc9, 0x84, 0x4e, 0xc0, 0x56, 0xa6, 0xf5, 0xe2, 0x95, 0x4d,
-		0xcf, 0x59, 0x6b, 0xe6, 0x3c, 0x6c, 0xa7, 0xff, 0xe7, 0x70,
-		0x8c, 0x1f, 0xb5, 0xbe, 0xe6, 0x65, 0xd, 0xc3, 0x17, 0x4d,
-		0xd8, 0x9d, 0xaf, 0xa3, 0x26, 0x1a, 0x73, 0xc7, 0xc0, 0x90,
-		0xa1, 0xe2, 0xd3, 0xe9, 0xa4, 0x2, 0x1f, 0x2c, 0xe6, 0x1f,
-		0xaf, 0xc, 0xac, 0x71, 0xd3, 0xe0, 0xc0, 0xb, 0x3f, 0x25, 0x2c,
-		0x3e, 0x89, 0xa3, 0x9f, 0xbd, 0x46, 0x35, 0x3b, 0x43, 0x79,
-		0x60, 0x17, 0x89, 0xb8, 0xc2, 0x81, 0xd2, 0xfa, 0x88, 0x70,
-		0x2, 0x8, 0x5e, 0x87, 0xb5, 0xb9, 0x74, 0xcc, 0x69, 0x46, 0xd0,
-		0xe0, 0xa, 0xf9, 0xb7, 0x67, 0xd1, 0x2, 0x3, 0x1, 0x0, 0x1,
-		0x30, 0xd, 0x6, 0x9, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0xd, 0x1,
-		0x1, 0x5, 0x5, 0x0, 0x3, 0x81, 0x81, 0x0, 0xe2, 0xa7, 0x40,
-		0x3b, 0x6a, 0x5, 0x5d, 0xb8, 0xbd, 0x5a, 0xaf, 0x7a, 0xc2,
-		0xf9, 0x76, 0x79, 0xb2, 0x16, 0x91, 0x4f, 0x5c, 0x19, 0xf7,
-		0x59, 0xd1, 0x5f, 0xc0, 0x3e, 0x83, 0xcc, 0x46, 0xf6, 0xd5,
-		0x45, 0x46, 0xe6, 0x4a, 0xe6, 0x26, 0x2b, 0xbe, 0x56, 0x28,
-		0xa9, 0x39, 0x12, 0x4f, 0x18, 0xc9, 0x20, 0xa0, 0xbe, 0x81,
-		0x8d, 0x4d, 0xb5, 0x5c, 0x8f, 0x79, 0x55, 0x6, 0xee, 0x9f,
-		0x93, 0xfc, 0xbe, 0xf8, 0x3c, 0x67, 0xe1, 0x67, 0x16, 0xcb,
-		0xd1, 0x15, 0x8d, 0xde, 0xd4, 0x20, 0xb3, 0x1, 0x54, 0x18,
-		0x66, 0xc5, 0x24, 0x2f, 0xd, 0x88, 0xef, 0x32, 0x3f, 0x74,
-		0xd9, 0x56, 0x74, 0x1f, 0x17, 0xa7, 0xbb, 0xfe, 0xdf, 0xf,
-		0x6c, 0x5f, 0x93, 0x77, 0x27, 0xf5, 0xae, 0x27, 0x52, 0x8e,
-		0x3b, 0x99, 0xb6, 0xea, 0x44, 0x65, 0x1d, 0xa, 0x3b, 0x13,
-		0x34, 0xf7, 0xf7, 0xbe, 0x20,
-	},
-}
-
-var privateKey = &Block{Type: "RSA PRIVATE KEY",
-	Headers: map[string]string{"DEK-Info": "DES-EDE3-CBC,80C7C7A09690757A", "Proc-Type": "4,ENCRYPTED"},
-	Bytes: []uint8{0x79, 0xa, 0x79, 0x66, 0x41, 0xfa, 0xb,
-		0x21, 0xc1, 0xcf, 0xb0, 0x59, 0x7d, 0x43, 0xf1, 0xc8, 0xb0,
-		0x82, 0x99, 0xfb, 0x6c, 0x4, 0x9e, 0xc7, 0x96, 0xa1, 0x9b,
-		0xf0, 0xb7, 0x76, 0xd5, 0xc4, 0xb0, 0x9f, 0x35, 0x99, 0xe3,
-		0xf4, 0x88, 0x96, 0x1c, 0xab, 0x52, 0xdb, 0x1f, 0xc3, 0xb5,
-		0x51, 0xd9, 0x34, 0xf0, 0x3, 0xea, 0x1d, 0xa3, 0xd7, 0xb1,
-		0xec, 0x67, 0x71, 0x39, 0x36, 0x87, 0xf2, 0x86, 0x45, 0xba,
-		0x62, 0x11, 0xa2, 0x21, 0x23, 0x1e, 0xc9, 0x3c, 0x53, 0xb0,
-		0x61, 0x9e, 0xda, 0x7e, 0x7a, 0x49, 0xf, 0x3f, 0xbf, 0x71,
-		0xba, 0x79, 0xcd, 0xee, 0x16, 0xfb, 0x86, 0x48, 0x6b, 0xc8,
-		0x60, 0xd0, 0x66, 0x0, 0x3b, 0xb3, 0x67, 0x10, 0x1d, 0xe,
-		0xf5, 0xbf, 0x78, 0x30, 0x4f, 0x60, 0x40, 0x8, 0x7, 0xed,
-		0xdb, 0xa8, 0xc2, 0x8d, 0xb3, 0x35, 0xc2, 0x3, 0x73, 0x6,
-		0x72, 0x7c, 0x33, 0x44, 0x73, 0x9f, 0xaf, 0x18, 0x5a, 0xa6,
-		0x8f, 0xb5, 0xd0, 0x6e, 0xf2, 0xa6, 0xff, 0xcd, 0x54, 0x79,
-		0x24, 0x1d, 0x66, 0x9e, 0xab, 0xd3, 0x49, 0xb1, 0x6c, 0x7c,
-		0x5e, 0x72, 0x31, 0xce, 0xa8, 0xd9, 0x64, 0x3d, 0x8c, 0x90,
-		0xa5, 0xe8, 0xac, 0xa9, 0x9c, 0xc9, 0x7e, 0x6, 0x92, 0xfe,
-		0x76, 0x5b, 0xdd, 0x8d, 0x85, 0x4a, 0xe2, 0x5f, 0x65, 0x62,
-		0xc0, 0x75, 0x1e, 0xcd, 0xdd, 0xfb, 0x30, 0xc1, 0x6d, 0x6c,
-		0x68, 0xb3, 0xcd, 0x7c, 0xcf, 0x38, 0x52, 0xf3, 0xfc, 0xba,
-		0x78, 0x87, 0xe2, 0x48, 0x6d, 0xbb, 0x72, 0xaa, 0xdb, 0x85,
-		0x44, 0x5b, 0x9a, 0x8, 0x92, 0x7c, 0x35, 0xe3, 0x9d, 0xc2,
-		0xb8, 0x9b, 0xfa, 0x4b, 0x71, 0xe, 0xe6, 0x98, 0x12, 0xfa,
-		0x98, 0x53, 0xab, 0xdc, 0xf8, 0xf8, 0x8d, 0xea, 0x73, 0x80,
-		0xe8, 0x85, 0x44, 0xbe, 0x8c, 0x28, 0x4f, 0xff, 0x87, 0xad,
-		0x9f, 0x66, 0xf2, 0x35, 0x12, 0xb6, 0x2b, 0xf1, 0x5b, 0xa7,
-		0x1c, 0x4c, 0xa4, 0x80, 0xa3, 0x61, 0xa, 0x10, 0xef, 0x6f,
-		0x54, 0x4e, 0xe8, 0xb1, 0x1f, 0xa8, 0xa0, 0x6e, 0xf8, 0x8b,
-		0xf0, 0x4c, 0x1e, 0x9f, 0x6, 0x15, 0xb7, 0x4c, 0x22, 0xcc,
-		0x9d, 0x53, 0xd8, 0x56, 0x86, 0x30, 0x3, 0xe7, 0xc7, 0x35,
-		0x39, 0x99, 0x66, 0x6f, 0x1, 0x12, 0x89, 0xe5, 0x20, 0xc7,
-		0xc8, 0xf8, 0xa9, 0x2d, 0x8d, 0x65, 0x20, 0xe0, 0xe8, 0x9a,
-		0xf8, 0xd2, 0x3a, 0xbc, 0xa7, 0xf, 0xa4, 0x5a, 0x31, 0x85,
-		0x29, 0xe5, 0x1a, 0x0, 0xad, 0xbd, 0xf1, 0x1a, 0xab, 0x9f,
-		0xc7, 0xe2, 0x41, 0xc9, 0xa7, 0xde, 0x5e, 0x3a, 0x99, 0xc5,
-		0xb0, 0xbb, 0xe2, 0xc3, 0x6b, 0x1e, 0x1c, 0xd9, 0x33, 0xfc,
-		0xbc, 0x49, 0x31, 0x13, 0xf5, 0x5f, 0x8d, 0xbc, 0xf8, 0x3a,
-		0x58, 0x5b, 0xf4, 0x3, 0xff, 0x42, 0x54, 0xb4, 0x94, 0xae,
-		0xb, 0xfa, 0xbd, 0x15, 0x41, 0xcb, 0xe9, 0x12, 0x37, 0xbb,
-		0xf0, 0x2c, 0xae, 0xff, 0x29, 0x9, 0xbe, 0x3e, 0xf, 0xb8,
-		0xb5, 0x8d, 0x6f, 0xc0, 0x30, 0x87, 0x49, 0x4e, 0xdc, 0x9c,
-		0x38, 0x6b, 0x1b, 0x3f, 0x14, 0x0, 0xef, 0x21, 0xcc, 0x5a,
-		0xe8, 0xc7, 0x99, 0xe6, 0xf5, 0x5, 0x38, 0x87, 0x70, 0xbd,
-		0xec, 0xdc, 0xaa, 0xc9, 0xbb, 0x5b, 0xc3, 0x56, 0xbb, 0x21,
-		0xbf, 0x17, 0xe7, 0xcf, 0xbd, 0x4a, 0x4d, 0xe3, 0x67, 0x64,
-		0x7f, 0x14, 0x6c, 0xea, 0x93, 0xe6, 0x2e, 0xdf, 0x3c, 0x6c,
-		0x97, 0xb5, 0x8d, 0x57, 0x25, 0xd7, 0x5c, 0x6c, 0x8f, 0xd0,
-		0xea, 0xd5, 0xdf, 0xc0, 0x71, 0x6c, 0x65, 0xcd, 0xb4, 0x4f,
-		0x34, 0x9d, 0xb1, 0x52, 0xc1, 0xb7, 0x9, 0x2c, 0x51, 0xa7,
-		0x29, 0x6c, 0x3a, 0x20, 0x70, 0x45, 0x4c, 0x72, 0xd9, 0xcd,
-		0xac, 0x1f, 0x5, 0x22, 0xb0, 0x77, 0xbd, 0x91, 0x2f, 0xf5,
-		0xd, 0x19, 0xd5, 0x57, 0x98, 0xee, 0x79, 0x93, 0xa4, 0x5f,
-		0xba, 0x6b, 0xec, 0xf6, 0x3f, 0xb6, 0x9c, 0x2f, 0xb8, 0xfa,
-		0x3, 0xa3, 0xeb, 0xdf, 0xea, 0xbc, 0x3f, 0xd0, 0x8f, 0x88,
-		0xf0, 0xbb, 0xcc, 0x5a, 0x27, 0x57, 0x3b, 0x95, 0x3f, 0x20,
-		0x7c, 0x19, 0xc8, 0x46, 0x47, 0x68, 0x72, 0xb7, 0x28, 0x8e,
-		0x56, 0x9b, 0x83, 0xf7, 0xe9, 0x3c, 0x85, 0xcb, 0xb0, 0x65,
-		0x60, 0x1a, 0x52, 0x85, 0x6d, 0x58, 0x84, 0x39, 0xd9, 0xa2,
-		0x92, 0xd2, 0x9d, 0x7d, 0x1b, 0xdf, 0x61, 0x85, 0xbf, 0x88,
-		0x54, 0x3, 0x42, 0xe1, 0xa9, 0x24, 0x74, 0x75, 0x78, 0x48,
-		0xff, 0x22, 0xec, 0xc5, 0x4d, 0x66, 0x17, 0xd4, 0x9a,
-	},
-}
-
-var privateKey2 = &Block{Type: "RSA PRIVATE KEY",
-	Headers: map[string]string{},
-	Bytes: []uint8{0x30, 0x82, 0x1, 0x3a, 0x2, 0x1, 0x0, 0x2,
-		0x41, 0x0, 0xb2, 0x99, 0xf, 0x49, 0xc4, 0x7d, 0xfa, 0x8c,
-		0xd4, 0x0, 0xae, 0x6a, 0x4d, 0x1b, 0x8a, 0x3b, 0x6a, 0x13,
-		0x64, 0x2b, 0x23, 0xf2, 0x8b, 0x0, 0x3b, 0xfb, 0x97, 0x79,
-		0xa, 0xde, 0x9a, 0x4c, 0xc8, 0x2b, 0x8b, 0x2a, 0x81, 0x74,
-		0x7d, 0xde, 0xc0, 0x8b, 0x62, 0x96, 0xe5, 0x3a, 0x8, 0xc3,
-		0x31, 0x68, 0x7e, 0xf2, 0x5c, 0x4b, 0xf4, 0x93, 0x6b, 0xa1,
-		0xc0, 0xe6, 0x4, 0x1e, 0x9d, 0x15, 0x2, 0x3, 0x1, 0x0, 0x1,
-		0x2, 0x41, 0x0, 0x8a, 0xbd, 0x6a, 0x69, 0xf4, 0xd1, 0xa4,
-		0xb4, 0x87, 0xf0, 0xab, 0x8d, 0x7a, 0xae, 0xfd, 0x38, 0x60,
-		0x94, 0x5, 0xc9, 0x99, 0x98, 0x4e, 0x30, 0xf5, 0x67, 0xe1,
-		0xe8, 0xae, 0xef, 0xf4, 0x4e, 0x8b, 0x18, 0xbd, 0xb1, 0xec,
-		0x78, 0xdf, 0xa3, 0x1a, 0x55, 0xe3, 0x2a, 0x48, 0xd7, 0xfb,
-		0x13, 0x1f, 0x5a, 0xf1, 0xf4, 0x4d, 0x7d, 0x6b, 0x2c, 0xed,
-		0x2a, 0x9d, 0xf5, 0xe5, 0xae, 0x45, 0x35, 0x2, 0x21, 0x0,
-		0xda, 0xb2, 0xf1, 0x80, 0x48, 0xba, 0xa6, 0x8d, 0xe7, 0xdf,
-		0x4, 0xd2, 0xd3, 0x5d, 0x5d, 0x80, 0xe6, 0xe, 0x2d, 0xfa,
-		0x42, 0xd5, 0xa, 0x9b, 0x4, 0x21, 0x90, 0x32, 0x71, 0x5e,
-		0x46, 0xb3, 0x2, 0x21, 0x0, 0xd1, 0xf, 0x2e, 0x66, 0xb1,
-		0xd0, 0xc1, 0x3f, 0x10, 0xef, 0x99, 0x27, 0xbf, 0x53, 0x24,
-		0xa3, 0x79, 0xca, 0x21, 0x81, 0x46, 0xcb, 0xf9, 0xca, 0xfc,
-		0x79, 0x52, 0x21, 0xf1, 0x6a, 0x31, 0x17, 0x2, 0x20, 0x21,
-		0x2, 0x89, 0x79, 0x37, 0x81, 0x14, 0xca, 0xae, 0x88, 0xf7,
-		0xd, 0x6b, 0x61, 0xd8, 0x4f, 0x30, 0x6a, 0x4b, 0x7e, 0x4e,
-		0xc0, 0x21, 0x4d, 0xac, 0x9d, 0xf4, 0x49, 0xe8, 0xda, 0xb6,
-		0x9, 0x2, 0x20, 0x16, 0xb3, 0xec, 0x59, 0x10, 0xa4, 0x57,
-		0xe8, 0xe, 0x61, 0xc6, 0xa3, 0xf, 0x5e, 0xeb, 0x12, 0xa9,
-		0xae, 0x2e, 0xb7, 0x48, 0x45, 0xec, 0x69, 0x83, 0xc3, 0x75,
-		0xc, 0xe4, 0x97, 0xa0, 0x9f, 0x2, 0x20, 0x69, 0x52, 0xb4,
-		0x6, 0xe8, 0x50, 0x60, 0x71, 0x4c, 0x3a, 0xb7, 0x66, 0xba,
-		0xd, 0x8a, 0xc9, 0xb7, 0xd, 0xa3, 0x8, 0x6c, 0xa3, 0xf2,
-		0x62, 0xb0, 0x2a, 0x84, 0xaa, 0x2f, 0xd6, 0x1e, 0x55,
-	},
-}
-
-var pemPrivateKey = `-----BEGIN RSA PRIVATE KEY-----
-MIIBOgIBAAJBALKZD0nEffqM1ACuak0bijtqE2QrI/KLADv7l3kK3ppMyCuLKoF0
-fd7Ai2KW5ToIwzFofvJcS/STa6HA5gQenRUCAwEAAQJBAIq9amn00aS0h/CrjXqu
-/ThglAXJmZhOMPVn4eiu7/ROixi9sex436MaVeMqSNf7Ex9a8fRNfWss7Sqd9eWu
-RTUCIQDasvGASLqmjeffBNLTXV2A5g4t+kLVCpsEIZAycV5GswIhANEPLmax0ME/
-EO+ZJ79TJKN5yiGBRsv5yvx5UiHxajEXAiAhAol5N4EUyq6I9w1rYdhPMGpLfk7A
-IU2snfRJ6Nq2CQIgFrPsWRCkV+gOYcajD17rEqmuLrdIRexpg8N1DOSXoJ8CIGlS
-tAboUGBxTDq3ZroNism3DaMIbKPyYrAqhKov1h5V
------END RSA PRIVATE KEY-----
-`