1) Change default gofmt default settings for

                  parsing and printing to new syntax.

                  Use -oldparser to parse the old syntax,
                  use -oldprinter to print the old syntax.

               2) Change default gofmt formatting settings
                  to use tabs for indentation only and to use
                  spaces for alignment. This will make the code
                  alignment insensitive to an editor's tabwidth.

                  Use -spaces=false to use tabs for alignment.

               3) Manually changed src/exp/parser/parser_test.go
                  so that it doesn't try to parse the parser's
                  source files using the old syntax (they have
                  new syntax now).

               4) gofmt -w src misc test/bench

	       1st set of files.

R=rsc
CC=agl, golang-dev, iant, ken2, r
http://codereview.appspot.com/180047

117 files changed, 6960 insertions, 6960 deletions

diff --git a/src/pkg/archive/tar/common.go b/src/pkg/archive/tar/common.go
index 792a3050b..4d399e5fe 100644
--- a/src/pkg/archive/tar/common.go
+++ b/src/pkg/archive/tar/common.go
@@ -12,39 +12,39 @@
 package tar
 
 const (
-	blockSize	= 512;
+	blockSize = 512
 
 	// Types
-	TypeReg			= '0';
-	TypeRegA		= '\x00';
-	TypeLink		= '1';
-	TypeSymlink		= '2';
-	TypeChar		= '3';
-	TypeBlock		= '4';
-	TypeDir			= '5';
-	TypeFifo		= '6';
-	TypeCont		= '7';
-	TypeXHeader		= 'x';
-	TypeXGlobalHeader	= 'g';
+	TypeReg           = '0'
+	TypeRegA          = '\x00'
+	TypeLink          = '1'
+	TypeSymlink       = '2'
+	TypeChar          = '3'
+	TypeBlock         = '4'
+	TypeDir           = '5'
+	TypeFifo          = '6'
+	TypeCont          = '7'
+	TypeXHeader       = 'x'
+	TypeXGlobalHeader = 'g'
 )
 
 // A Header represents a single header in a tar archive.
 // Some fields may not be populated.
 type Header struct {
-	Name		string;
-	Mode		int64;
-	Uid		int64;
-	Gid		int64;
-	Size		int64;
-	Mtime		int64;
-	Typeflag	byte;
-	Linkname	string;
-	Uname		string;
-	Gname		string;
-	Devmajor	int64;
-	Devminor	int64;
-	Atime		int64;
-	Ctime		int64;
+	Name     string
+	Mode     int64
+	Uid      int64
+	Gid      int64
+	Size     int64
+	Mtime    int64
+	Typeflag byte
+	Linkname string
+	Uname    string
+	Gname    string
+	Devmajor int64
+	Devminor int64
+	Atime    int64
+	Ctime    int64
 }
 
 var zeroBlock = make([]byte, blockSize)
@@ -55,21 +55,21 @@ func checksum(header []byte) (unsigned int64, signed int64) {
 	for i := 0; i < len(header); i++ {
 		if i == 148 {
 			// The chksum field (header[148:156]) is special: it should be treated as space bytes.
-			unsigned += ' ' * 8;
-			signed += ' ' * 8;
-			i += 7;
-			continue;
+			unsigned += ' ' * 8
+			signed += ' ' * 8
+			i += 7
+			continue
 		}
-		unsigned += int64(header[i]);
-		signed += int64(int8(header[i]));
+		unsigned += int64(header[i])
+		signed += int64(int8(header[i]))
 	}
-	return;
+	return
 }
 
 type slicer []byte
 
 func (sp *slicer) next(n int) (b []byte) {
-	s := *sp;
-	b, *sp = s[0:n], s[n:];
-	return;
+	s := *sp
+	b, *sp = s[0:n], s[n:]
+	return
 }
diff --git a/src/pkg/archive/tar/reader.go b/src/pkg/archive/tar/reader.go
index 50cda624b..9d598361a 100644
--- a/src/pkg/archive/tar/reader.go
+++ b/src/pkg/archive/tar/reader.go
@@ -8,14 +8,14 @@ package tar
 //   - pax extensions
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"strconv";
+	"bytes"
+	"io"
+	"os"
+	"strconv"
 )
 
 var (
-	HeaderError os.Error = os.ErrorString("invalid tar header");
+	HeaderError os.Error = os.ErrorString("invalid tar header")
 )
 
 // A Reader provides sequential access to the contents of a tar archive.
@@ -37,35 +37,35 @@ var (
 //		io.Copy(data, tr);
 //	}
 type Reader struct {
-	r	io.Reader;
-	err	os.Error;
-	nb	int64;	// number of unread bytes for current file entry
-	pad	int64;	// amount of padding (ignored) after current file entry
+	r   io.Reader
+	err os.Error
+	nb  int64 // number of unread bytes for current file entry
+	pad int64 // amount of padding (ignored) after current file entry
 }
 
 // NewReader creates a new Reader reading from r.
-func NewReader(r io.Reader) *Reader	{ return &Reader{r: r} }
+func NewReader(r io.Reader) *Reader { return &Reader{r: r} }
 
 // Next advances to the next entry in the tar archive.
 func (tr *Reader) Next() (*Header, os.Error) {
-	var hdr *Header;
+	var hdr *Header
 	if tr.err == nil {
 		tr.skipUnread()
 	}
 	if tr.err == nil {
 		hdr = tr.readHeader()
 	}
-	return hdr, tr.err;
+	return hdr, tr.err
 }
 
 // Parse bytes as a NUL-terminated C-style string.
 // If a NUL byte is not found then the whole slice is returned as a string.
 func cString(b []byte) string {
-	n := 0;
+	n := 0
 	for n < len(b) && b[n] != 0 {
 		n++
 	}
-	return string(b[0:n]);
+	return string(b[0:n])
 }
 
 func (tr *Reader) octal(b []byte) int64 {
@@ -77,11 +77,11 @@ func (tr *Reader) octal(b []byte) int64 {
 	for len(b) > 0 && (b[len(b)-1] == ' ' || b[len(b)-1] == '\x00') {
 		b = b[0 : len(b)-1]
 	}
-	x, err := strconv.Btoui64(cString(b), 8);
+	x, err := strconv.Btoui64(cString(b), 8)
 	if err != nil {
 		tr.err = err
 	}
-	return int64(x);
+	return int64(x)
 }
 
 type ignoreWriter struct{}
@@ -92,14 +92,14 @@ func (ignoreWriter) Write(b []byte) (n int, err os.Error) {
 
 // Skip any unread bytes in the existing file entry, as well as any alignment padding.
 func (tr *Reader) skipUnread() {
-	nr := tr.nb + tr.pad;	// number of bytes to skip
-	tr.nb, tr.pad = 0, 0;
+	nr := tr.nb + tr.pad // number of bytes to skip
+	tr.nb, tr.pad = 0, 0
 	if sr, ok := tr.r.(io.Seeker); ok {
 		if _, err := sr.Seek(nr, 1); err == nil {
 			return
 		}
 	}
-	_, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr);
+	_, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr)
 }
 
 func (tr *Reader) verifyChecksum(header []byte) bool {
@@ -107,13 +107,13 @@ func (tr *Reader) verifyChecksum(header []byte) bool {
 		return false
 	}
 
-	given := tr.octal(header[148:156]);
-	unsigned, signed := checksum(header);
-	return given == unsigned || given == signed;
+	given := tr.octal(header[148:156])
+	unsigned, signed := checksum(header)
+	return given == unsigned || given == signed
 }
 
 func (tr *Reader) readHeader() *Header {
-	header := make([]byte, blockSize);
+	header := make([]byte, blockSize)
 	if _, tr.err = io.ReadFull(tr.r, header); tr.err != nil {
 		return nil
 	}
@@ -126,64 +126,64 @@ func (tr *Reader) readHeader() *Header {
 		if bytes.Equal(header, zeroBlock[0:blockSize]) {
 			tr.err = os.EOF
 		} else {
-			tr.err = HeaderError	// zero block and then non-zero block
+			tr.err = HeaderError // zero block and then non-zero block
 		}
-		return nil;
+		return nil
 	}
 
 	if !tr.verifyChecksum(header) {
-		tr.err = HeaderError;
-		return nil;
+		tr.err = HeaderError
+		return nil
 	}
 
 	// Unpack
-	hdr := new(Header);
-	s := slicer(header);
-
-	hdr.Name = cString(s.next(100));
-	hdr.Mode = tr.octal(s.next(8));
-	hdr.Uid = tr.octal(s.next(8));
-	hdr.Gid = tr.octal(s.next(8));
-	hdr.Size = tr.octal(s.next(12));
-	hdr.Mtime = tr.octal(s.next(12));
-	s.next(8);	// chksum
-	hdr.Typeflag = s.next(1)[0];
-	hdr.Linkname = cString(s.next(100));
+	hdr := new(Header)
+	s := slicer(header)
+
+	hdr.Name = cString(s.next(100))
+	hdr.Mode = tr.octal(s.next(8))
+	hdr.Uid = tr.octal(s.next(8))
+	hdr.Gid = tr.octal(s.next(8))
+	hdr.Size = tr.octal(s.next(12))
+	hdr.Mtime = tr.octal(s.next(12))
+	s.next(8) // chksum
+	hdr.Typeflag = s.next(1)[0]
+	hdr.Linkname = cString(s.next(100))
 
 	// The remainder of the header depends on the value of magic.
 	// The original (v7) version of tar had no explicit magic field,
 	// so its magic bytes, like the rest of the block, are NULs.
-	magic := string(s.next(8));	// contains version field as well.
-	var format string;
+	magic := string(s.next(8)) // contains version field as well.
+	var format string
 	switch magic {
-	case "ustar\x0000":	// POSIX tar (1003.1-1988)
+	case "ustar\x0000": // POSIX tar (1003.1-1988)
 		if string(header[508:512]) == "tar\x00" {
 			format = "star"
 		} else {
 			format = "posix"
 		}
-	case "ustar  \x00":	// old GNU tar
+	case "ustar  \x00": // old GNU tar
 		format = "gnu"
 	}
 
 	switch format {
 	case "posix", "gnu", "star":
-		hdr.Uname = cString(s.next(32));
-		hdr.Gname = cString(s.next(32));
-		devmajor := s.next(8);
-		devminor := s.next(8);
+		hdr.Uname = cString(s.next(32))
+		hdr.Gname = cString(s.next(32))
+		devmajor := s.next(8)
+		devminor := s.next(8)
 		if hdr.Typeflag == TypeChar || hdr.Typeflag == TypeBlock {
-			hdr.Devmajor = tr.octal(devmajor);
-			hdr.Devminor = tr.octal(devminor);
+			hdr.Devmajor = tr.octal(devmajor)
+			hdr.Devminor = tr.octal(devminor)
 		}
-		var prefix string;
+		var prefix string
 		switch format {
 		case "posix", "gnu":
 			prefix = cString(s.next(155))
 		case "star":
-			prefix = cString(s.next(131));
-			hdr.Atime = tr.octal(s.next(12));
-			hdr.Ctime = tr.octal(s.next(12));
+			prefix = cString(s.next(131))
+			hdr.Atime = tr.octal(s.next(12))
+			hdr.Ctime = tr.octal(s.next(12))
 		}
 		if len(prefix) > 0 {
 			hdr.Name = prefix + "/" + hdr.Name
@@ -191,16 +191,16 @@ func (tr *Reader) readHeader() *Header {
 	}
 
 	if tr.err != nil {
-		tr.err = HeaderError;
-		return nil;
+		tr.err = HeaderError
+		return nil
 	}
 
 	// Maximum value of hdr.Size is 64 GB (12 octal digits),
 	// so there's no risk of int64 overflowing.
-	tr.nb = int64(hdr.Size);
-	tr.pad = -tr.nb & (blockSize - 1);	// blockSize is a power of two
+	tr.nb = int64(hdr.Size)
+	tr.pad = -tr.nb & (blockSize - 1) // blockSize is a power of two
 
-	return hdr;
+	return hdr
 }
 
 // Read reads from the current entry in the tar archive.
@@ -215,12 +215,12 @@ func (tr *Reader) Read(b []byte) (n int, err os.Error) {
 	if int64(len(b)) > tr.nb {
 		b = b[0:tr.nb]
 	}
-	n, err = tr.r.Read(b);
-	tr.nb -= int64(n);
+	n, err = tr.r.Read(b)
+	tr.nb -= int64(n)
 
 	if err == os.EOF && tr.nb > 0 {
 		err = io.ErrUnexpectedEOF
 	}
-	tr.err = err;
-	return;
+	tr.err = err
+	return
 }
diff --git a/src/pkg/archive/tar/reader_test.go b/src/pkg/archive/tar/reader_test.go
index f5a77dd38..719e3d87e 100644
--- a/src/pkg/archive/tar/reader_test.go
+++ b/src/pkg/archive/tar/reader_test.go
@@ -5,20 +5,20 @@
 package tar
 
 import (
-	"bytes";
-	"crypto/md5";
-	"fmt";
-	"io";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type untarTest struct {
-	file	string;
-	headers	[]*Header;
-	cksums	[]string;
+	file    string
+	headers []*Header
+	cksums  []string
 }
 
 var gnuTarTest = &untarTest{
@@ -114,50 +114,50 @@ var untarTests = []*untarTest{
 func TestReader(t *testing.T) {
 testLoop:
 	for i, test := range untarTests {
-		f, err := os.Open(test.file, os.O_RDONLY, 0444);
+		f, err := os.Open(test.file, os.O_RDONLY, 0444)
 		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err);
-			continue;
+			t.Errorf("test %d: Unexpected error: %v", i, err)
+			continue
 		}
-		tr := NewReader(f);
+		tr := NewReader(f)
 		for j, header := range test.headers {
-			hdr, err := tr.Next();
+			hdr, err := tr.Next()
 			if err != nil || hdr == nil {
-				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err);
-				f.Close();
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
+				f.Close()
+				continue testLoop
 			}
 			if !reflect.DeepEqual(hdr, header) {
 				t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
 					i, j, *hdr, *header)
 			}
 		}
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if err == os.EOF {
 			break
 		}
 		if hdr != nil || err != nil {
 			t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err)
 		}
-		f.Close();
+		f.Close()
 	}
 }
 
 func TestPartialRead(t *testing.T) {
-	f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444);
+	f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
-	tr := NewReader(f);
+	tr := NewReader(f)
 
 	// Read the first four bytes; Next() should skip the last byte.
-	hdr, err := tr.Next();
+	hdr, err := tr.Next()
 	if err != nil || hdr == nil {
 		t.Fatalf("Didn't get first file: %v", err)
 	}
-	buf := make([]byte, 4);
+	buf := make([]byte, 4)
 	if _, err := io.ReadFull(tr, buf); err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -166,11 +166,11 @@ func TestPartialRead(t *testing.T) {
 	}
 
 	// Second file
-	hdr, err = tr.Next();
+	hdr, err = tr.Next()
 	if err != nil || hdr == nil {
 		t.Fatalf("Didn't get second file: %v", err)
 	}
-	buf = make([]byte, 6);
+	buf = make([]byte, 6)
 	if _, err := io.ReadFull(tr, buf); err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -181,22 +181,22 @@ func TestPartialRead(t *testing.T) {
 
 
 func TestIncrementalRead(t *testing.T) {
-	test := gnuTarTest;
-	f, err := os.Open(test.file, os.O_RDONLY, 0444);
+	test := gnuTarTest
+	f, err := os.Open(test.file, os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
-	tr := NewReader(f);
+	tr := NewReader(f)
 
-	headers := test.headers;
-	cksums := test.cksums;
-	nread := 0;
+	headers := test.headers
+	cksums := test.cksums
+	nread := 0
 
 	// loop over all files
 	for ; ; nread++ {
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if hdr == nil || err == os.EOF {
 			break
 		}
@@ -209,22 +209,22 @@ func TestIncrementalRead(t *testing.T) {
 
 		// read file contents in little chunks EOF,
 		// checksumming all the way
-		h := md5.New();
-		rdbuf := make([]uint8, 8);
+		h := md5.New()
+		rdbuf := make([]uint8, 8)
 		for {
-			nr, err := tr.Read(rdbuf);
+			nr, err := tr.Read(rdbuf)
 			if err == os.EOF {
 				break
 			}
 			if err != nil {
-				t.Errorf("Read: unexpected error %v\n", err);
-				break;
+				t.Errorf("Read: unexpected error %v\n", err)
+				break
 			}
-			h.Write(rdbuf[0:nr]);
+			h.Write(rdbuf[0:nr])
 		}
 		// verify checksum
-		have := fmt.Sprintf("%x", h.Sum());
-		want := cksums[nread];
+		have := fmt.Sprintf("%x", h.Sum())
+		want := cksums[nread]
 		if want != have {
 			t.Errorf("Bad checksum on file %s:\nhave %+v\nwant %+v", hdr.Name, have, want)
 		}
@@ -235,35 +235,35 @@ func TestIncrementalRead(t *testing.T) {
 }
 
 func TestNonSeekable(t *testing.T) {
-	test := gnuTarTest;
-	f, err := os.Open(test.file, os.O_RDONLY, 0444);
+	test := gnuTarTest
+	f, err := os.Open(test.file, os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
 	// pipe the data in
-	r, w, err := os.Pipe();
+	r, w, err := os.Pipe()
 	if err != nil {
 		t.Fatalf("Unexpected error %s", err)
 	}
 	go func() {
-		rdbuf := make([]uint8, 1<<16);
+		rdbuf := make([]uint8, 1<<16)
 		for {
-			nr, err := f.Read(rdbuf);
-			w.Write(rdbuf[0:nr]);
+			nr, err := f.Read(rdbuf)
+			w.Write(rdbuf[0:nr])
 			if err == os.EOF {
 				break
 			}
 		}
-		w.Close();
-	}();
+		w.Close()
+	}()
 
-	tr := NewReader(r);
-	nread := 0;
+	tr := NewReader(r)
+	nread := 0
 
 	for ; ; nread++ {
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if hdr == nil || err == os.EOF {
 			break
 		}
diff --git a/src/pkg/archive/tar/writer.go b/src/pkg/archive/tar/writer.go
index f3ce84afa..88f9c72bd 100644
--- a/src/pkg/archive/tar/writer.go
+++ b/src/pkg/archive/tar/writer.go
@@ -8,16 +8,16 @@ package tar
 // - catch more errors (no first header, write after close, etc.)
 
 import (
-	"io";
-	"os";
-	"strconv";
-	"strings";
+	"io"
+	"os"
+	"strconv"
+	"strings"
 )
 
 var (
-	ErrWriteTooLong		= os.NewError("write too long");
-	ErrFieldTooLong		= os.NewError("header field too long");
-	ErrWriteAfterClose	= os.NewError("write after close");
+	ErrWriteTooLong    = os.NewError("write too long")
+	ErrFieldTooLong    = os.NewError("header field too long")
+	ErrWriteAfterClose = os.NewError("write after close")
 )
 
 // A Writer provides sequential writing of a tar archive in POSIX.1 format.
@@ -36,32 +36,32 @@ var (
 //	io.Copy(tw, data);
 //	tw.Close();
 type Writer struct {
-	w		io.Writer;
-	err		os.Error;
-	nb		int64;	// number of unwritten bytes for current file entry
-	pad		int64;	// amount of padding to write after current file entry
-	closed		bool;
-	usedBinary	bool;	// whether the binary numeric field extension was used
+	w          io.Writer
+	err        os.Error
+	nb         int64 // number of unwritten bytes for current file entry
+	pad        int64 // amount of padding to write after current file entry
+	closed     bool
+	usedBinary bool // whether the binary numeric field extension was used
 }
 
 // NewWriter creates a new Writer writing to w.
-func NewWriter(w io.Writer) *Writer	{ return &Writer{w: w} }
+func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
 
 // Flush finishes writing the current file (optional).
 func (tw *Writer) Flush() os.Error {
-	n := tw.nb + tw.pad;
+	n := tw.nb + tw.pad
 	for n > 0 && tw.err == nil {
-		nr := n;
+		nr := n
 		if nr > blockSize {
 			nr = blockSize
 		}
-		var nw int;
-		nw, tw.err = tw.w.Write(zeroBlock[0:nr]);
-		n -= int64(nw);
+		var nw int
+		nw, tw.err = tw.w.Write(zeroBlock[0:nr])
+		n -= int64(nw)
 	}
-	tw.nb = 0;
-	tw.pad = 0;
-	return tw.err;
+	tw.nb = 0
+	tw.pad = 0
+	return tw.err
 }
 
 // Write s into b, terminating it with a NUL if there is room.
@@ -70,7 +70,7 @@ func (tw *Writer) cString(b []byte, s string) {
 		if tw.err == nil {
 			tw.err = ErrFieldTooLong
 		}
-		return;
+		return
 	}
 	for i, ch := range strings.Bytes(s) {
 		b[i] = ch
@@ -82,29 +82,29 @@ func (tw *Writer) cString(b []byte, s string) {
 
 // Encode x as an octal ASCII string and write it into b with leading zeros.
 func (tw *Writer) octal(b []byte, x int64) {
-	s := strconv.Itob64(x, 8);
+	s := strconv.Itob64(x, 8)
 	// leading zeros, but leave room for a NUL.
 	for len(s)+1 < len(b) {
 		s = "0" + s
 	}
-	tw.cString(b, s);
+	tw.cString(b, s)
 }
 
 // Write x into b, either as octal or as binary (GNUtar/star extension).
 func (tw *Writer) numeric(b []byte, x int64) {
 	// Try octal first.
-	s := strconv.Itob64(x, 8);
+	s := strconv.Itob64(x, 8)
 	if len(s) < len(b) {
-		tw.octal(b, x);
-		return;
+		tw.octal(b, x)
+		return
 	}
 	// Too big: use binary (big-endian).
-	tw.usedBinary = true;
+	tw.usedBinary = true
 	for i := len(b) - 1; x > 0 && i >= 0; i-- {
-		b[i] = byte(x);
-		x >>= 8;
+		b[i] = byte(x)
+		x >>= 8
 	}
-	b[0] |= 0x80;	// highest bit indicates binary format
+	b[0] |= 0x80 // highest bit indicates binary format
 }
 
 // WriteHeader writes hdr and prepares to accept the file's contents.
@@ -121,28 +121,28 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 		return tw.err
 	}
 
-	tw.nb = int64(hdr.Size);
-	tw.pad = -tw.nb & (blockSize - 1);	// blockSize is a power of two
+	tw.nb = int64(hdr.Size)
+	tw.pad = -tw.nb & (blockSize - 1) // blockSize is a power of two
 
-	header := make([]byte, blockSize);
-	s := slicer(header);
+	header := make([]byte, blockSize)
+	s := slicer(header)
 
 	// TODO(dsymonds): handle names longer than 100 chars
-	copy(s.next(100), strings.Bytes(hdr.Name));
-
-	tw.octal(s.next(8), hdr.Mode);			// 100:108
-	tw.numeric(s.next(8), hdr.Uid);			// 108:116
-	tw.numeric(s.next(8), hdr.Gid);			// 116:124
-	tw.numeric(s.next(12), hdr.Size);		// 124:136
-	tw.numeric(s.next(12), hdr.Mtime);		// 136:148
-	s.next(8);					// chksum (148:156)
-	s.next(1)[0] = hdr.Typeflag;			// 156:157
-	s.next(100);					// linkname (157:257)
-	copy(s.next(8), strings.Bytes("ustar\x0000"));	// 257:265
-	tw.cString(s.next(32), hdr.Uname);		// 265:297
-	tw.cString(s.next(32), hdr.Gname);		// 297:329
-	tw.numeric(s.next(8), hdr.Devmajor);		// 329:337
-	tw.numeric(s.next(8), hdr.Devminor);		// 337:345
+	copy(s.next(100), strings.Bytes(hdr.Name))
+
+	tw.octal(s.next(8), hdr.Mode)                 // 100:108
+	tw.numeric(s.next(8), hdr.Uid)                // 108:116
+	tw.numeric(s.next(8), hdr.Gid)                // 116:124
+	tw.numeric(s.next(12), hdr.Size)              // 124:136
+	tw.numeric(s.next(12), hdr.Mtime)             // 136:148
+	s.next(8)                                     // chksum (148:156)
+	s.next(1)[0] = hdr.Typeflag                   // 156:157
+	s.next(100)                                   // linkname (157:257)
+	copy(s.next(8), strings.Bytes("ustar\x0000")) // 257:265
+	tw.cString(s.next(32), hdr.Uname)             // 265:297
+	tw.cString(s.next(32), hdr.Gname)             // 297:329
+	tw.numeric(s.next(8), hdr.Devmajor)           // 329:337
+	tw.numeric(s.next(8), hdr.Devminor)           // 337:345
 
 	// Use the GNU magic instead of POSIX magic if we used any GNU extensions.
 	if tw.usedBinary {
@@ -151,18 +151,18 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 
 	// The chksum field is terminated by a NUL and a space.
 	// This is different from the other octal fields.
-	chksum, _ := checksum(header);
-	tw.octal(header[148:155], chksum);
-	header[155] = ' ';
+	chksum, _ := checksum(header)
+	tw.octal(header[148:155], chksum)
+	header[155] = ' '
 
 	if tw.err != nil {
 		// problem with header; probably integer too big for a field.
 		return tw.err
 	}
 
-	_, tw.err = tw.w.Write(header);
+	_, tw.err = tw.w.Write(header)
 
-	return tw.err;
+	return tw.err
 }
 
 // Write writes to the current entry in the tar archive.
@@ -170,22 +170,22 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 // hdr.Size bytes are written after WriteHeader.
 func (tw *Writer) Write(b []byte) (n int, err os.Error) {
 	if tw.closed {
-		err = ErrWriteTooLong;
-		return;
+		err = ErrWriteTooLong
+		return
 	}
-	overwrite := false;
+	overwrite := false
 	if int64(len(b)) > tw.nb {
-		b = b[0:tw.nb];
-		overwrite = true;
+		b = b[0:tw.nb]
+		overwrite = true
 	}
-	n, err = tw.w.Write(b);
-	tw.nb -= int64(n);
+	n, err = tw.w.Write(b)
+	tw.nb -= int64(n)
 	if err == nil && overwrite {
-		err = ErrWriteTooLong;
-		return;
+		err = ErrWriteTooLong
+		return
 	}
-	tw.err = err;
-	return;
+	tw.err = err
+	return
 }
 
 // Close closes the tar archive, flushing any unwritten
@@ -194,15 +194,15 @@ func (tw *Writer) Close() os.Error {
 	if tw.err != nil || tw.closed {
 		return tw.err
 	}
-	tw.Flush();
-	tw.closed = true;
+	tw.Flush()
+	tw.closed = true
 
 	// trailer: two zero blocks
 	for i := 0; i < 2; i++ {
-		_, tw.err = tw.w.Write(zeroBlock);
+		_, tw.err = tw.w.Write(zeroBlock)
 		if tw.err != nil {
 			break
 		}
 	}
-	return tw.err;
+	return tw.err
 }
diff --git a/src/pkg/archive/tar/writer_test.go b/src/pkg/archive/tar/writer_test.go
index 0df0144b1..f060efcbe 100644
--- a/src/pkg/archive/tar/writer_test.go
+++ b/src/pkg/archive/tar/writer_test.go
@@ -5,22 +5,22 @@
 package tar
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"io/ioutil";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"testing"
+	"testing/iotest"
 )
 
 type writerTestEntry struct {
-	header		*Header;
-	contents	string;
+	header   *Header
+	contents string
 }
 
 type writerTest struct {
-	file	string;	// filename of expected output
-	entries	[]*writerTestEntry;
+	file    string // filename of expected output
+	entries []*writerTestEntry
 }
 
 var writerTests = []*writerTest{
@@ -83,8 +83,8 @@ var writerTests = []*writerTest{
 
 // Render byte array in a two-character hexadecimal string, spaced for easy visual inspection.
 func bytestr(offset int, b []byte) string {
-	const rowLen = 32;
-	s := fmt.Sprintf("%04x ", offset);
+	const rowLen = 32
+	s := fmt.Sprintf("%04x ", offset)
 	for _, ch := range b {
 		switch {
 		case '0' <= ch && ch <= '9', 'A' <= ch && ch <= 'Z', 'a' <= ch && ch <= 'z':
@@ -93,59 +93,59 @@ func bytestr(offset int, b []byte) string {
 			s += fmt.Sprintf(" %02x", ch)
 		}
 	}
-	return s;
+	return s
 }
 
 // Render a pseudo-diff between two blocks of bytes.
 func bytediff(a []byte, b []byte) string {
-	const rowLen = 32;
-	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b));
+	const rowLen = 32
+	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b))
 	for offset := 0; len(a)+len(b) > 0; offset += rowLen {
-		na, nb := rowLen, rowLen;
+		na, nb := rowLen, rowLen
 		if na > len(a) {
 			na = len(a)
 		}
 		if nb > len(b) {
 			nb = len(b)
 		}
-		sa := bytestr(offset, a[0:na]);
-		sb := bytestr(offset, b[0:nb]);
+		sa := bytestr(offset, a[0:na])
+		sb := bytestr(offset, b[0:nb])
 		if sa != sb {
 			s += fmt.Sprintf("-%v\n+%v\n", sa, sb)
 		}
-		a = a[na:];
-		b = b[nb:];
+		a = a[na:]
+		b = b[nb:]
 	}
-	return s;
+	return s
 }
 
 func TestWriter(t *testing.T) {
 testLoop:
 	for i, test := range writerTests {
-		expected, err := ioutil.ReadFile(test.file);
+		expected, err := ioutil.ReadFile(test.file)
 		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err);
-			continue;
+			t.Errorf("test %d: Unexpected error: %v", i, err)
+			continue
 		}
 
-		buf := new(bytes.Buffer);
-		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10));	// only catch the first 4 KB
+		buf := new(bytes.Buffer)
+		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)) // only catch the first 4 KB
 		for j, entry := range test.entries {
 			if err := tw.WriteHeader(entry.header); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err);
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err)
+				continue testLoop
 			}
 			if _, err := io.WriteString(tw, entry.contents); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err);
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err)
+				continue testLoop
 			}
 		}
 		if err := tw.Close(); err != nil {
-			t.Errorf("test %d: Failed closing archive: %v", err);
-			continue testLoop;
+			t.Errorf("test %d: Failed closing archive: %v", err)
+			continue testLoop
 		}
 
-		actual := buf.Bytes();
+		actual := buf.Bytes()
 		if !bytes.Equal(expected, actual) {
 			t.Errorf("test %d: Incorrect result: (-=expected, +=actual)\n%v",
 				i, bytediff(expected, actual))
diff --git a/src/pkg/asn1/asn1.go b/src/pkg/asn1/asn1.go
index 4a1ef7f5e..a422f28ad 100644
--- a/src/pkg/asn1/asn1.go
+++ b/src/pkg/asn1/asn1.go
@@ -20,26 +20,26 @@ package asn1
 // everything by any means.
 
 import (
-	"fmt";
-	"os";
-	"reflect";
-	"time";
+	"fmt"
+	"os"
+	"reflect"
+	"time"
 )
 
 // A StructuralError suggests that the ASN.1 data is valid, but the Go type
 // which is receiving it doesn't match.
 type StructuralError struct {
-	Msg string;
+	Msg string
 }
 
-func (e StructuralError) String() string	{ return "ASN.1 structure error: " + e.Msg }
+func (e StructuralError) String() string { return "ASN.1 structure error: " + e.Msg }
 
 // A SyntaxError suggests that the ASN.1 data is invalid.
 type SyntaxError struct {
-	Msg string;
+	Msg string
 }
 
-func (e SyntaxError) String() string	{ return "ASN.1 syntax error: " + e.Msg }
+func (e SyntaxError) String() string { return "ASN.1 syntax error: " + e.Msg }
 
 // We start by dealing with each of the primitive types in turn.
 
@@ -47,11 +47,11 @@ func (e SyntaxError) String() string	{ return "ASN.1 syntax error: " + e.Msg }
 
 func parseBool(bytes []byte) (ret bool, err os.Error) {
 	if len(bytes) != 1 {
-		err = SyntaxError{"invalid boolean"};
-		return;
+		err = SyntaxError{"invalid boolean"}
+		return
 	}
 
-	return bytes[0] != 0, nil;
+	return bytes[0] != 0, nil
 }
 
 // INTEGER
@@ -61,31 +61,31 @@ func parseBool(bytes []byte) (ret bool, err os.Error) {
 func parseInt64(bytes []byte) (ret int64, err os.Error) {
 	if len(bytes) > 8 {
 		// We'll overflow an int64 in this case.
-		err = StructuralError{"integer too large"};
-		return;
+		err = StructuralError{"integer too large"}
+		return
 	}
 	for bytesRead := 0; bytesRead < len(bytes); bytesRead++ {
-		ret <<= 8;
-		ret |= int64(bytes[bytesRead]);
+		ret <<= 8
+		ret |= int64(bytes[bytesRead])
 	}
 
 	// Shift up and down in order to sign extend the result.
-	ret <<= 64 - uint8(len(bytes))*8;
-	ret >>= 64 - uint8(len(bytes))*8;
-	return;
+	ret <<= 64 - uint8(len(bytes))*8
+	ret >>= 64 - uint8(len(bytes))*8
+	return
 }
 
 // parseInt treats the given bytes as a big-endian, signed integer and returns
 // the result.
 func parseInt(bytes []byte) (int, os.Error) {
-	ret64, err := parseInt64(bytes);
+	ret64, err := parseInt64(bytes)
 	if err != nil {
 		return 0, err
 	}
 	if ret64 != int64(int(ret64)) {
 		return 0, StructuralError{"integer too large"}
 	}
-	return int(ret64), nil;
+	return int(ret64), nil
 }
 
 // BIT STRING
@@ -94,8 +94,8 @@ func parseInt(bytes []byte) (int, os.Error) {
 // bit string is padded up to the nearest byte in memory and the number of
 // valid bits is recorded. Padding bits will be zero.
 type BitString struct {
-	Bytes		[]byte;	// bits packed into bytes.
-	BitLength	int;	// length in bits.
+	Bytes     []byte // bits packed into bytes.
+	BitLength int    // length in bits.
 }
 
 // At returns the bit at the given index. If the index is out of range it
@@ -104,45 +104,45 @@ func (b BitString) At(i int) int {
 	if i < 0 || i >= b.BitLength {
 		return 0
 	}
-	x := i / 8;
-	y := 7 - uint(i%8);
-	return int(b.Bytes[x]>>y) & 1;
+	x := i / 8
+	y := 7 - uint(i%8)
+	return int(b.Bytes[x]>>y) & 1
 }
 
 // RightAlign returns a slice where the padding bits are at the beginning. The
 // slice may share memory with the BitString.
 func (b BitString) RightAlign() []byte {
-	shift := uint(8 - (b.BitLength % 8));
+	shift := uint(8 - (b.BitLength % 8))
 	if shift == 8 || len(b.Bytes) == 0 {
 		return b.Bytes
 	}
 
-	a := make([]byte, len(b.Bytes));
-	a[0] = b.Bytes[0] >> shift;
+	a := make([]byte, len(b.Bytes))
+	a[0] = b.Bytes[0] >> shift
 	for i := 1; i < len(b.Bytes); i++ {
-		a[i] = b.Bytes[i-1] << (8 - shift);
-		a[i] |= b.Bytes[i] >> shift;
+		a[i] = b.Bytes[i-1] << (8 - shift)
+		a[i] |= b.Bytes[i] >> shift
 	}
 
-	return a;
+	return a
 }
 
 // parseBitString parses an ASN.1 bit string from the given byte array and returns it.
 func parseBitString(bytes []byte) (ret BitString, err os.Error) {
 	if len(bytes) == 0 {
-		err = SyntaxError{"zero length BIT STRING"};
-		return;
+		err = SyntaxError{"zero length BIT STRING"}
+		return
 	}
-	paddingBits := int(bytes[0]);
+	paddingBits := int(bytes[0])
 	if paddingBits > 7 ||
 		len(bytes) == 1 && paddingBits > 0 ||
 		bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {
-		err = SyntaxError{"invalid padding bits in BIT STRING"};
-		return;
+		err = SyntaxError{"invalid padding bits in BIT STRING"}
+		return
 	}
-	ret.BitLength = (len(bytes)-1)*8 - paddingBits;
-	ret.Bytes = bytes[1:];
-	return;
+	ret.BitLength = (len(bytes)-1)*8 - paddingBits
+	ret.Bytes = bytes[1:]
+	return
 }
 
 // OBJECT IDENTIFIER
@@ -155,54 +155,54 @@ type ObjectIdentifier []int
 // that are assigned in a hierarachy.
 func parseObjectIdentifier(bytes []byte) (s []int, err os.Error) {
 	if len(bytes) == 0 {
-		err = SyntaxError{"zero length OBJECT IDENTIFIER"};
-		return;
+		err = SyntaxError{"zero length OBJECT IDENTIFIER"}
+		return
 	}
 
 	// In the worst case, we get two elements from the first byte (which is
 	// encoded differently) and then every varint is a single byte long.
-	s = make([]int, len(bytes)+1);
+	s = make([]int, len(bytes)+1)
 
 	// The first byte is 40*value1 + value2:
-	s[0] = int(bytes[0]) / 40;
-	s[1] = int(bytes[0]) % 40;
-	i := 2;
+	s[0] = int(bytes[0]) / 40
+	s[1] = int(bytes[0]) % 40
+	i := 2
 	for offset := 1; offset < len(bytes); i++ {
-		var v int;
-		v, offset, err = parseBase128Int(bytes, offset);
+		var v int
+		v, offset, err = parseBase128Int(bytes, offset)
 		if err != nil {
 			return
 		}
-		s[i] = v;
+		s[i] = v
 	}
-	s = s[0:i];
-	return;
+	s = s[0:i]
+	return
 }
 
 // parseBase128Int parses a base-128 encoded int from the given offset in the
 // given byte array. It returns the value and the new offset.
 func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err os.Error) {
-	offset = initOffset;
+	offset = initOffset
 	for shifted := 0; offset < len(bytes); shifted++ {
 		if shifted > 4 {
-			err = StructuralError{"base 128 integer too large"};
-			return;
+			err = StructuralError{"base 128 integer too large"}
+			return
 		}
-		ret <<= 7;
-		b := bytes[offset];
-		ret |= int(b & 0x7f);
-		offset++;
+		ret <<= 7
+		b := bytes[offset]
+		ret |= int(b & 0x7f)
+		offset++
 		if b&0x80 == 0 {
 			return
 		}
 	}
-	err = SyntaxError{"truncated base 128 integer"};
-	return;
+	err = SyntaxError{"truncated base 128 integer"}
+	return
 }
 
 // UTCTime
 
-func isDigit(b byte) bool	{ return '0' <= b && b <= '9' }
+func isDigit(b byte) bool { return '0' <= b && b <= '9' }
 
 // twoDigits returns the value of two, base 10 digits.
 func twoDigits(bytes []byte, max int) (int, bool) {
@@ -211,11 +211,11 @@ func twoDigits(bytes []byte, max int) (int, bool) {
 			return 0, false
 		}
 	}
-	value := (int(bytes[0])-'0')*10 + int(bytes[1]-'0');
+	value := (int(bytes[0])-'0')*10 + int(bytes[1]-'0')
 	if value > max {
 		return 0, false
 	}
-	return value, true;
+	return value, true
 }
 
 // parseUTCTime parses the UTCTime from the given byte array and returns the
@@ -233,13 +233,13 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) {
 	//   YYMMDDhhmmss+hhmm
 	//   YYMMDDhhmmss-hhmm
 	if len(bytes) < 11 {
-		err = SyntaxError{"UTCTime too short"};
-		return;
+		err = SyntaxError{"UTCTime too short"}
+		return
 	}
-	ret = new(time.Time);
+	ret = new(time.Time)
 
-	var ok1, ok2, ok3, ok4, ok5 bool;
-	year, ok1 := twoDigits(bytes[0:2], 99);
+	var ok1, ok2, ok3, ok4, ok5 bool
+	year, ok1 := twoDigits(bytes[0:2], 99)
 	// RFC 5280, section 5.1.2.4 says that years 2050 or later use another date
 	// scheme.
 	if year >= 50 {
@@ -247,24 +247,24 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) {
 	} else {
 		ret.Year = 2000 + int64(year)
 	}
-	ret.Month, ok2 = twoDigits(bytes[2:4], 12);
-	ret.Day, ok3 = twoDigits(bytes[4:6], 31);
-	ret.Hour, ok4 = twoDigits(bytes[6:8], 23);
-	ret.Minute, ok5 = twoDigits(bytes[8:10], 59);
+	ret.Month, ok2 = twoDigits(bytes[2:4], 12)
+	ret.Day, ok3 = twoDigits(bytes[4:6], 31)
+	ret.Hour, ok4 = twoDigits(bytes[6:8], 23)
+	ret.Minute, ok5 = twoDigits(bytes[8:10], 59)
 	if !ok1 || !ok2 || !ok3 || !ok4 || !ok5 {
 		goto Error
 	}
-	bytes = bytes[10:];
+	bytes = bytes[10:]
 	switch bytes[0] {
 	case '0', '1', '2', '3', '4', '5', '6':
 		if len(bytes) < 3 {
 			goto Error
 		}
-		ret.Second, ok1 = twoDigits(bytes[0:2], 60);	// 60, not 59, because of leap seconds.
+		ret.Second, ok1 = twoDigits(bytes[0:2], 60) // 60, not 59, because of leap seconds.
 		if !ok1 {
 			goto Error
 		}
-		bytes = bytes[2:];
+		bytes = bytes[2:]
 	}
 	if len(bytes) == 0 {
 		goto Error
@@ -274,29 +274,29 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) {
 		if len(bytes) != 1 {
 			goto Error
 		}
-		return;
+		return
 	case '-', '+':
 		if len(bytes) != 5 {
 			goto Error
 		}
-		hours, ok1 := twoDigits(bytes[1:3], 12);
-		minutes, ok2 := twoDigits(bytes[3:5], 59);
+		hours, ok1 := twoDigits(bytes[1:3], 12)
+		minutes, ok2 := twoDigits(bytes[3:5], 59)
 		if !ok1 || !ok2 {
 			goto Error
 		}
-		sign := 1;
+		sign := 1
 		if bytes[0] == '-' {
 			sign = -1
 		}
-		ret.ZoneOffset = sign * (60 * (hours*60 + minutes));
+		ret.ZoneOffset = sign * (60 * (hours*60 + minutes))
 	default:
 		goto Error
 	}
-	return;
+	return
 
 Error:
-	err = SyntaxError{"invalid UTCTime"};
-	return;
+	err = SyntaxError{"invalid UTCTime"}
+	return
 }
 
 // PrintableString
@@ -306,12 +306,12 @@ Error:
 func parsePrintableString(bytes []byte) (ret string, err os.Error) {
 	for _, b := range bytes {
 		if !isPrintable(b) {
-			err = SyntaxError{"PrintableString contains invalid character"};
-			return;
+			err = SyntaxError{"PrintableString contains invalid character"}
+			return
 		}
 	}
-	ret = string(bytes);
-	return;
+	ret = string(bytes)
+	return
 }
 
 // isPrintable returns true iff the given b is in the ASN.1 PrintableString set.
@@ -334,19 +334,19 @@ func isPrintable(b byte) bool {
 func parseIA5String(bytes []byte) (ret string, err os.Error) {
 	for _, b := range bytes {
 		if b >= 0x80 {
-			err = SyntaxError{"IA5String contains invalid character"};
-			return;
+			err = SyntaxError{"IA5String contains invalid character"}
+			return
 		}
 	}
-	ret = string(bytes);
-	return;
+	ret = string(bytes)
+	return
 }
 
 // A RawValue represents an undecoded ASN.1 object.
 type RawValue struct {
-	Class, Tag	int;
-	IsCompound	bool;
-	Bytes		[]byte;
+	Class, Tag int
+	IsCompound bool
+	Bytes      []byte
 }
 
 // RawContent is used to signal that the undecoded, DER data needs to be
@@ -361,52 +361,52 @@ type RawContent []byte
 // SET OF (tag 17) are mapped to SEQUENCE and SEQUENCE OF (tag 16) since we
 // don't distinguish between ordered and unordered objects in this code.
 func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err os.Error) {
-	offset = initOffset;
-	b := bytes[offset];
-	offset++;
-	ret.class = int(b >> 6);
-	ret.isCompound = b&0x20 == 0x20;
-	ret.tag = int(b & 0x1f);
+	offset = initOffset
+	b := bytes[offset]
+	offset++
+	ret.class = int(b >> 6)
+	ret.isCompound = b&0x20 == 0x20
+	ret.tag = int(b & 0x1f)
 
 	// If the bottom five bits are set, then the tag number is actually base 128
 	// encoded afterwards
 	if ret.tag == 0x1f {
-		ret.tag, offset, err = parseBase128Int(bytes, offset);
+		ret.tag, offset, err = parseBase128Int(bytes, offset)
 		if err != nil {
 			return
 		}
 	}
 	if offset >= len(bytes) {
-		err = SyntaxError{"truncated tag or length"};
-		return;
+		err = SyntaxError{"truncated tag or length"}
+		return
 	}
-	b = bytes[offset];
-	offset++;
+	b = bytes[offset]
+	offset++
 	if b&0x80 == 0 {
 		// The length is encoded in the bottom 7 bits.
 		ret.length = int(b & 0x7f)
 	} else {
 		// Bottom 7 bits give the number of length bytes to follow.
-		numBytes := int(b & 0x7f);
+		numBytes := int(b & 0x7f)
 		// We risk overflowing a signed 32-bit number if we accept more than 3 bytes.
 		if numBytes > 3 {
-			err = StructuralError{"length too large"};
-			return;
+			err = StructuralError{"length too large"}
+			return
 		}
 		if numBytes == 0 {
-			err = SyntaxError{"indefinite length found (not DER)"};
-			return;
+			err = SyntaxError{"indefinite length found (not DER)"}
+			return
 		}
-		ret.length = 0;
+		ret.length = 0
 		for i := 0; i < numBytes; i++ {
 			if offset >= len(bytes) {
-				err = SyntaxError{"truncated tag or length"};
-				return;
+				err = SyntaxError{"truncated tag or length"}
+				return
 			}
-			b = bytes[offset];
-			offset++;
-			ret.length <<= 8;
-			ret.length |= int(b);
+			b = bytes[offset]
+			offset++
+			ret.length <<= 8
+			ret.length |= int(b)
 		}
 	}
 
@@ -415,57 +415,57 @@ func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset i
 	if ret.tag == tagSet {
 		ret.tag = tagSequence
 	}
-	return;
+	return
 }
 
 // parseSequenceOf is used for SEQUENCE OF and SET OF values. It tries to parse
 // a number of ASN.1 values from the given byte array and returns them as a
 // slice of Go values of the given type.
 func parseSequenceOf(bytes []byte, sliceType *reflect.SliceType, elemType reflect.Type) (ret *reflect.SliceValue, err os.Error) {
-	expectedTag, compoundType, ok := getUniversalType(elemType);
+	expectedTag, compoundType, ok := getUniversalType(elemType)
 	if !ok {
-		err = StructuralError{"unknown Go type for slice"};
-		return;
+		err = StructuralError{"unknown Go type for slice"}
+		return
 	}
 
 	// First we iterate over the input and count the number of elements,
 	// checking that the types are correct in each case.
-	numElements := 0;
+	numElements := 0
 	for offset := 0; offset < len(bytes); {
-		var t tagAndLength;
-		t, offset, err = parseTagAndLength(bytes, offset);
+		var t tagAndLength
+		t, offset, err = parseTagAndLength(bytes, offset)
 		if err != nil {
 			return
 		}
 		if t.class != classUniversal || t.isCompound != compoundType || t.tag != expectedTag {
-			err = StructuralError{"sequence tag mismatch"};
-			return;
+			err = StructuralError{"sequence tag mismatch"}
+			return
 		}
 		if invalidLength(offset, t.length, len(bytes)) {
-			err = SyntaxError{"truncated sequence"};
-			return;
+			err = SyntaxError{"truncated sequence"}
+			return
 		}
-		offset += t.length;
-		numElements++;
+		offset += t.length
+		numElements++
 	}
-	ret = reflect.MakeSlice(sliceType, numElements, numElements);
-	params := fieldParameters{};
-	offset := 0;
+	ret = reflect.MakeSlice(sliceType, numElements, numElements)
+	params := fieldParameters{}
+	offset := 0
 	for i := 0; i < numElements; i++ {
-		offset, err = parseField(ret.Elem(i), bytes, offset, params);
+		offset, err = parseField(ret.Elem(i), bytes, offset, params)
 		if err != nil {
 			return
 		}
 	}
-	return;
+	return
 }
 
 var (
-	bitStringType		= reflect.Typeof(BitString{});
-	objectIdentifierType	= reflect.Typeof(ObjectIdentifier{});
-	timeType		= reflect.Typeof(&time.Time{});
-	rawValueType		= reflect.Typeof(RawValue{});
-	rawContentsType		= reflect.Typeof(RawContent(nil));
+	bitStringType        = reflect.Typeof(BitString{})
+	objectIdentifierType = reflect.Typeof(ObjectIdentifier{})
+	timeType             = reflect.Typeof(&time.Time{})
+	rawValueType         = reflect.Typeof(RawValue{})
+	rawContentsType      = reflect.Typeof(RawContent(nil))
 )
 
 // invalidLength returns true iff offset + length > sliceLength, or if the
@@ -478,49 +478,49 @@ func invalidLength(offset, length, sliceLength int) bool {
 // into the array, it will try to parse a suitable ASN.1 value out and store it
 // in the given Value.
 func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err os.Error) {
-	offset = initOffset;
-	fieldType := v.Type();
+	offset = initOffset
+	fieldType := v.Type()
 
 	// If we have run out of data, it may be that there are optional elements at the end.
 	if offset == len(bytes) {
 		if !setDefaultValue(v, params) {
 			err = SyntaxError{"sequence truncated"}
 		}
-		return;
+		return
 	}
 
 	// Deal with raw values.
 	if fieldType == rawValueType {
-		var t tagAndLength;
-		t, offset, err = parseTagAndLength(bytes, offset);
+		var t tagAndLength
+		t, offset, err = parseTagAndLength(bytes, offset)
 		if err != nil {
 			return
 		}
 		if invalidLength(offset, t.length, len(bytes)) {
-			err = SyntaxError{"data truncated"};
-			return;
+			err = SyntaxError{"data truncated"}
+			return
 		}
-		result := RawValue{t.class, t.tag, t.isCompound, bytes[offset : offset+t.length]};
-		offset += t.length;
-		v.(*reflect.StructValue).Set(reflect.NewValue(result).(*reflect.StructValue));
-		return;
+		result := RawValue{t.class, t.tag, t.isCompound, bytes[offset : offset+t.length]}
+		offset += t.length
+		v.(*reflect.StructValue).Set(reflect.NewValue(result).(*reflect.StructValue))
+		return
 	}
 
 	// Deal with the ANY type.
 	if ifaceType, ok := fieldType.(*reflect.InterfaceType); ok && ifaceType.NumMethod() == 0 {
-		ifaceValue := v.(*reflect.InterfaceValue);
-		var t tagAndLength;
-		t, offset, err = parseTagAndLength(bytes, offset);
+		ifaceValue := v.(*reflect.InterfaceValue)
+		var t tagAndLength
+		t, offset, err = parseTagAndLength(bytes, offset)
 		if err != nil {
 			return
 		}
 		if invalidLength(offset, t.length, len(bytes)) {
-			err = SyntaxError{"data truncated"};
-			return;
+			err = SyntaxError{"data truncated"}
+			return
 		}
 		var result interface{}
 		if !t.isCompound && t.class == classUniversal {
-			innerBytes := bytes[offset : offset+t.length];
+			innerBytes := bytes[offset : offset+t.length]
 			switch t.tag {
 			case tagPrintableString:
 				result, err = parsePrintableString(innerBytes)
@@ -540,40 +540,40 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
 				// If we don't know how to handle the type, we just leave Value as nil.
 			}
 		}
-		offset += t.length;
+		offset += t.length
 		if err != nil {
 			return
 		}
 		if result != nil {
 			ifaceValue.Set(reflect.NewValue(result))
 		}
-		return;
+		return
 	}
-	universalTag, compoundType, ok1 := getUniversalType(fieldType);
+	universalTag, compoundType, ok1 := getUniversalType(fieldType)
 	if !ok1 {
-		err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)};
-		return;
+		err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)}
+		return
 	}
 
-	t, offset, err := parseTagAndLength(bytes, offset);
+	t, offset, err := parseTagAndLength(bytes, offset)
 	if err != nil {
 		return
 	}
 	if params.explicit {
 		if t.class == classContextSpecific && t.tag == *params.tag && t.isCompound {
-			t, offset, err = parseTagAndLength(bytes, offset);
+			t, offset, err = parseTagAndLength(bytes, offset)
 			if err != nil {
 				return
 			}
 		} else {
 			// The tags didn't match, it might be an optional element.
-			ok := setDefaultValue(v, params);
+			ok := setDefaultValue(v, params)
 			if ok {
 				offset = initOffset
 			} else {
 				err = StructuralError{"explicitly tagged member didn't match"}
 			}
-			return;
+			return
 		}
 	}
 
@@ -585,128 +585,128 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
 		universalTag = tagIA5String
 	}
 
-	expectedClass := classUniversal;
-	expectedTag := universalTag;
+	expectedClass := classUniversal
+	expectedTag := universalTag
 
 	if !params.explicit && params.tag != nil {
-		expectedClass = classContextSpecific;
-		expectedTag = *params.tag;
+		expectedClass = classContextSpecific
+		expectedTag = *params.tag
 	}
 
 	// We have unwrapped any explicit tagging at this point.
 	if t.class != expectedClass || t.tag != expectedTag || t.isCompound != compoundType {
 		// Tags don't match. Again, it could be an optional element.
-		ok := setDefaultValue(v, params);
+		ok := setDefaultValue(v, params)
 		if ok {
 			offset = initOffset
 		} else {
 			err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)}
 		}
-		return;
+		return
 	}
 	if invalidLength(offset, t.length, len(bytes)) {
-		err = SyntaxError{"data truncated"};
-		return;
+		err = SyntaxError{"data truncated"}
+		return
 	}
-	innerBytes := bytes[offset : offset+t.length];
+	innerBytes := bytes[offset : offset+t.length]
 
 	// We deal with the structures defined in this package first.
 	switch fieldType {
 	case objectIdentifierType:
-		newSlice, err1 := parseObjectIdentifier(innerBytes);
-		sliceValue := v.(*reflect.SliceValue);
-		sliceValue.Set(reflect.MakeSlice(sliceValue.Type().(*reflect.SliceType), len(newSlice), len(newSlice)));
+		newSlice, err1 := parseObjectIdentifier(innerBytes)
+		sliceValue := v.(*reflect.SliceValue)
+		sliceValue.Set(reflect.MakeSlice(sliceValue.Type().(*reflect.SliceType), len(newSlice), len(newSlice)))
 		if err1 == nil {
 			reflect.ArrayCopy(sliceValue, reflect.NewValue(newSlice).(reflect.ArrayOrSliceValue))
 		}
-		offset += t.length;
-		err = err1;
-		return;
+		offset += t.length
+		err = err1
+		return
 	case bitStringType:
-		structValue := v.(*reflect.StructValue);
-		bs, err1 := parseBitString(innerBytes);
-		offset += t.length;
+		structValue := v.(*reflect.StructValue)
+		bs, err1 := parseBitString(innerBytes)
+		offset += t.length
 		if err1 == nil {
 			structValue.Set(reflect.NewValue(bs).(*reflect.StructValue))
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	case timeType:
-		ptrValue := v.(*reflect.PtrValue);
-		time, err1 := parseUTCTime(innerBytes);
-		offset += t.length;
+		ptrValue := v.(*reflect.PtrValue)
+		time, err1 := parseUTCTime(innerBytes)
+		offset += t.length
 		if err1 == nil {
 			ptrValue.Set(reflect.NewValue(time).(*reflect.PtrValue))
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	}
 	switch val := v.(type) {
 	case *reflect.BoolValue:
-		parsedBool, err1 := parseBool(innerBytes);
-		offset += t.length;
+		parsedBool, err1 := parseBool(innerBytes)
+		offset += t.length
 		if err1 == nil {
 			val.Set(parsedBool)
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	case *reflect.IntValue:
-		parsedInt, err1 := parseInt(innerBytes);
-		offset += t.length;
+		parsedInt, err1 := parseInt(innerBytes)
+		offset += t.length
 		if err1 == nil {
 			val.Set(parsedInt)
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	case *reflect.Int64Value:
-		parsedInt, err1 := parseInt64(innerBytes);
-		offset += t.length;
+		parsedInt, err1 := parseInt64(innerBytes)
+		offset += t.length
 		if err1 == nil {
 			val.Set(parsedInt)
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	case *reflect.StructValue:
-		structType := fieldType.(*reflect.StructType);
+		structType := fieldType.(*reflect.StructType)
 
 		if structType.NumField() > 0 &&
 			structType.Field(0).Type == rawContentsType {
-			bytes := bytes[initOffset : offset+t.length];
-			val.Field(0).SetValue(reflect.NewValue(RawContent(bytes)));
+			bytes := bytes[initOffset : offset+t.length]
+			val.Field(0).SetValue(reflect.NewValue(RawContent(bytes)))
 		}
 
-		innerOffset := 0;
+		innerOffset := 0
 		for i := 0; i < structType.NumField(); i++ {
-			field := structType.Field(i);
+			field := structType.Field(i)
 			if i == 0 && field.Type == rawContentsType {
 				continue
 			}
-			innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag));
+			innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag))
 			if err != nil {
 				return
 			}
 		}
-		offset += t.length;
+		offset += t.length
 		// We allow extra bytes at the end of the SEQUENCE because
 		// adding elements to the end has been used in X.509 as the
 		// version numbers have increased.
-		return;
+		return
 	case *reflect.SliceValue:
-		sliceType := fieldType.(*reflect.SliceType);
+		sliceType := fieldType.(*reflect.SliceType)
 		if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok {
-			val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes)));
-			reflect.ArrayCopy(val, reflect.NewValue(innerBytes).(reflect.ArrayOrSliceValue));
-			return;
+			val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes)))
+			reflect.ArrayCopy(val, reflect.NewValue(innerBytes).(reflect.ArrayOrSliceValue))
+			return
 		}
-		newSlice, err1 := parseSequenceOf(innerBytes, sliceType, sliceType.Elem());
-		offset += t.length;
+		newSlice, err1 := parseSequenceOf(innerBytes, sliceType, sliceType.Elem())
+		offset += t.length
 		if err1 == nil {
 			val.Set(newSlice)
 		}
-		err = err1;
-		return;
+		err = err1
+		return
 	case *reflect.StringValue:
-		var v string;
+		var v string
 		switch universalTag {
 		case tagPrintableString:
 			v, err = parsePrintableString(innerBytes)
@@ -718,10 +718,10 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
 		if err == nil {
 			val.Set(v)
 		}
-		return;
+		return
 	}
-	err = StructuralError{"unknown Go type"};
-	return;
+	err = StructuralError{"unknown Go type"}
+	return
 }
 
 // setDefaultValue is used to install a default value, from a tag string, into
@@ -731,7 +731,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
 	if !params.optional {
 		return
 	}
-	ok = true;
+	ok = true
 	if params.defaultValue == nil {
 		return
 	}
@@ -741,7 +741,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
 	case *reflect.Int64Value:
 		val.Set(int64(*params.defaultValue))
 	}
-	return;
+	return
 }
 
 // Unmarshal parses the DER-encoded ASN.1 data structure b
@@ -785,10 +785,10 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
 // Other ASN.1 types are not supported; if it encounters them,
 // Unmarshal returns a parse error.
 func Unmarshal(val interface{}, b []byte) (rest []byte, err os.Error) {
-	v := reflect.NewValue(val).(*reflect.PtrValue).Elem();
-	offset, err := parseField(v, b, 0, fieldParameters{});
+	v := reflect.NewValue(val).(*reflect.PtrValue).Elem()
+	offset, err := parseField(v, b, 0, fieldParameters{})
 	if err != nil {
 		return nil, err
 	}
-	return b[offset:], nil;
+	return b[offset:], nil
 }
diff --git a/src/pkg/asn1/asn1_test.go b/src/pkg/asn1/asn1_test.go
index 6f677ffb6..5071facfc 100644
--- a/src/pkg/asn1/asn1_test.go
+++ b/src/pkg/asn1/asn1_test.go
@@ -5,17 +5,17 @@
 package asn1
 
 import (
-	"bytes";
-	"reflect";
-	"strings";
-	"testing";
-	"time";
+	"bytes"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
 )
 
 type int64Test struct {
-	in	[]byte;
-	ok	bool;
-	out	int64;
+	in  []byte
+	ok  bool
+	out int64
 }
 
 var int64TestData = []int64Test{
@@ -33,7 +33,7 @@ var int64TestData = []int64Test{
 
 func TestParseInt64(t *testing.T) {
 	for i, test := range int64TestData {
-		ret, err := parseInt64(test.in);
+		ret, err := parseInt64(test.in)
 		if (err == nil) != test.ok {
 			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 		}
@@ -44,10 +44,10 @@ func TestParseInt64(t *testing.T) {
 }
 
 type bitStringTest struct {
-	in		[]byte;
-	ok		bool;
-	out		[]byte;
-	bitLength	int;
+	in        []byte
+	ok        bool
+	out       []byte
+	bitLength int
 }
 
 var bitStringTestData = []bitStringTest{
@@ -61,7 +61,7 @@ var bitStringTestData = []bitStringTest{
 
 func TestBitString(t *testing.T) {
 	for i, test := range bitStringTestData {
-		ret, err := parseBitString(test.in);
+		ret, err := parseBitString(test.in)
 		if (err == nil) != test.ok {
 			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 		}
@@ -74,7 +74,7 @@ func TestBitString(t *testing.T) {
 }
 
 func TestBitStringAt(t *testing.T) {
-	bs := BitString{[]byte{0x82, 0x40}, 16};
+	bs := BitString{[]byte{0x82, 0x40}, 16}
 	if bs.At(0) != 1 {
 		t.Error("#1: Failed")
 	}
@@ -90,9 +90,9 @@ func TestBitStringAt(t *testing.T) {
 }
 
 type bitStringRightAlignTest struct {
-	in	[]byte;
-	inlen	int;
-	out	[]byte;
+	in    []byte
+	inlen int
+	out   []byte
 }
 
 var bitStringRightAlignTests = []bitStringRightAlignTest{
@@ -106,8 +106,8 @@ var bitStringRightAlignTests = []bitStringRightAlignTest{
 
 func TestBitStringRightAlign(t *testing.T) {
 	for i, test := range bitStringRightAlignTests {
-		bs := BitString{test.in, test.inlen};
-		out := bs.RightAlign();
+		bs := BitString{test.in, test.inlen}
+		out := bs.RightAlign()
 		if bytes.Compare(out, test.out) != 0 {
 			t.Errorf("#%d got: %x want: %x", i, out, test.out)
 		}
@@ -115,9 +115,9 @@ func TestBitStringRightAlign(t *testing.T) {
 }
 
 type objectIdentifierTest struct {
-	in	[]byte;
-	ok	bool;
-	out	[]int;
+	in  []byte
+	ok  bool
+	out []int
 }
 
 var objectIdentifierTestData = []objectIdentifierTest{
@@ -130,7 +130,7 @@ var objectIdentifierTestData = []objectIdentifierTest{
 
 func TestObjectIdentifier(t *testing.T) {
 	for i, test := range objectIdentifierTestData {
-		ret, err := parseObjectIdentifier(test.in);
+		ret, err := parseObjectIdentifier(test.in)
 		if (err == nil) != test.ok {
 			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 		}
@@ -143,9 +143,9 @@ func TestObjectIdentifier(t *testing.T) {
 }
 
 type timeTest struct {
-	in	string;
-	ok	bool;
-	out	*time.Time;
+	in  string
+	ok  bool
+	out *time.Time
 }
 
 var timeTestData = []timeTest{
@@ -165,7 +165,7 @@ var timeTestData = []timeTest{
 
 func TestTime(t *testing.T) {
 	for i, test := range timeTestData {
-		ret, err := parseUTCTime(strings.Bytes(test.in));
+		ret, err := parseUTCTime(strings.Bytes(test.in))
 		if (err == nil) != test.ok {
 			t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
 		}
@@ -178,9 +178,9 @@ func TestTime(t *testing.T) {
 }
 
 type tagAndLengthTest struct {
-	in	[]byte;
-	ok	bool;
-	out	tagAndLength;
+	in  []byte
+	ok  bool
+	out tagAndLength
 }
 
 var tagAndLengthData = []tagAndLengthTest{
@@ -200,7 +200,7 @@ var tagAndLengthData = []tagAndLengthTest{
 
 func TestParseTagAndLength(t *testing.T) {
 	for i, test := range tagAndLengthData {
-		tagAndLength, _, err := parseTagAndLength(test.in, 0);
+		tagAndLength, _, err := parseTagAndLength(test.in, 0)
 		if (err == nil) != test.ok {
 			t.Errorf("#%d: Incorrect error result (did pass? %v, expected: %v)", i, err == nil, test.ok)
 		}
@@ -211,17 +211,17 @@ func TestParseTagAndLength(t *testing.T) {
 }
 
 type parseFieldParametersTest struct {
-	in	string;
-	out	fieldParameters;
+	in  string
+	out fieldParameters
 }
 
-func newInt(n int) *int	{ return &n }
+func newInt(n int) *int { return &n }
 
-func newInt64(n int64) *int64	{ return &n }
+func newInt64(n int64) *int64 { return &n }
 
-func newString(s string) *string	{ return &s }
+func newString(s string) *string { return &s }
 
-func newBool(b bool) *bool	{ return &b }
+func newBool(b bool) *bool { return &b }
 
 var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParametersTest{
 	parseFieldParametersTest{"", fieldParameters{false, false, nil, nil, 0}},
@@ -238,7 +238,7 @@ var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParame
 
 func TestParseFieldParameters(t *testing.T) {
 	for i, test := range parseFieldParametersTestData {
-		f := parseFieldParameters(test.in);
+		f := parseFieldParameters(test.in)
 		if !reflect.DeepEqual(f, test.out) {
 			t.Errorf("#%d: Bad result: %v (expected %v)", i, f, test.out)
 		}
@@ -246,21 +246,21 @@ func TestParseFieldParameters(t *testing.T) {
 }
 
 type unmarshalTest struct {
-	in	[]byte;
-	out	interface{};
+	in  []byte
+	out interface{}
 }
 
 type TestObjectIdentifierStruct struct {
-	OID ObjectIdentifier;
+	OID ObjectIdentifier
 }
 
 type TestContextSpecificTags struct {
-	A int "tag:1";
+	A int "tag:1"
 }
 
 type TestContextSpecificTags2 struct {
-	A	int	"explicit,tag:1";
-	B	int;
+	A int "explicit,tag:1"
+	B int
 }
 
 var unmarshalTestData []unmarshalTest = []unmarshalTest{
@@ -281,11 +281,11 @@ var unmarshalTestData []unmarshalTest = []unmarshalTest{
 
 func TestUnmarshal(t *testing.T) {
 	for i, test := range unmarshalTestData {
-		pv := reflect.MakeZero(reflect.NewValue(test.out).Type());
-		zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem());
-		pv.(*reflect.PtrValue).PointTo(zv);
-		val := pv.Interface();
-		_, err := Unmarshal(val, test.in);
+		pv := reflect.MakeZero(reflect.NewValue(test.out).Type())
+		zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem())
+		pv.(*reflect.PtrValue).PointTo(zv)
+		val := pv.Interface()
+		_, err := Unmarshal(val, test.in)
 		if err != nil {
 			t.Errorf("Unmarshal failed at index %d %v", i, err)
 		}
@@ -296,23 +296,23 @@ func TestUnmarshal(t *testing.T) {
 }
 
 type Certificate struct {
-	TBSCertificate		TBSCertificate;
-	SignatureAlgorithm	AlgorithmIdentifier;
-	SignatureValue		BitString;
+	TBSCertificate     TBSCertificate
+	SignatureAlgorithm AlgorithmIdentifier
+	SignatureValue     BitString
 }
 
 type TBSCertificate struct {
-	Version			int	"optional,explicit,default:0,tag:0";
-	SerialNumber		RawValue;
-	SignatureAlgorithm	AlgorithmIdentifier;
-	Issuer			RDNSequence;
-	Validity		Validity;
-	Subject			RDNSequence;
-	PublicKey		PublicKeyInfo;
+	Version            int "optional,explicit,default:0,tag:0"
+	SerialNumber       RawValue
+	SignatureAlgorithm AlgorithmIdentifier
+	Issuer             RDNSequence
+	Validity           Validity
+	Subject            RDNSequence
+	PublicKey          PublicKeyInfo
 }
 
 type AlgorithmIdentifier struct {
-	Algorithm ObjectIdentifier;
+	Algorithm ObjectIdentifier
 }
 
 type RDNSequence []RelativeDistinguishedName
@@ -320,22 +320,22 @@ type RDNSequence []RelativeDistinguishedName
 type RelativeDistinguishedName []AttributeTypeAndValue
 
 type AttributeTypeAndValue struct {
-	Type	ObjectIdentifier;
-	Value	interface{};
+	Type  ObjectIdentifier
+	Value interface{}
 }
 
 type Validity struct {
-	NotBefore, NotAfter *time.Time;
+	NotBefore, NotAfter *time.Time
 }
 
 type PublicKeyInfo struct {
-	Algorithm	AlgorithmIdentifier;
-	PublicKey	BitString;
+	Algorithm AlgorithmIdentifier
+	PublicKey BitString
 }
 
 func TestCertificate(t *testing.T) {
 	// This is a minimal, self-signed certificate that should parse correctly.
-	var cert Certificate;
+	var cert Certificate
 	if _, err := Unmarshal(&cert, derEncodedSelfSignedCertBytes); err != nil {
 		t.Errorf("Unmarshal failed: %v", err)
 	}
@@ -348,29 +348,29 @@ func TestCertificateWithNUL(t *testing.T) {
 	// This is the paypal NUL-hack certificate. It should fail to parse because
 	// NUL isn't a permitted character in a PrintableString.
 
-	var cert Certificate;
+	var cert Certificate
 	if _, err := Unmarshal(&cert, derEncodedPaypalNULCertBytes); err == nil {
 		t.Error("Unmarshal succeeded, should not have")
 	}
 }
 
 type rawStructTest struct {
-	Raw	RawContent;
-	A	int;
+	Raw RawContent
+	A   int
 }
 
 func TestRawStructs(t *testing.T) {
-	var s rawStructTest;
-	input := []byte{0x30, 0x03, 0x02, 0x01, 0x50};
+	var s rawStructTest
+	input := []byte{0x30, 0x03, 0x02, 0x01, 0x50}
 
-	rest, err := Unmarshal(&s, input);
+	rest, err := Unmarshal(&s, input)
 	if len(rest) != 0 {
-		t.Errorf("incomplete parse: %x", rest);
-		return;
+		t.Errorf("incomplete parse: %x", rest)
+		return
 	}
 	if err != nil {
-		t.Error(err);
-		return;
+		t.Error(err)
+		return
 	}
 	if s.A != 0x50 {
 		t.Errorf("bad value for A: got %d want %d", s.A, 0x50)
diff --git a/src/pkg/asn1/common.go b/src/pkg/asn1/common.go
index bdc4c8abd..a3278b639 100644
--- a/src/pkg/asn1/common.go
+++ b/src/pkg/asn1/common.go
@@ -5,9 +5,9 @@
 package asn1
 
 import (
-	"reflect";
-	"strconv";
-	"strings";
+	"reflect"
+	"strconv"
+	"strings"
 )
 
 // ASN.1 objects have metadata preceeding them:
@@ -19,28 +19,28 @@ import (
 // Here are some standard tags and classes
 
 const (
-	tagBoolean		= 1;
-	tagInteger		= 2;
-	tagBitString		= 3;
-	tagOctetString		= 4;
-	tagOID			= 6;
-	tagSequence		= 16;
-	tagSet			= 17;
-	tagPrintableString	= 19;
-	tagIA5String		= 22;
-	tagUTCTime		= 23;
+	tagBoolean         = 1
+	tagInteger         = 2
+	tagBitString       = 3
+	tagOctetString     = 4
+	tagOID             = 6
+	tagSequence        = 16
+	tagSet             = 17
+	tagPrintableString = 19
+	tagIA5String       = 22
+	tagUTCTime         = 23
 )
 
 const (
-	classUniversal		= 0;
-	classApplication	= 1;
-	classContextSpecific	= 2;
-	classPrivate		= 3;
+	classUniversal       = 0
+	classApplication     = 1
+	classContextSpecific = 2
+	classPrivate         = 3
 )
 
 type tagAndLength struct {
-	class, tag, length	int;
-	isCompound		bool;
+	class, tag, length int
+	isCompound         bool
 }
 
 // ASN.1 has IMPLICIT and EXPLICIT tags, which can be translated as "instead
@@ -63,11 +63,11 @@ type tagAndLength struct {
 
 // fieldParameters is the parsed representation of tag string from a structure field.
 type fieldParameters struct {
-	optional	bool;	// true iff the field is OPTIONAL
-	explicit	bool;	// true iff and EXPLICIT tag is in use.
-	defaultValue	*int64;	// a default value for INTEGER typed fields (maybe nil).
-	tag		*int;	// the EXPLICIT or IMPLICIT tag (maybe nil).
-	stringType	int;	// the string tag to use when marshaling.
+	optional     bool   // true iff the field is OPTIONAL
+	explicit     bool   // true iff and EXPLICIT tag is in use.
+	defaultValue *int64 // a default value for INTEGER typed fields (maybe nil).
+	tag          *int   // the EXPLICIT or IMPLICIT tag (maybe nil).
+	stringType   int    // the string tag to use when marshaling.
 
 	// Invariants:
 	//   if explicit is set, tag is non-nil.
@@ -82,30 +82,30 @@ func parseFieldParameters(str string) (ret fieldParameters) {
 		case part == "optional":
 			ret.optional = true
 		case part == "explicit":
-			ret.explicit = true;
+			ret.explicit = true
 			if ret.tag == nil {
-				ret.tag = new(int);
-				*ret.tag = 0;
+				ret.tag = new(int)
+				*ret.tag = 0
 			}
 		case part == "ia5":
 			ret.stringType = tagIA5String
 		case part == "printable":
 			ret.stringType = tagPrintableString
 		case strings.HasPrefix(part, "default:"):
-			i, err := strconv.Atoi64(part[8:]);
+			i, err := strconv.Atoi64(part[8:])
 			if err == nil {
-				ret.defaultValue = new(int64);
-				*ret.defaultValue = i;
+				ret.defaultValue = new(int64)
+				*ret.defaultValue = i
 			}
 		case strings.HasPrefix(part, "tag:"):
-			i, err := strconv.Atoi(part[4:]);
+			i, err := strconv.Atoi(part[4:])
 			if err == nil {
-				ret.tag = new(int);
-				*ret.tag = i;
+				ret.tag = new(int)
+				*ret.tag = i
 			}
 		}
 	}
-	return;
+	return
 }
 
 // Given a reflected Go type, getUniversalType returns the default tag number
@@ -132,9 +132,9 @@ func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) {
 		if _, ok := t.(*reflect.SliceType).Elem().(*reflect.Uint8Type); ok {
 			return tagOctetString, false, true
 		}
-		return tagSequence, true, true;
+		return tagSequence, true, true
 	case *reflect.StringType:
 		return tagPrintableString, false, true
 	}
-	return 0, false, false;
+	return 0, false, false
 }
diff --git a/src/pkg/asn1/marshal.go b/src/pkg/asn1/marshal.go
index 2e9aa1439..eec0ee849 100644
--- a/src/pkg/asn1/marshal.go
+++ b/src/pkg/asn1/marshal.go
@@ -5,13 +5,13 @@
 package asn1
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"os";
-	"reflect";
-	"strings";
-	"time";
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+	"time"
 )
 
 // A forkableWriter is an in-memory buffer that can be
@@ -20,8 +20,8 @@ import (
 //    pre, post := w.fork();
 // the overall sequence of bytes represented is logically w+pre+post.
 type forkableWriter struct {
-	*bytes.Buffer;
-	pre, post	*forkableWriter;
+	*bytes.Buffer
+	pre, post *forkableWriter
 }
 
 func newForkableWriter() *forkableWriter {
@@ -29,65 +29,65 @@ func newForkableWriter() *forkableWriter {
 }
 
 func (f *forkableWriter) fork() (pre, post *forkableWriter) {
-	f.pre = newForkableWriter();
-	f.post = newForkableWriter();
-	return f.pre, f.post;
+	f.pre = newForkableWriter()
+	f.post = newForkableWriter()
+	return f.pre, f.post
 }
 
 func (f *forkableWriter) Len() (l int) {
-	l += f.Buffer.Len();
+	l += f.Buffer.Len()
 	if f.pre != nil {
 		l += f.pre.Len()
 	}
 	if f.post != nil {
 		l += f.post.Len()
 	}
-	return;
+	return
 }
 
 func (f *forkableWriter) writeTo(out io.Writer) (n int, err os.Error) {
-	n, err = out.Write(f.Bytes());
+	n, err = out.Write(f.Bytes())
 	if err != nil {
 		return
 	}
 
-	var nn int;
+	var nn int
 
 	if f.pre != nil {
-		nn, err = f.pre.writeTo(out);
-		n += nn;
+		nn, err = f.pre.writeTo(out)
+		n += nn
 		if err != nil {
 			return
 		}
 	}
 
 	if f.pre != nil {
-		nn, err = f.post.writeTo(out);
-		n += nn;
+		nn, err = f.post.writeTo(out)
+		n += nn
 	}
-	return;
+	return
 }
 
 func marshalBase128Int(out *forkableWriter, i int64) (err os.Error) {
 	if i == 0 {
-		err = out.WriteByte(0);
-		return;
+		err = out.WriteByte(0)
+		return
 	}
 
 	for i > 0 {
-		next := i >> 7;
-		o := byte(i & 0x7f);
+		next := i >> 7
+		o := byte(i & 0x7f)
 		if next > 0 {
 			o |= 0x80
 		}
-		err = out.WriteByte(o);
+		err = out.WriteByte(o)
 		if err != nil {
 			return
 		}
-		i = next;
+		i = next
 	}
 
-	return nil;
+	return nil
 }
 
 func base128Length(i int) (numBytes int) {
@@ -96,63 +96,63 @@ func base128Length(i int) (numBytes int) {
 	}
 
 	for i > 0 {
-		numBytes++;
-		i >>= 7;
+		numBytes++
+		i >>= 7
 	}
 
-	return;
+	return
 }
 
 func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err os.Error) {
-	b := uint8(t.class) << 6;
+	b := uint8(t.class) << 6
 	if t.isCompound {
 		b |= 0x20
 	}
 	if t.tag >= 31 {
-		b |= 0x1f;
-		err = out.WriteByte(b);
+		b |= 0x1f
+		err = out.WriteByte(b)
 		if err != nil {
 			return
 		}
-		err = marshalBase128Int(out, int64(t.tag));
+		err = marshalBase128Int(out, int64(t.tag))
 		if err != nil {
 			return
 		}
 	} else {
-		b |= uint8(t.tag);
-		err = out.WriteByte(b);
+		b |= uint8(t.tag)
+		err = out.WriteByte(b)
 		if err != nil {
 			return
 		}
 	}
 
 	if t.length >= 128 {
-		err = out.WriteByte(byte(base128Length(t.length)));
+		err = out.WriteByte(byte(base128Length(t.length)))
 		if err != nil {
 			return
 		}
-		err = marshalBase128Int(out, int64(t.length));
+		err = marshalBase128Int(out, int64(t.length))
 		if err != nil {
 			return
 		}
 	} else {
-		err = out.WriteByte(byte(t.length));
+		err = out.WriteByte(byte(t.length))
 		if err != nil {
 			return
 		}
 	}
 
-	return nil;
+	return nil
 }
 
 func marshalBitString(out *forkableWriter, b BitString) (err os.Error) {
-	paddingBits := byte((8 - b.BitLength%8) % 8);
-	err = out.WriteByte(paddingBits);
+	paddingBits := byte((8 - b.BitLength%8) % 8)
+	err = out.WriteByte(paddingBits)
 	if err != nil {
 		return
 	}
-	_, err = out.Write(b.Bytes);
-	return;
+	_, err = out.Write(b.Bytes)
+	return
 }
 
 func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
@@ -160,50 +160,50 @@ func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
 		return StructuralError{"invalid object identifier"}
 	}
 
-	err = out.WriteByte(byte(oid[0]*40 + oid[1]));
+	err = out.WriteByte(byte(oid[0]*40 + oid[1]))
 	if err != nil {
 		return
 	}
 	for i := 2; i < len(oid); i++ {
-		err = marshalBase128Int(out, int64(oid[i]));
+		err = marshalBase128Int(out, int64(oid[i]))
 		if err != nil {
 			return
 		}
 	}
 
-	return;
+	return
 }
 
 func marshalPrintableString(out *forkableWriter, s string) (err os.Error) {
-	b := strings.Bytes(s);
+	b := strings.Bytes(s)
 	for _, c := range b {
 		if !isPrintable(c) {
 			return StructuralError{"PrintableString contains invalid character"}
 		}
 	}
 
-	_, err = out.Write(b);
-	return;
+	_, err = out.Write(b)
+	return
 }
 
 func marshalIA5String(out *forkableWriter, s string) (err os.Error) {
-	b := strings.Bytes(s);
+	b := strings.Bytes(s)
 	for _, c := range b {
 		if c > 127 {
 			return StructuralError{"IA5String contains invalid character"}
 		}
 	}
 
-	_, err = out.Write(b);
-	return;
+	_, err = out.Write(b)
+	return
 }
 
 func marshalTwoDigits(out *forkableWriter, v int) (err os.Error) {
-	err = out.WriteByte(byte('0' + (v/10)%10));
+	err = out.WriteByte(byte('0' + (v/10)%10))
 	if err != nil {
 		return
 	}
-	return out.WriteByte(byte('0' + v%10));
+	return out.WriteByte(byte('0' + v%10))
 }
 
 func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
@@ -220,35 +220,35 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
 		return
 	}
 
-	err = marshalTwoDigits(out, t.Month);
+	err = marshalTwoDigits(out, t.Month)
 	if err != nil {
 		return
 	}
 
-	err = marshalTwoDigits(out, t.Day);
+	err = marshalTwoDigits(out, t.Day)
 	if err != nil {
 		return
 	}
 
-	err = marshalTwoDigits(out, t.Hour);
+	err = marshalTwoDigits(out, t.Hour)
 	if err != nil {
 		return
 	}
 
-	err = marshalTwoDigits(out, t.Minute);
+	err = marshalTwoDigits(out, t.Minute)
 	if err != nil {
 		return
 	}
 
-	err = marshalTwoDigits(out, t.Second);
+	err = marshalTwoDigits(out, t.Second)
 	if err != nil {
 		return
 	}
 
 	switch {
 	case t.ZoneOffset/60 == 0:
-		err = out.WriteByte('Z');
-		return;
+		err = out.WriteByte('Z')
+		return
 	case t.ZoneOffset > 0:
 		err = out.WriteByte('+')
 	case t.ZoneOffset < 0:
@@ -259,18 +259,18 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
 		return
 	}
 
-	offsetMinutes := t.ZoneOffset / 60;
+	offsetMinutes := t.ZoneOffset / 60
 	if offsetMinutes < 0 {
 		offsetMinutes = -offsetMinutes
 	}
 
-	err = marshalTwoDigits(out, offsetMinutes/60);
+	err = marshalTwoDigits(out, offsetMinutes/60)
 	if err != nil {
 		return
 	}
 
-	err = marshalTwoDigits(out, offsetMinutes%60);
-	return;
+	err = marshalTwoDigits(out, offsetMinutes%60)
+	return
 }
 
 func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameters) (err os.Error) {
@@ -295,81 +295,81 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
 	case *reflect.Int64Value:
 		return marshalBase128Int(out, v.Get())
 	case *reflect.StructValue:
-		t := v.Type().(*reflect.StructType);
+		t := v.Type().(*reflect.StructType)
 		for i := 0; i < t.NumField(); i++ {
-			err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag));
+			err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag))
 			if err != nil {
 				return
 			}
 		}
-		return;
+		return
 	case *reflect.SliceValue:
-		sliceType := v.Type().(*reflect.SliceType);
+		sliceType := v.Type().(*reflect.SliceType)
 		if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok {
-			bytes := make([]byte, v.Len());
+			bytes := make([]byte, v.Len())
 			for i := 0; i < v.Len(); i++ {
 				bytes[i] = v.Elem(i).(*reflect.Uint8Value).Get()
 			}
-			_, err = out.Write(bytes);
-			return;
+			_, err = out.Write(bytes)
+			return
 		}
 
-		var params fieldParameters;
+		var params fieldParameters
 		for i := 0; i < v.Len(); i++ {
-			err = marshalField(out, v.Elem(i), params);
+			err = marshalField(out, v.Elem(i), params)
 			if err != nil {
 				return
 			}
 		}
-		return;
+		return
 	case *reflect.StringValue:
 		if params.stringType == tagIA5String {
 			return marshalIA5String(out, v.Get())
 		} else {
 			return marshalPrintableString(out, v.Get())
 		}
-		return;
+		return
 	}
 
-	return StructuralError{"unknown Go type"};
+	return StructuralError{"unknown Go type"}
 }
 
 func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err os.Error) {
-	tag, isCompound, ok := getUniversalType(v.Type());
+	tag, isCompound, ok := getUniversalType(v.Type())
 	if !ok {
-		err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())};
-		return;
+		err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
+		return
 	}
-	class := classUniversal;
+	class := classUniversal
 
 	if params.stringType != 0 {
 		if tag != tagPrintableString {
 			return StructuralError{"Explicit string type given to non-string member"}
 		}
-		tag = params.stringType;
+		tag = params.stringType
 	}
 
-	tags, body := out.fork();
+	tags, body := out.fork()
 
-	err = marshalBody(body, v, params);
+	err = marshalBody(body, v, params)
 	if err != nil {
 		return
 	}
 
-	bodyLen := body.Len();
+	bodyLen := body.Len()
 
-	var explicitTag *forkableWriter;
+	var explicitTag *forkableWriter
 	if params.explicit {
 		explicitTag, tags = tags.fork()
 	}
 
 	if !params.explicit && params.tag != nil {
 		// implicit tag.
-		tag = *params.tag;
-		class = classContextSpecific;
+		tag = *params.tag
+		class = classContextSpecific
 	}
 
-	err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound});
+	err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound})
 	if err != nil {
 		return
 	}
@@ -383,18 +383,18 @@ func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters)
 		})
 	}
 
-	return nil;
+	return nil
 }
 
 // Marshal serialises val as an ASN.1 structure and writes the result to out.
 // In the case of an error, no output is produced.
 func Marshal(out io.Writer, val interface{}) os.Error {
-	v := reflect.NewValue(val);
-	f := newForkableWriter();
-	err := marshalField(f, v, fieldParameters{});
+	v := reflect.NewValue(val)
+	f := newForkableWriter()
+	err := marshalField(f, v, fieldParameters{})
 	if err != nil {
 		return err
 	}
-	_, err = f.writeTo(out);
-	return err;
+	_, err = f.writeTo(out)
+	return err
 }
diff --git a/src/pkg/asn1/marshal_test.go b/src/pkg/asn1/marshal_test.go
index c2ce1e476..2bb8a28d9 100644
--- a/src/pkg/asn1/marshal_test.go
+++ b/src/pkg/asn1/marshal_test.go
@@ -5,44 +5,44 @@
 package asn1
 
 import (
-	"bytes";
-	"encoding/hex";
-	"testing";
-	"time";
+	"bytes"
+	"encoding/hex"
+	"testing"
+	"time"
 )
 
 type intStruct struct {
-	A int;
+	A int
 }
 
 type nestedStruct struct {
-	A intStruct;
+	A intStruct
 }
 
 type marshalTest struct {
-	in	interface{};
-	out	string;	// hex encoded
+	in  interface{}
+	out string // hex encoded
 }
 
 type implicitTagTest struct {
-	A int "implicit,tag:5";
+	A int "implicit,tag:5"
 }
 
 type explicitTagTest struct {
-	A int "explicit,tag:5";
+	A int "explicit,tag:5"
 }
 
 type ia5StringTest struct {
-	A string "ia5";
+	A string "ia5"
 }
 
 type printableStringTest struct {
-	A string "printable";
+	A string "printable"
 }
 
 func setPST(t *time.Time) *time.Time {
-	t.ZoneOffset = -28800;
-	return t;
+	t.ZoneOffset = -28800
+	return t
 }
 
 var marshalTests = []marshalTest{
@@ -65,12 +65,12 @@ var marshalTests = []marshalTest{
 
 func TestMarshal(t *testing.T) {
 	for i, test := range marshalTests {
-		buf := bytes.NewBuffer(nil);
-		err := Marshal(buf, test.in);
+		buf := bytes.NewBuffer(nil)
+		err := Marshal(buf, test.in)
 		if err != nil {
 			t.Errorf("#%d failed: %s", i, err)
 		}
-		out, _ := hex.DecodeString(test.out);
+		out, _ := hex.DecodeString(test.out)
 		if bytes.Compare(out, buf.Bytes()) != 0 {
 			t.Errorf("#%d got: %x want %x", i, buf.Bytes(), out)
 		}
diff --git a/src/pkg/big/arith.go b/src/pkg/big/arith.go
index 3dcbe637f..81ce23a3a 100644
--- a/src/pkg/big/arith.go
+++ b/src/pkg/big/arith.go
@@ -13,14 +13,14 @@ import "unsafe"
 type Word uintptr
 
 const (
-	_S	= uintptr(unsafe.Sizeof(Word(0)));	// TODO(gri) should Sizeof return a uintptr?
-	_logW	= (0x650 >> _S) & 7;
-	_W	= 1 << _logW;
-	_B	= 1 << _W;
-	_M	= _B - 1;
-	_W2	= _W / 2;
-	_B2	= 1 << _W2;
-	_M2	= _B2 - 1;
+	_S    = uintptr(unsafe.Sizeof(Word(0))) // TODO(gri) should Sizeof return a uintptr?
+	_logW = (0x650 >> _S) & 7
+	_W    = 1 << _logW
+	_B    = 1 << _W
+	_M    = _B - 1
+	_W2   = _W / 2
+	_B2   = 1 << _W2
+	_M2   = _B2 - 1
 )
 
 
@@ -31,23 +31,23 @@ const (
 
 // z1<<_W + z0 = x+y+c, with c == 0 or 1
 func addWW_g(x, y, c Word) (z1, z0 Word) {
-	yc := y + c;
-	z0 = x + yc;
+	yc := y + c
+	z0 = x + yc
 	if z0 < x || yc < y {
 		z1 = 1
 	}
-	return;
+	return
 }
 
 
 // z1<<_W + z0 = x-y-c, with c == 0 or 1
 func subWW_g(x, y, c Word) (z1, z0 Word) {
-	yc := y + c;
-	z0 = x - yc;
+	yc := y + c
+	z0 = x - yc
 	if z0 > x || yc < y {
 		z1 = 1
 	}
-	return;
+	return
 }
 
 
@@ -65,62 +65,62 @@ func mulWW_g(x, y Word) (z1, z0 Word) {
 		// y < _B2 because y <= x
 		// sub-digits of x and y are (0, x) and (0, y)
 		// z = z[0] = x*y
-		z0 = x * y;
-		return;
+		z0 = x * y
+		return
 	}
 
 	if y < _B2 {
 		// sub-digits of x and y are (x1, x0) and (0, y)
 		// x = (x1*_B2 + x0)
 		// y = (y1*_B2 + y0)
-		x1, x0 := x>>_W2, x&_M2;
+		x1, x0 := x>>_W2, x&_M2
 
 		// x*y = t2*_B2*_B2 + t1*_B2 + t0
-		t0 := x0 * y;
-		t1 := x1 * y;
+		t0 := x0 * y
+		t1 := x1 * y
 
 		// compute result digits but avoid overflow
 		// z = z[1]*_B + z[0] = x*y
-		z0 = t1<<_W2 + t0;
-		z1 = (t1 + t0>>_W2) >> _W2;
-		return;
+		z0 = t1<<_W2 + t0
+		z1 = (t1 + t0>>_W2) >> _W2
+		return
 	}
 
 	// general case
 	// sub-digits of x and y are (x1, x0) and (y1, y0)
 	// x = (x1*_B2 + x0)
 	// y = (y1*_B2 + y0)
-	x1, x0 := x>>_W2, x&_M2;
-	y1, y0 := y>>_W2, y&_M2;
+	x1, x0 := x>>_W2, x&_M2
+	y1, y0 := y>>_W2, y&_M2
 
 	// x*y = t2*_B2*_B2 + t1*_B2 + t0
-	t0 := x0 * y0;
+	t0 := x0 * y0
 	// t1 := x1*y0 + x0*y1;
-	var c Word;
-	t1 := x1 * y0;
-	t1a := t1;
-	t1 += x0 * y1;
+	var c Word
+	t1 := x1 * y0
+	t1a := t1
+	t1 += x0 * y1
 	if t1 < t1a {
 		c++
 	}
-	t2 := x1*y1 + c*_B2;
+	t2 := x1*y1 + c*_B2
 
 	// compute result digits but avoid overflow
 	// z = z[1]*_B + z[0] = x*y
 	// This may overflow, but that's ok because we also sum t1 and t0 above
 	// and we take care of the overflow there.
-	z0 = t1<<_W2 + t0;
+	z0 = t1<<_W2 + t0
 
 	// z1 = t2 + (t1 + t0>>_W2)>>_W2;
-	var c3 Word;
-	z1 = t1 + t0>>_W2;
+	var c3 Word
+	z1 = t1 + t0>>_W2
 	if z1 < t1 {
 		c3++
 	}
-	z1 >>= _W2;
-	z1 += c3 * _B2;
-	z1 += t2;
-	return;
+	z1 >>= _W2
+	z1 += c3 * _B2
+	z1 += t2
+	return
 }
 
 
@@ -136,78 +136,78 @@ func mulAddWWW_g(x, y, c Word) (z1, z0 Word) {
 	// sub-digits of x, y, and c are (x1, x0), (y1, y0), (c1, c0)
 	// x = (x1*_B2 + x0)
 	// y = (y1*_B2 + y0)
-	x1, x0 := x>>_W2, x&_M2;
-	y1, y0 := y>>_W2, y&_M2;
-	c1, c0 := c>>_W2, c&_M2;
+	x1, x0 := x>>_W2, x&_M2
+	y1, y0 := y>>_W2, y&_M2
+	c1, c0 := c>>_W2, c&_M2
 
 	// x*y + c = t2*_B2*_B2 + t1*_B2 + t0
 	// (1<<32-1)^2 == 1<<64 - 1<<33 + 1, so there's space to add c0 in here.
-	t0 := x0*y0 + c0;
+	t0 := x0*y0 + c0
 
 	// t1 := x1*y0 + x0*y1 + c1;
-	var c2 Word;	// extra carry
-	t1 := x1*y0 + c1;
-	t1a := t1;
-	t1 += x0 * y1;
-	if t1 < t1a {	// If the number got smaller then we overflowed.
+	var c2 Word // extra carry
+	t1 := x1*y0 + c1
+	t1a := t1
+	t1 += x0 * y1
+	if t1 < t1a { // If the number got smaller then we overflowed.
 		c2++
 	}
 
-	t2 := x1*y1 + c2*_B2;
+	t2 := x1*y1 + c2*_B2
 
 	// compute result digits but avoid overflow
 	// z = z[1]*_B + z[0] = x*y
 	// z0 = t1<<_W2 + t0;
 	// This may overflow, but that's ok because we also sum t1 and t0 below
 	// and we take care of the overflow there.
-	z0 = t1<<_W2 + t0;
+	z0 = t1<<_W2 + t0
 
-	var c3 Word;
-	z1 = t1 + t0>>_W2;
+	var c3 Word
+	z1 = t1 + t0>>_W2
 	if z1 < t1 {
 		c3++
 	}
-	z1 >>= _W2;
-	z1 += t2 + c3*_B2;
+	z1 >>= _W2
+	z1 += t2 + c3*_B2
 
-	return;
+	return
 }
 
 
 // q = (x1<<_W + x0 - r)/y
 // The most significant bit of y must be 1.
 func divStep(x1, x0, y Word) (q, r Word) {
-	d1, d0 := y>>_W2, y&_M2;
-	q1, r1 := x1/d1, x1%d1;
-	m := q1 * d0;
-	r1 = r1*_B2 | x0>>_W2;
+	d1, d0 := y>>_W2, y&_M2
+	q1, r1 := x1/d1, x1%d1
+	m := q1 * d0
+	r1 = r1*_B2 | x0>>_W2
 	if r1 < m {
-		q1--;
-		r1 += y;
+		q1--
+		r1 += y
 		if r1 >= y && r1 < m {
-			q1--;
-			r1 += y;
+			q1--
+			r1 += y
 		}
 	}
-	r1 -= m;
+	r1 -= m
 
-	r0 := r1 % d1;
-	q0 := r1 / d1;
-	m = q0 * d0;
-	r0 = r0*_B2 | x0&_M2;
+	r0 := r1 % d1
+	q0 := r1 / d1
+	m = q0 * d0
+	r0 = r0*_B2 | x0&_M2
 	if r0 < m {
-		q0--;
-		r0 += y;
+		q0--
+		r0 += y
 		if r0 >= y && r0 < m {
-			q0--;
-			r0 += y;
+			q0--
+			r0 += y
 		}
 	}
-	r0 -= m;
+	r0 -= m
 
-	q = q1*_B2 | q0;
-	r = r0;
-	return;
+	q = q1*_B2 | q0
+	r = r0
+	return
 }
 
 
@@ -217,53 +217,53 @@ func leadingZeros(x Word) (n uint) {
 		return _W
 	}
 	for x&(1<<(_W-1)) == 0 {
-		n++;
-		x <<= 1;
+		n++
+		x <<= 1
 	}
-	return;
+	return
 }
 
 
 // q = (x1<<_W + x0 - r)/y
 func divWW_g(x1, x0, y Word) (q, r Word) {
 	if x1 == 0 {
-		q, r = x0/y, x0%y;
-		return;
+		q, r = x0/y, x0%y
+		return
 	}
 
-	var q0, q1 Word;
-	z := leadingZeros(y);
+	var q0, q1 Word
+	z := leadingZeros(y)
 	if y > x1 {
 		if z != 0 {
-			y <<= z;
-			x1 = (x1 << z) | (x0 >> (_W - z));
-			x0 <<= z;
+			y <<= z
+			x1 = (x1 << z) | (x0 >> (_W - z))
+			x0 <<= z
 		}
-		q0, x0 = divStep(x1, x0, y);
-		q1 = 0;
+		q0, x0 = divStep(x1, x0, y)
+		q1 = 0
 	} else {
 		if z == 0 {
-			x1 -= y;
-			q1 = 1;
+			x1 -= y
+			q1 = 1
 		} else {
-			z1 := _W - z;
-			y <<= z;
-			x2 := x1 >> z1;
-			x1 = (x1 << z) | (x0 >> z1);
-			x0 <<= z;
-			q1, x1 = divStep(x2, x1, y);
+			z1 := _W - z
+			y <<= z
+			x2 := x1 >> z1
+			x1 = (x1 << z) | (x0 >> z1)
+			x0 <<= z
+			q1, x1 = divStep(x2, x1, y)
 		}
 
-		q0, x0 = divStep(x1, x0, y);
+		q0, x0 = divStep(x1, x0, y)
 	}
 
-	r = x0 >> z;
+	r = x0 >> z
 
 	if q1 != 0 {
 		panic("div out of range")
 	}
 
-	return q0, r;
+	return q0, r
 }
 
 
@@ -276,25 +276,25 @@ func divWW_g(x1, x0, y Word) (q, r Word) {
 // f_s should be installed if they exist.
 var (
 	// addVV sets z and returns c such that z+c = x+y.
-	addVV	func(z, x, y *Word, n int) (c Word)	= addVV_g;
+	addVV func(z, x, y *Word, n int) (c Word) = addVV_g
 
 	// subVV sets z and returns c such that z-c = x-y.
-	subVV	func(z, x, y *Word, n int) (c Word)	= subVV_g;
+	subVV func(z, x, y *Word, n int) (c Word) = subVV_g
 
 	// addVW sets z and returns c such that z+c = x-y.
-	addVW	func(z, x *Word, y Word, n int) (c Word)	= addVW_g;
+	addVW func(z, x *Word, y Word, n int) (c Word) = addVW_g
 
 	// subVW sets z and returns c such that z-c = x-y.
-	subVW	func(z, x *Word, y Word, n int) (c Word)	= subVW_g;
+	subVW func(z, x *Word, y Word, n int) (c Word) = subVW_g
 
 	// mulAddVWW sets z and returns c such that z+c = x*y + r.
-	mulAddVWW	func(z, x *Word, y, r Word, n int) (c Word)	= mulAddVWW_g;
+	mulAddVWW func(z, x *Word, y, r Word, n int) (c Word) = mulAddVWW_g
 
 	// addMulVVW sets z and returns c such that z+c = z + x*y.
-	addMulVVW	func(z, x *Word, y Word, n int) (c Word)	= addMulVVW_g;
+	addMulVVW func(z, x *Word, y Word, n int) (c Word) = addMulVVW_g
 
 	// divWVW sets z and returns r such that z-r = (xn<<(n*_W) + x) / y.
-	divWVW	func(z *Word, xn Word, x *Word, y Word, n int) (r Word)	= divWVW_g;
+	divWVW func(z *Word, xn Word, x *Word, y Word, n int) (r Word) = divWVW_g
 )
 
 
@@ -303,13 +303,13 @@ func init() {
 	//return;
 
 	// Install assembly routines.
-	addVV = addVV_s;
-	subVV = subVV_s;
-	addVW = addVW_s;
-	subVW = subVW_s;
-	mulAddVWW = mulAddVWW_s;
-	addMulVVW = addMulVVW_s;
-	divWVW = divWVW_s;
+	addVV = addVV_s
+	subVV = subVV_s
+	addVW = addVW_s
+	subVW = subVW_s
+	mulAddVWW = mulAddVWW_s
+	addMulVVW = addMulVVW_s
+	divWVW = divWVW_s
 }
 
 
@@ -323,7 +323,7 @@ func addVV_g(z, x, y *Word, n int) (c Word) {
 	for i := 0; i < n; i++ {
 		c, *z.at(i) = addWW_g(*x.at(i), *y.at(i), c)
 	}
-	return;
+	return
 }
 
 
@@ -332,56 +332,56 @@ func subVV_g(z, x, y *Word, n int) (c Word) {
 	for i := 0; i < n; i++ {
 		c, *z.at(i) = subWW_g(*x.at(i), *y.at(i), c)
 	}
-	return;
+	return
 }
 
 
 func addVW_s(z, x *Word, y Word, n int) (c Word)
 func addVW_g(z, x *Word, y Word, n int) (c Word) {
-	c = y;
+	c = y
 	for i := 0; i < n; i++ {
 		c, *z.at(i) = addWW_g(*x.at(i), c, 0)
 	}
-	return;
+	return
 }
 
 
 func subVW_s(z, x *Word, y Word, n int) (c Word)
 func subVW_g(z, x *Word, y Word, n int) (c Word) {
-	c = y;
+	c = y
 	for i := 0; i < n; i++ {
 		c, *z.at(i) = subWW_g(*x.at(i), c, 0)
 	}
-	return;
+	return
 }
 
 
 func mulAddVWW_s(z, x *Word, y, r Word, n int) (c Word)
 func mulAddVWW_g(z, x *Word, y, r Word, n int) (c Word) {
-	c = r;
+	c = r
 	for i := 0; i < n; i++ {
 		c, *z.at(i) = mulAddWWW_g(*x.at(i), y, c)
 	}
-	return;
+	return
 }
 
 
 func addMulVVW_s(z, x *Word, y Word, n int) (c Word)
 func addMulVVW_g(z, x *Word, y Word, n int) (c Word) {
 	for i := 0; i < n; i++ {
-		z1, z0 := mulAddWWW_g(*x.at(i), y, *z.at(i));
-		c, *z.at(i) = addWW_g(z0, c, 0);
-		c += z1;
+		z1, z0 := mulAddWWW_g(*x.at(i), y, *z.at(i))
+		c, *z.at(i) = addWW_g(z0, c, 0)
+		c += z1
 	}
-	return;
+	return
 }
 
 
 func divWVW_s(z *Word, xn Word, x *Word, y Word, n int) (r Word)
 func divWVW_g(z *Word, xn Word, x *Word, y Word, n int) (r Word) {
-	r = xn;
+	r = xn
 	for i := n - 1; i >= 0; i-- {
 		*z.at(i), r = divWW_g(r, *x.at(i), y)
 	}
-	return;
+	return
 }
diff --git a/src/pkg/big/arith_test.go b/src/pkg/big/arith_test.go
index 41b91626a..b0f6bf6f1 100644
--- a/src/pkg/big/arith_test.go
+++ b/src/pkg/big/arith_test.go
@@ -9,7 +9,7 @@ import "testing"
 
 type funWW func(x, y, c Word) (z1, z0 Word)
 type argWW struct {
-	x, y, c, z1, z0 Word;
+	x, y, c, z1, z0 Word
 }
 
 var sumWW = []argWW{
@@ -28,7 +28,7 @@ var sumWW = []argWW{
 
 
 func testFunWW(t *testing.T, msg string, f funWW, a argWW) {
-	z1, z0 := f(a.x, a.y, a.c);
+	z1, z0 := f(a.x, a.y, a.c)
 	if z1 != a.z1 || z0 != a.z0 {
 		t.Errorf("%s%+v\n\tgot z1:z0 = %#x:%#x; want %#x:%#x", msg, a, z1, z0, a.z1, a.z0)
 	}
@@ -37,17 +37,17 @@ func testFunWW(t *testing.T, msg string, f funWW, a argWW) {
 
 func TestFunWW(t *testing.T) {
 	for _, a := range sumWW {
-		arg := a;
-		testFunWW(t, "addWW_g", addWW_g, arg);
+		arg := a
+		testFunWW(t, "addWW_g", addWW_g, arg)
 
-		arg = argWW{a.y, a.x, a.c, a.z1, a.z0};
-		testFunWW(t, "addWW_g symmetric", addWW_g, arg);
+		arg = argWW{a.y, a.x, a.c, a.z1, a.z0}
+		testFunWW(t, "addWW_g symmetric", addWW_g, arg)
 
-		arg = argWW{a.z0, a.x, a.c, a.z1, a.y};
-		testFunWW(t, "subWW_g", subWW_g, arg);
+		arg = argWW{a.z0, a.x, a.c, a.z1, a.y}
+		testFunWW(t, "subWW_g", subWW_g, arg)
 
-		arg = argWW{a.z0, a.y, a.c, a.z1, a.x};
-		testFunWW(t, "subWW_g symmetric", subWW_g, arg);
+		arg = argWW{a.z0, a.y, a.c, a.z1, a.x}
+		testFunWW(t, "subWW_g symmetric", subWW_g, arg)
 	}
 }
 
@@ -56,14 +56,14 @@ func addr(x []Word) *Word {
 	if len(x) == 0 {
 		return nil
 	}
-	return &x[0];
+	return &x[0]
 }
 
 
 type funVV func(z, x, y *Word, n int) (c Word)
 type argVV struct {
-	z, x, y	[]Word;
-	c	Word;
+	z, x, y []Word
+	c       Word
 }
 
 var sumVV = []argVV{
@@ -80,13 +80,13 @@ var sumVV = []argVV{
 
 
 func testFunVV(t *testing.T, msg string, f funVV, a argVV) {
-	n := len(a.z);
-	z := make([]Word, n);
-	c := f(addr(z), addr(a.x), addr(a.y), n);
+	n := len(a.z)
+	z := make([]Word, n)
+	c := f(addr(z), addr(a.x), addr(a.y), n)
 	for i, zi := range z {
 		if zi != a.z[i] {
-			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]);
-			break;
+			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i])
+			break
 		}
 	}
 	if c != a.c {
@@ -97,30 +97,30 @@ func testFunVV(t *testing.T, msg string, f funVV, a argVV) {
 
 func TestFunVV(t *testing.T) {
 	for _, a := range sumVV {
-		arg := a;
-		testFunVV(t, "addVV_g", addVV_g, arg);
-		testFunVV(t, "addVV", addVV, arg);
+		arg := a
+		testFunVV(t, "addVV_g", addVV_g, arg)
+		testFunVV(t, "addVV", addVV, arg)
 
-		arg = argVV{a.z, a.y, a.x, a.c};
-		testFunVV(t, "addVV_g symmetric", addVV_g, arg);
-		testFunVV(t, "addVV symmetric", addVV, arg);
+		arg = argVV{a.z, a.y, a.x, a.c}
+		testFunVV(t, "addVV_g symmetric", addVV_g, arg)
+		testFunVV(t, "addVV symmetric", addVV, arg)
 
-		arg = argVV{a.x, a.z, a.y, a.c};
-		testFunVV(t, "subVV_g", subVV_g, arg);
-		testFunVV(t, "subVV", subVV, arg);
+		arg = argVV{a.x, a.z, a.y, a.c}
+		testFunVV(t, "subVV_g", subVV_g, arg)
+		testFunVV(t, "subVV", subVV, arg)
 
-		arg = argVV{a.y, a.z, a.x, a.c};
-		testFunVV(t, "subVV_g symmetric", subVV_g, arg);
-		testFunVV(t, "subVV symmetric", subVV, arg);
+		arg = argVV{a.y, a.z, a.x, a.c}
+		testFunVV(t, "subVV_g symmetric", subVV_g, arg)
+		testFunVV(t, "subVV symmetric", subVV, arg)
 	}
 }
 
 
 type funVW func(z, x *Word, y Word, n int) (c Word)
 type argVW struct {
-	z, x	[]Word;
-	y	Word;
-	c	Word;
+	z, x []Word
+	y    Word
+	c    Word
 }
 
 var sumVW = []argVW{
@@ -149,13 +149,13 @@ var prodVW = []argVW{
 
 
 func testFunVW(t *testing.T, msg string, f funVW, a argVW) {
-	n := len(a.z);
-	z := make([]Word, n);
-	c := f(addr(z), addr(a.x), a.y, n);
+	n := len(a.z)
+	z := make([]Word, n)
+	c := f(addr(z), addr(a.x), a.y, n)
 	for i, zi := range z {
 		if zi != a.z[i] {
-			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]);
-			break;
+			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i])
+			break
 		}
 	}
 	if c != a.c {
@@ -166,22 +166,22 @@ func testFunVW(t *testing.T, msg string, f funVW, a argVW) {
 
 func TestFunVW(t *testing.T) {
 	for _, a := range sumVW {
-		arg := a;
-		testFunVW(t, "addVW_g", addVW_g, arg);
-		testFunVW(t, "addVW", addVW, arg);
+		arg := a
+		testFunVW(t, "addVW_g", addVW_g, arg)
+		testFunVW(t, "addVW", addVW, arg)
 
-		arg = argVW{a.x, a.z, a.y, a.c};
-		testFunVW(t, "subVW_g", subVW_g, arg);
-		testFunVW(t, "subVW", subVW, arg);
+		arg = argVW{a.x, a.z, a.y, a.c}
+		testFunVW(t, "subVW_g", subVW_g, arg)
+		testFunVW(t, "subVW", subVW, arg)
 	}
 }
 
 
 type funVWW func(z, x *Word, y, r Word, n int) (c Word)
 type argVWW struct {
-	z, x	[]Word;
-	y, r	Word;
-	c	Word;
+	z, x []Word
+	y, r Word
+	c    Word
 }
 
 var prodVWW = []argVWW{
@@ -212,13 +212,13 @@ var prodVWW = []argVWW{
 
 
 func testFunVWW(t *testing.T, msg string, f funVWW, a argVWW) {
-	n := len(a.z);
-	z := make([]Word, n);
-	c := f(addr(z), addr(a.x), a.y, a.r, n);
+	n := len(a.z)
+	z := make([]Word, n)
+	c := f(addr(z), addr(a.x), a.y, a.r, n)
 	for i, zi := range z {
 		if zi != a.z[i] {
-			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]);
-			break;
+			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i])
+			break
 		}
 	}
 	if c != a.c {
@@ -232,21 +232,21 @@ func testFunVWW(t *testing.T, msg string, f funVWW, a argVWW) {
 
 type funWVW func(z *Word, xn Word, x *Word, y Word, n int) (r Word)
 type argWVW struct {
-	z	[]Word;
-	xn	Word;
-	x	[]Word;
-	y	Word;
-	r	Word;
+	z  []Word
+	xn Word
+	x  []Word
+	y  Word
+	r  Word
 }
 
 func testFunWVW(t *testing.T, msg string, f funWVW, a argWVW) {
-	n := len(a.z);
-	z := make([]Word, n);
-	r := f(addr(z), a.xn, addr(a.x), a.y, n);
+	n := len(a.z)
+	z := make([]Word, n)
+	r := f(addr(z), a.xn, addr(a.x), a.y, n)
 	for i, zi := range z {
 		if zi != a.z[i] {
-			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]);
-			break;
+			t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i])
+			break
 		}
 	}
 	if r != a.r {
@@ -257,22 +257,22 @@ func testFunWVW(t *testing.T, msg string, f funWVW, a argWVW) {
 
 func TestFunVWW(t *testing.T) {
 	for _, a := range prodVWW {
-		arg := a;
-		testFunVWW(t, "mulAddVWW_g", mulAddVWW_g, arg);
-		testFunVWW(t, "mulAddVWW", mulAddVWW, arg);
+		arg := a
+		testFunVWW(t, "mulAddVWW_g", mulAddVWW_g, arg)
+		testFunVWW(t, "mulAddVWW", mulAddVWW, arg)
 
 		if a.y != 0 && a.r < a.y {
-			arg := argWVW{a.x, a.c, a.z, a.y, a.r};
-			testFunWVW(t, "divWVW_g", divWVW_g, arg);
-			testFunWVW(t, "divWVW", divWVW, arg);
+			arg := argWVW{a.x, a.c, a.z, a.y, a.r}
+			testFunWVW(t, "divWVW_g", divWVW_g, arg)
+			testFunWVW(t, "divWVW", divWVW, arg)
 		}
 	}
 }
 
 
 type mulWWTest struct {
-	x, y	Word;
-	q, r	Word;
+	x, y Word
+	q, r Word
 }
 
 
@@ -284,7 +284,7 @@ var mulWWTests = []mulWWTest{
 
 func TestMulWW(t *testing.T) {
 	for i, test := range mulWWTests {
-		q, r := mulWW_g(test.x, test.y);
+		q, r := mulWW_g(test.x, test.y)
 		if q != test.q || r != test.r {
 			t.Errorf("#%d got (%x, %x) want (%x, %x)", i, q, r, test.q, test.r)
 		}
@@ -293,8 +293,8 @@ func TestMulWW(t *testing.T) {
 
 
 type mulAddWWWTest struct {
-	x, y, c	Word;
-	q, r	Word;
+	x, y, c Word
+	q, r    Word
 }
 
 
@@ -309,7 +309,7 @@ var mulAddWWWTests = []mulAddWWWTest{
 
 func TestMulAddWWW(t *testing.T) {
 	for i, test := range mulAddWWWTests {
-		q, r := mulAddWWW_g(test.x, test.y, test.c);
+		q, r := mulAddWWW_g(test.x, test.y, test.c)
 		if q != test.q || r != test.r {
 			t.Errorf("#%d got (%x, %x) want (%x, %x)", i, q, r, test.q, test.r)
 		}
diff --git a/src/pkg/big/int.go b/src/pkg/big/int.go
index 22c0eddff..5a0f7c0df 100644
--- a/src/pkg/big/int.go
+++ b/src/pkg/big/int.go
@@ -9,32 +9,32 @@ package big
 // An Int represents a signed multi-precision integer.
 // The zero value for an Int represents the value 0.
 type Int struct {
-	neg	bool;	// sign
-	abs	[]Word;	// absolute value of the integer
+	neg bool   // sign
+	abs []Word // absolute value of the integer
 }
 
 
 // New allocates and returns a new Int set to x.
 func (z *Int) New(x int64) *Int {
-	z.neg = false;
+	z.neg = false
 	if x < 0 {
-		z.neg = true;
-		x = -x;
+		z.neg = true
+		x = -x
 	}
-	z.abs = newN(z.abs, uint64(x));
-	return z;
+	z.abs = newN(z.abs, uint64(x))
+	return z
 }
 
 
 // NewInt allocates and returns a new Int set to x.
-func NewInt(x int64) *Int	{ return new(Int).New(x) }
+func NewInt(x int64) *Int { return new(Int).New(x) }
 
 
 // Set sets z to x.
 func (z *Int) Set(x *Int) *Int {
-	z.neg = x.neg;
-	z.abs = setN(z.abs, x.abs);
-	return z;
+	z.neg = x.neg
+	z.abs = setN(z.abs, x.abs)
+	return z
 }
 
 
@@ -43,23 +43,23 @@ func (z *Int) Add(x, y *Int) *Int {
 	if x.neg == y.neg {
 		// x + y == x + y
 		// (-x) + (-y) == -(x + y)
-		z.neg = x.neg;
-		z.abs = addNN(z.abs, x.abs, y.abs);
+		z.neg = x.neg
+		z.abs = addNN(z.abs, x.abs, y.abs)
 	} else {
 		// x + (-y) == x - y == -(y - x)
 		// (-x) + y == y - x == -(x - y)
 		if cmpNN(x.abs, y.abs) >= 0 {
-			z.neg = x.neg;
-			z.abs = subNN(z.abs, x.abs, y.abs);
+			z.neg = x.neg
+			z.abs = subNN(z.abs, x.abs, y.abs)
 		} else {
-			z.neg = !x.neg;
-			z.abs = subNN(z.abs, y.abs, x.abs);
+			z.neg = !x.neg
+			z.abs = subNN(z.abs, y.abs, x.abs)
 		}
 	}
 	if len(z.abs) == 0 {
-		z.neg = false	// 0 has no sign
+		z.neg = false // 0 has no sign
 	}
-	return z;
+	return z
 }
 
 
@@ -68,23 +68,23 @@ func (z *Int) Sub(x, y *Int) *Int {
 	if x.neg != y.neg {
 		// x - (-y) == x + y
 		// (-x) - y == -(x + y)
-		z.neg = x.neg;
-		z.abs = addNN(z.abs, x.abs, y.abs);
+		z.neg = x.neg
+		z.abs = addNN(z.abs, x.abs, y.abs)
 	} else {
 		// x - y == x - y == -(y - x)
 		// (-x) - (-y) == y - x == -(x - y)
 		if cmpNN(x.abs, y.abs) >= 0 {
-			z.neg = x.neg;
-			z.abs = subNN(z.abs, x.abs, y.abs);
+			z.neg = x.neg
+			z.abs = subNN(z.abs, x.abs, y.abs)
 		} else {
-			z.neg = !x.neg;
-			z.abs = subNN(z.abs, y.abs, x.abs);
+			z.neg = !x.neg
+			z.abs = subNN(z.abs, y.abs, x.abs)
 		}
 	}
 	if len(z.abs) == 0 {
-		z.neg = false	// 0 has no sign
+		z.neg = false // 0 has no sign
 	}
-	return z;
+	return z
 }
 
 
@@ -94,43 +94,43 @@ func (z *Int) Mul(x, y *Int) *Int {
 	// x * (-y) == -(x * y)
 	// (-x) * y == -(x * y)
 	// (-x) * (-y) == x * y
-	z.abs = mulNN(z.abs, x.abs, y.abs);
-	z.neg = len(z.abs) > 0 && x.neg != y.neg;	// 0 has no sign
-	return z;
+	z.abs = mulNN(z.abs, x.abs, y.abs)
+	z.neg = len(z.abs) > 0 && x.neg != y.neg // 0 has no sign
+	return z
 }
 
 
 // Div calculates q = (x-r)/y where 0 <= r < y. The receiver is set to q.
 func (z *Int) Div(x, y *Int) (q, r *Int) {
-	q = z;
-	r = new(Int);
-	div(q, r, x, y);
-	return;
+	q = z
+	r = new(Int)
+	div(q, r, x, y)
+	return
 }
 
 
 // Mod calculates q = (x-r)/y and returns r.
 func (z *Int) Mod(x, y *Int) (r *Int) {
-	q := new(Int);
-	r = z;
-	div(q, r, x, y);
-	return;
+	q := new(Int)
+	r = z
+	div(q, r, x, y)
+	return
 }
 
 
 func div(q, r, x, y *Int) {
-	q.neg = x.neg != y.neg;
-	r.neg = x.neg;
-	q.abs, r.abs = divNN(q.abs, r.abs, x.abs, y.abs);
-	return;
+	q.neg = x.neg != y.neg
+	r.neg = x.neg
+	q.abs, r.abs = divNN(q.abs, r.abs, x.abs, y.abs)
+	return
 }
 
 
 // Neg computes z = -x.
 func (z *Int) Neg(x *Int) *Int {
-	z.abs = setN(z.abs, x.abs);
-	z.neg = len(z.abs) > 0 && !x.neg;	// 0 has no sign
-	return z;
+	z.abs = setN(z.abs, x.abs)
+	z.neg = len(z.abs) > 0 && !x.neg // 0 has no sign
+	return z
 }
 
 
@@ -147,7 +147,7 @@ func (x *Int) Cmp(y *Int) (r int) {
 	// (-x) cmp (-y) == -(x cmp y)
 	switch {
 	case x.neg == y.neg:
-		r = cmpNN(x.abs, y.abs);
+		r = cmpNN(x.abs, y.abs)
 		if x.neg {
 			r = -r
 		}
@@ -156,16 +156,16 @@ func (x *Int) Cmp(y *Int) (r int) {
 	default:
 		r = 1
 	}
-	return;
+	return
 }
 
 
 func (z *Int) String() string {
-	s := "";
+	s := ""
 	if z.neg {
 		s = "-"
 	}
-	return s + stringN(z.abs, 10);
+	return s + stringN(z.abs, 10)
 }
 
 
@@ -173,7 +173,7 @@ func (z *Int) String() string {
 // If base is 0 then SetString attempts to detect the base by at the prefix of
 // s. '0x' implies base 16, '0' implies base 8. Otherwise base 10 is assumed.
 func (z *Int) SetString(s string, base int) (*Int, bool) {
-	var scanned int;
+	var scanned int
 
 	if base == 1 || base > 16 {
 		goto Error
@@ -184,83 +184,83 @@ func (z *Int) SetString(s string, base int) (*Int, bool) {
 	}
 
 	if s[0] == '-' {
-		z.neg = true;
-		s = s[1:];
+		z.neg = true
+		s = s[1:]
 	} else {
 		z.neg = false
 	}
 
-	z.abs, _, scanned = scanN(z.abs, s, base);
+	z.abs, _, scanned = scanN(z.abs, s, base)
 	if scanned != len(s) {
 		goto Error
 	}
 
-	return z, true;
+	return z, true
 
 Error:
-	z.neg = false;
-	z.abs = nil;
-	return nil, false;
+	z.neg = false
+	z.abs = nil
+	return nil, false
 }
 
 
 // SetBytes interprets b as the bytes of a big-endian, unsigned integer and
 // sets x to that value.
 func (z *Int) SetBytes(b []byte) *Int {
-	s := int(_S);
-	z.abs = makeN(z.abs, (len(b)+s-1)/s, false);
-	z.neg = false;
+	s := int(_S)
+	z.abs = makeN(z.abs, (len(b)+s-1)/s, false)
+	z.neg = false
 
-	j := 0;
+	j := 0
 	for len(b) >= s {
-		var w Word;
+		var w Word
 
 		for i := s; i > 0; i-- {
-			w <<= 8;
-			w |= Word(b[len(b)-i]);
+			w <<= 8
+			w |= Word(b[len(b)-i])
 		}
 
-		z.abs[j] = w;
-		j++;
-		b = b[0 : len(b)-s];
+		z.abs[j] = w
+		j++
+		b = b[0 : len(b)-s]
 	}
 
 	if len(b) > 0 {
-		var w Word;
+		var w Word
 
 		for i := len(b); i > 0; i-- {
-			w <<= 8;
-			w |= Word(b[len(b)-i]);
+			w <<= 8
+			w |= Word(b[len(b)-i])
 		}
 
-		z.abs[j] = w;
+		z.abs[j] = w
 	}
 
-	z.abs = normN(z.abs);
+	z.abs = normN(z.abs)
 
-	return z;
+	return z
 }
 
 
 // Bytes returns the absolute value of x as a big-endian byte array.
 func (z *Int) Bytes() []byte {
-	s := int(_S);
-	b := make([]byte, len(z.abs)*s);
+	s := int(_S)
+	b := make([]byte, len(z.abs)*s)
 
 	for i, w := range z.abs {
-		wordBytes := b[(len(z.abs)-i-1)*s : (len(z.abs)-i)*s];
+		wordBytes := b[(len(z.abs)-i-1)*s : (len(z.abs)-i)*s]
 		for j := s - 1; j >= 0; j-- {
-			wordBytes[j] = byte(w);
-			w >>= 8;
+			wordBytes[j] = byte(w)
+			w >>= 8
 		}
 	}
 
-	i := 0;
+	i := 0
 	for i < len(b) && b[i] == 0 {
 		i++
 	}
 
-	return b[i:];
+	return b[i:]
 }
 
 
@@ -271,7 +271,7 @@ func (z *Int) Len() int {
 		return 0
 	}
 
-	return len(z.abs)*_W - int(leadingZeros(z.abs[len(z.abs)-1]));
+	return len(z.abs)*_W - int(leadingZeros(z.abs[len(z.abs)-1]))
 }
 
 
@@ -279,19 +279,19 @@ func (z *Int) Len() int {
 // See Knuth, volume 2, section 4.6.3.
 func (z *Int) Exp(x, y, m *Int) *Int {
 	if y.neg || len(y.abs) == 0 {
-		z.New(1);
-		z.neg = x.neg;
-		return z;
+		z.New(1)
+		z.neg = x.neg
+		return z
 	}
 
-	var mWords []Word;
+	var mWords []Word
 	if m != nil {
 		mWords = m.abs
 	}
 
-	z.abs = expNNN(z.abs, x.abs, y.abs, mWords);
-	z.neg = x.neg && y.abs[0]&1 == 1;
-	return z;
+	z.abs = expNNN(z.abs, x.abs, y.abs, mWords)
+	z.neg = x.neg && y.abs[0]&1 == 1
+	return z
 }
 
 
@@ -301,44 +301,44 @@ func (z *Int) Exp(x, y, m *Int) *Int {
 // If either a or b is not positive, GcdInt sets d = x = y = 0.
 func GcdInt(d, x, y, a, b *Int) {
 	if a.neg || b.neg {
-		d.New(0);
+		d.New(0)
 		if x != nil {
 			x.New(0)
 		}
 		if y != nil {
 			y.New(0)
 		}
-		return;
+		return
 	}
 
-	A := new(Int).Set(a);
-	B := new(Int).Set(b);
+	A := new(Int).Set(a)
+	B := new(Int).Set(b)
 
-	X := new(Int);
-	Y := new(Int).New(1);
+	X := new(Int)
+	Y := new(Int).New(1)
 
-	lastX := new(Int).New(1);
-	lastY := new(Int);
+	lastX := new(Int).New(1)
+	lastY := new(Int)
 
-	q := new(Int);
-	temp := new(Int);
+	q := new(Int)
+	temp := new(Int)
 
 	for len(B.abs) > 0 {
-		q, r := q.Div(A, B);
+		q, r := q.Div(A, B)
 
-		A, B = B, r;
+		A, B = B, r
 
-		temp.Set(X);
-		X.Mul(X, q);
-		X.neg = !X.neg;
-		X.Add(X, lastX);
-		lastX.Set(temp);
+		temp.Set(X)
+		X.Mul(X, q)
+		X.neg = !X.neg
+		X.Add(X, lastX)
+		lastX.Set(temp)
 
-		temp.Set(Y);
-		Y.Mul(Y, q);
-		Y.neg = !Y.neg;
-		Y.Add(Y, lastY);
-		lastY.Set(temp);
+		temp.Set(Y)
+		Y.Mul(Y, q)
+		Y.neg = !Y.neg
+		Y.Add(Y, lastY)
+		lastY.Set(temp)
 	}
 
 	if x != nil {
@@ -349,22 +349,22 @@ func GcdInt(d, x, y, a, b *Int) {
 		*y = *lastY
 	}
 
-	*d = *A;
+	*d = *A
 }
 
 
 // ProbablyPrime performs n Miller-Rabin tests to check whether z is prime.
 // If it returns true, z is prime with probability 1 - 1/4^n.
 // If it returns false, z is not prime.
-func ProbablyPrime(z *Int, reps int) bool	{ return !z.neg && probablyPrime(z.abs, reps) }
+func ProbablyPrime(z *Int, reps int) bool { return !z.neg && probablyPrime(z.abs, reps) }
 
 
 // Rsh sets z = x >> s and returns z.
 func (z *Int) Rsh(x *Int, n int) *Int {
-	removedWords := n / _W;
-	z.abs = makeN(z.abs, len(x.abs)-removedWords, false);
-	z.neg = x.neg;
-	shiftRight(z.abs, x.abs[removedWords:], n%_W);
-	z.abs = normN(z.abs);
-	return z;
+	removedWords := n / _W
+	z.abs = makeN(z.abs, len(x.abs)-removedWords, false)
+	z.neg = x.neg
+	shiftRight(z.abs, x.abs[removedWords:], n%_W)
+	z.abs = normN(z.abs)
+	return z
 }
diff --git a/src/pkg/big/int_test.go b/src/pkg/big/int_test.go
index e5ed221af..b2c33fcc4 100644
--- a/src/pkg/big/int_test.go
+++ b/src/pkg/big/int_test.go
@@ -5,21 +5,21 @@
 package big
 
 import (
-	"bytes";
-	"encoding/hex";
-	"testing";
-	"testing/quick";
+	"bytes"
+	"encoding/hex"
+	"testing"
+	"testing/quick"
 )
 
 func newZ(x int64) *Int {
-	var z Int;
-	return z.New(x);
+	var z Int
+	return z.New(x)
 }
 
 
 type funZZ func(z, x, y *Int) *Int
 type argZZ struct {
-	z, x, y *Int;
+	z, x, y *Int
 }
 
 
@@ -44,8 +44,8 @@ var prodZZ = []argZZ{
 
 func TestSetZ(t *testing.T) {
 	for _, a := range sumZZ {
-		var z Int;
-		z.Set(a.z);
+		var z Int
+		z.Set(a.z)
 		if (&z).Cmp(a.z) != 0 {
 			t.Errorf("got z = %v; want %v", z, a.z)
 		}
@@ -54,8 +54,8 @@ func TestSetZ(t *testing.T) {
 
 
 func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) {
-	var z Int;
-	f(&z, a.x, a.y);
+	var z Int
+	f(&z, a.x, a.y)
 	if (&z).Cmp(a.z) != 0 {
 		t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, &z, a.z)
 	}
@@ -63,32 +63,32 @@ func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) {
 
 
 func TestSumZZ(t *testing.T) {
-	AddZZ := func(z, x, y *Int) *Int { return z.Add(x, y) };
-	SubZZ := func(z, x, y *Int) *Int { return z.Sub(x, y) };
+	AddZZ := func(z, x, y *Int) *Int { return z.Add(x, y) }
+	SubZZ := func(z, x, y *Int) *Int { return z.Sub(x, y) }
 	for _, a := range sumZZ {
-		arg := a;
-		testFunZZ(t, "AddZZ", AddZZ, arg);
+		arg := a
+		testFunZZ(t, "AddZZ", AddZZ, arg)
 
-		arg = argZZ{a.z, a.y, a.x};
-		testFunZZ(t, "AddZZ symmetric", AddZZ, arg);
+		arg = argZZ{a.z, a.y, a.x}
+		testFunZZ(t, "AddZZ symmetric", AddZZ, arg)
 
-		arg = argZZ{a.x, a.z, a.y};
-		testFunZZ(t, "SubZZ", SubZZ, arg);
+		arg = argZZ{a.x, a.z, a.y}
+		testFunZZ(t, "SubZZ", SubZZ, arg)
 
-		arg = argZZ{a.y, a.z, a.x};
-		testFunZZ(t, "SubZZ symmetric", SubZZ, arg);
+		arg = argZZ{a.y, a.z, a.x}
+		testFunZZ(t, "SubZZ symmetric", SubZZ, arg)
 	}
 }
 
 
 func TestProdZZ(t *testing.T) {
-	MulZZ := func(z, x, y *Int) *Int { return z.Mul(x, y) };
+	MulZZ := func(z, x, y *Int) *Int { return z.Mul(x, y) }
 	for _, a := range prodZZ {
-		arg := a;
-		testFunZZ(t, "MulZZ", MulZZ, arg);
+		arg := a
+		testFunZZ(t, "MulZZ", MulZZ, arg)
 
-		arg = argZZ{a.z, a.y, a.x};
-		testFunZZ(t, "MulZZ symmetric", MulZZ, arg);
+		arg = argZZ{a.z, a.y, a.x}
+		testFunZZ(t, "MulZZ symmetric", MulZZ, arg)
 	}
 }
 
@@ -106,20 +106,20 @@ var facts = map[int]string{
 
 
 func fact(n int) *Int {
-	var z Int;
-	z.New(1);
+	var z Int
+	z.New(1)
 	for i := 2; i <= n; i++ {
-		var t Int;
-		t.New(int64(i));
-		z.Mul(&z, &t);
+		var t Int
+		t.New(int64(i))
+		z.Mul(&z, &t)
 	}
-	return &z;
+	return &z
 }
 
 
 func TestFact(t *testing.T) {
 	for n, s := range facts {
-		f := fact(n).String();
+		f := fact(n).String()
 		if f != s {
 			t.Errorf("%d! = %s; want %s", n, f, s)
 		}
@@ -128,10 +128,10 @@ func TestFact(t *testing.T) {
 
 
 type fromStringTest struct {
-	in	string;
-	base	int;
-	out	int64;
-	ok	bool;
+	in   string
+	base int
+	out  int64
+	ok   bool
 }
 
 
@@ -156,10 +156,10 @@ var fromStringTests = []fromStringTest{
 
 func TestSetString(t *testing.T) {
 	for i, test := range fromStringTests {
-		n, ok := new(Int).SetString(test.in, test.base);
+		n, ok := new(Int).SetString(test.in, test.base)
 		if ok != test.ok {
-			t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok);
-			continue;
+			t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok)
+			continue
 		}
 		if !ok {
 			continue
@@ -173,8 +173,8 @@ func TestSetString(t *testing.T) {
 
 
 type divSignsTest struct {
-	x, y	int64;
-	q, r	int64;
+	x, y int64
+	q, r int64
 }
 
 
@@ -190,11 +190,11 @@ var divSignsTests = []divSignsTest{
 
 func TestDivSigns(t *testing.T) {
 	for i, test := range divSignsTests {
-		x := new(Int).New(test.x);
-		y := new(Int).New(test.y);
-		q, r := new(Int).Div(x, y);
-		expectedQ := new(Int).New(test.q);
-		expectedR := new(Int).New(test.r);
+		x := new(Int).New(test.x)
+		y := new(Int).New(test.y)
+		q, r := new(Int).Div(x, y)
+		expectedQ := new(Int).New(test.q)
+		expectedR := new(Int).New(test.r)
 
 		if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 {
 			t.Errorf("#%d: got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR)
@@ -204,8 +204,8 @@ func TestDivSigns(t *testing.T) {
 
 
 func checkSetBytes(b []byte) bool {
-	hex1 := hex.EncodeToString(new(Int).SetBytes(b).Bytes());
-	hex2 := hex.EncodeToString(b);
+	hex1 := hex.EncodeToString(new(Int).SetBytes(b).Bytes())
+	hex2 := hex.EncodeToString(b)
 
 	for len(hex1) < len(hex2) {
 		hex1 = "0" + hex1
@@ -215,12 +215,12 @@ func checkSetBytes(b []byte) bool {
 		hex2 = "0" + hex2
 	}
 
-	return hex1 == hex2;
+	return hex1 == hex2
 }
 
 
 func TestSetBytes(t *testing.T) {
-	err := quick.Check(checkSetBytes, nil);
+	err := quick.Check(checkSetBytes, nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -228,13 +228,13 @@ func TestSetBytes(t *testing.T) {
 
 
 func checkBytes(b []byte) bool {
-	b2 := new(Int).SetBytes(b).Bytes();
-	return bytes.Compare(b, b2) == 0;
+	b2 := new(Int).SetBytes(b).Bytes()
+	return bytes.Compare(b, b2) == 0
 }
 
 
 func TestBytes(t *testing.T) {
-	err := quick.Check(checkSetBytes, nil);
+	err := quick.Check(checkSetBytes, nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -242,30 +242,30 @@ func TestBytes(t *testing.T) {
 
 
 func checkDiv(x, y []byte) bool {
-	u := new(Int).SetBytes(x);
-	v := new(Int).SetBytes(y);
+	u := new(Int).SetBytes(x)
+	v := new(Int).SetBytes(y)
 
 	if len(v.abs) == 0 {
 		return true
 	}
 
-	q, r := new(Int).Div(u, v);
+	q, r := new(Int).Div(u, v)
 
 	if r.Cmp(v) >= 0 {
 		return false
 	}
 
-	uprime := new(Int).Set(q);
-	uprime.Mul(uprime, v);
-	uprime.Add(uprime, r);
+	uprime := new(Int).Set(q)
+	uprime.Mul(uprime, v)
+	uprime.Add(uprime, r)
 
-	return uprime.Cmp(u) == 0;
+	return uprime.Cmp(u) == 0
 }
 
 
 type divTest struct {
-	x, y	string;
-	q, r	string;
+	x, y string
+	q, r string
 }
 
 
@@ -286,18 +286,18 @@ var divTests = []divTest{
 
 
 func TestDiv(t *testing.T) {
-	err := quick.Check(checkDiv, nil);
+	err := quick.Check(checkDiv, nil)
 	if err != nil {
 		t.Error(err)
 	}
 
 	for i, test := range divTests {
-		x, _ := new(Int).SetString(test.x, 10);
-		y, _ := new(Int).SetString(test.y, 10);
-		expectedQ, _ := new(Int).SetString(test.q, 10);
-		expectedR, _ := new(Int).SetString(test.r, 10);
+		x, _ := new(Int).SetString(test.x, 10)
+		y, _ := new(Int).SetString(test.y, 10)
+		expectedQ, _ := new(Int).SetString(test.q, 10)
+		expectedR, _ := new(Int).SetString(test.r, 10)
 
-		q, r := new(Int).Div(x, y);
+		q, r := new(Int).Div(x, y)
 
 		if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 {
 			t.Errorf("#%d got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR)
@@ -310,14 +310,14 @@ func TestDivStepD6(t *testing.T) {
 	// See Knuth, Volume 2, section 4.3.1, exercise 21. This code exercises
 	// a code path which only triggers 1 in 10^{-19} cases.
 
-	u := &Int{false, []Word{0, 0, 1 + 1<<(_W-1), _M ^ (1 << (_W - 1))}};
-	v := &Int{false, []Word{5, 2 + 1<<(_W-1), 1 << (_W - 1)}};
+	u := &Int{false, []Word{0, 0, 1 + 1<<(_W-1), _M ^ (1 << (_W - 1))}}
+	v := &Int{false, []Word{5, 2 + 1<<(_W-1), 1 << (_W - 1)}}
 
-	q, r := new(Int).Div(u, v);
-	const expectedQ64 = "18446744073709551613";
-	const expectedR64 = "3138550867693340382088035895064302439801311770021610913807";
-	const expectedQ32 = "4294967293";
-	const expectedR32 = "39614081266355540837921718287";
+	q, r := new(Int).Div(u, v)
+	const expectedQ64 = "18446744073709551613"
+	const expectedR64 = "3138550867693340382088035895064302439801311770021610913807"
+	const expectedQ32 = "4294967293"
+	const expectedR32 = "39614081266355540837921718287"
 	if q.String() != expectedQ64 && q.String() != expectedQ32 ||
 		r.String() != expectedR64 && r.String() != expectedR32 {
 		t.Errorf("got (%s, %s) want (%s, %s) or (%s, %s)", q, r, expectedQ64, expectedR64, expectedQ32, expectedR32)
@@ -326,8 +326,8 @@ func TestDivStepD6(t *testing.T) {
 
 
 type lenTest struct {
-	in	string;
-	out	int;
+	in  string
+	out int
 }
 
 
@@ -346,10 +346,10 @@ var lenTests = []lenTest{
 
 func TestLen(t *testing.T) {
 	for i, test := range lenTests {
-		n, ok := new(Int).SetString(test.in, 0);
+		n, ok := new(Int).SetString(test.in, 0)
 		if !ok {
-			t.Errorf("#%d test input invalid: %s", i, test.in);
-			continue;
+			t.Errorf("#%d test input invalid: %s", i, test.in)
+			continue
 		}
 
 		if n.Len() != test.out {
@@ -360,8 +360,8 @@ func TestLen(t *testing.T) {
 
 
 type expTest struct {
-	x, y, m	string;
-	out	string;
+	x, y, m string
+	out     string
 }
 
 
@@ -388,12 +388,12 @@ var expTests = []expTest{
 
 func TestExp(t *testing.T) {
 	for i, test := range expTests {
-		x, ok1 := new(Int).SetString(test.x, 0);
-		y, ok2 := new(Int).SetString(test.y, 0);
-		out, ok3 := new(Int).SetString(test.out, 0);
+		x, ok1 := new(Int).SetString(test.x, 0)
+		y, ok2 := new(Int).SetString(test.y, 0)
+		out, ok3 := new(Int).SetString(test.out, 0)
 
-		var ok4 bool;
-		var m *Int;
+		var ok4 bool
+		var m *Int
 
 		if len(test.m) == 0 {
 			m, ok4 = nil, true
@@ -402,11 +402,11 @@ func TestExp(t *testing.T) {
 		}
 
 		if !ok1 || !ok2 || !ok3 || !ok4 {
-			t.Errorf("#%d error in input", i);
-			continue;
+			t.Errorf("#%d error in input", i)
+			continue
 		}
 
-		z := new(Int).Exp(x, y, m);
+		z := new(Int).Exp(x, y, m)
 		if z.Cmp(out) != 0 {
 			t.Errorf("#%d got %s want %s", i, z, out)
 		}
@@ -415,25 +415,25 @@ func TestExp(t *testing.T) {
 
 
 func checkGcd(aBytes, bBytes []byte) bool {
-	a := new(Int).SetBytes(aBytes);
-	b := new(Int).SetBytes(bBytes);
+	a := new(Int).SetBytes(aBytes)
+	b := new(Int).SetBytes(bBytes)
 
-	x := new(Int);
-	y := new(Int);
-	d := new(Int);
+	x := new(Int)
+	y := new(Int)
+	d := new(Int)
 
-	GcdInt(d, x, y, a, b);
-	x.Mul(x, a);
-	y.Mul(y, b);
-	x.Add(x, y);
+	GcdInt(d, x, y, a, b)
+	x.Mul(x, a)
+	y.Mul(y, b)
+	x.Add(x, y)
 
-	return x.Cmp(d) == 0;
+	return x.Cmp(d) == 0
 }
 
 
 type gcdTest struct {
-	a, b	int64;
-	d, x, y	int64;
+	a, b    int64
+	d, x, y int64
 }
 
 
@@ -444,18 +444,18 @@ var gcdTests = []gcdTest{
 
 func TestGcd(t *testing.T) {
 	for i, test := range gcdTests {
-		a := new(Int).New(test.a);
-		b := new(Int).New(test.b);
+		a := new(Int).New(test.a)
+		b := new(Int).New(test.b)
 
-		x := new(Int);
-		y := new(Int);
-		d := new(Int);
+		x := new(Int)
+		y := new(Int)
+		d := new(Int)
 
-		expectedX := new(Int).New(test.x);
-		expectedY := new(Int).New(test.y);
-		expectedD := new(Int).New(test.d);
+		expectedX := new(Int).New(test.x)
+		expectedY := new(Int).New(test.y)
+		expectedD := new(Int).New(test.d)
 
-		GcdInt(d, x, y, a, b);
+		GcdInt(d, x, y, a, b)
 
 		if expectedX.Cmp(x) != 0 ||
 			expectedY.Cmp(y) != 0 ||
@@ -464,7 +464,7 @@ func TestGcd(t *testing.T) {
 		}
 	}
 
-	quick.Check(checkGcd, nil);
+	quick.Check(checkGcd, nil)
 }
 
 
@@ -494,14 +494,14 @@ var composites = []string{
 
 func TestProbablyPrime(t *testing.T) {
 	for i, s := range primes {
-		p, _ := new(Int).SetString(s, 10);
+		p, _ := new(Int).SetString(s, 10)
 		if !ProbablyPrime(p, 20) {
 			t.Errorf("#%d prime found to be non-prime", i)
 		}
 	}
 
 	for i, s := range composites {
-		c, _ := new(Int).SetString(s, 10);
+		c, _ := new(Int).SetString(s, 10)
 		if ProbablyPrime(c, 20) {
 			t.Errorf("#%d composite found to be prime", i)
 		}
@@ -510,9 +510,9 @@ func TestProbablyPrime(t *testing.T) {
 
 
 type rshTest struct {
-	in	string;
-	shift	int;
-	out	string;
+	in    string
+	shift int
+	out   string
 }
 
 
@@ -540,9 +540,9 @@ var rshTests = []rshTest{
 
 func TestRsh(t *testing.T) {
 	for i, test := range rshTests {
-		in, _ := new(Int).SetString(test.in, 10);
-		expected, _ := new(Int).SetString(test.out, 10);
-		out := new(Int).Rsh(in, test.shift);
+		in, _ := new(Int).SetString(test.in, 10)
+		expected, _ := new(Int).SetString(test.out, 10)
+		out := new(Int).Rsh(in, test.shift)
 
 		if out.Cmp(expected) != 0 {
 			t.Errorf("#%d got %s want %s", i, out, expected)
diff --git a/src/pkg/big/nat.go b/src/pkg/big/nat.go
index 0b7c18428..877bc9811 100644
--- a/src/pkg/big/nat.go
+++ b/src/pkg/big/nat.go
@@ -38,31 +38,31 @@ import "rand"
 //           - decide if type 'nat' should be exported
 
 func normN(z []Word) []Word {
-	i := len(z);
+	i := len(z)
 	for i > 0 && z[i-1] == 0 {
 		i--
 	}
-	z = z[0:i];
-	return z;
+	z = z[0:i]
+	return z
 }
 
 
 func makeN(z []Word, m int, clear bool) []Word {
 	if len(z) > m {
-		z = z[0:m];	// reuse z - has at least one extra word for a carry, if any
+		z = z[0:m] // reuse z - has at least one extra word for a carry, if any
 		if clear {
 			for i := range z {
 				z[i] = 0
 			}
 		}
-		return z;
+		return z
 	}
 
-	c := 4;	// minimum capacity
+	c := 4 // minimum capacity
 	if m > c {
 		c = m
 	}
-	return make([]Word, m, c+1);	// +1: extra word for a carry, if any
+	return make([]Word, m, c+1) // +1: extra word for a carry, if any
 }
 
 
@@ -73,40 +73,40 @@ func newN(z []Word, x uint64) []Word {
 
 	// single-digit values
 	if x == uint64(Word(x)) {
-		z = makeN(z, 1, false);
-		z[0] = Word(x);
-		return z;
+		z = makeN(z, 1, false)
+		z[0] = Word(x)
+		return z
 	}
 
 	// compute number of words n required to represent x
-	n := 0;
+	n := 0
 	for t := x; t > 0; t >>= _W {
 		n++
 	}
 
 	// split x into n words
-	z = makeN(z, n, false);
+	z = makeN(z, n, false)
 	for i := 0; i < n; i++ {
-		z[i] = Word(x & _M);
-		x >>= _W;
+		z[i] = Word(x & _M)
+		x >>= _W
 	}
 
-	return z;
+	return z
 }
 
 
 func setN(z, x []Word) []Word {
-	z = makeN(z, len(x), false);
+	z = makeN(z, len(x), false)
 	for i, d := range x {
 		z[i] = d
 	}
-	return z;
+	return z
 }
 
 
 func addNN(z, x, y []Word) []Word {
-	m := len(x);
-	n := len(y);
+	m := len(x)
+	n := len(y)
 
 	switch {
 	case m < n:
@@ -120,23 +120,23 @@ func addNN(z, x, y []Word) []Word {
 	}
 	// m > 0
 
-	z = makeN(z, m, false);
-	c := addVV(&z[0], &x[0], &y[0], n);
+	z = makeN(z, m, false)
+	c := addVV(&z[0], &x[0], &y[0], n)
 	if m > n {
 		c = addVW(&z[n], &x[n], c, m-n)
 	}
 	if c > 0 {
-		z = z[0 : m+1];
-		z[m] = c;
+		z = z[0 : m+1]
+		z[m] = c
 	}
 
-	return z;
+	return z
 }
 
 
 func subNN(z, x, y []Word) []Word {
-	m := len(x);
-	n := len(y);
+	m := len(x)
+	n := len(y)
 
 	switch {
 	case m < n:
@@ -150,23 +150,23 @@ func subNN(z, x, y []Word) []Word {
 	}
 	// m > 0
 
-	z = makeN(z, m, false);
-	c := subVV(&z[0], &x[0], &y[0], n);
+	z = makeN(z, m, false)
+	c := subVV(&z[0], &x[0], &y[0], n)
 	if m > n {
 		c = subVW(&z[n], &x[n], c, m-n)
 	}
 	if c != 0 {
 		panic("underflow")
 	}
-	z = normN(z);
+	z = normN(z)
 
-	return z;
+	return z
 }
 
 
 func cmpNN(x, y []Word) (r int) {
-	m := len(x);
-	n := len(y);
+	m := len(x)
+	n := len(y)
 	if m != n || m == 0 {
 		switch {
 		case m < n:
@@ -174,10 +174,10 @@ func cmpNN(x, y []Word) (r int) {
 		case m > n:
 			r = 1
 		}
-		return;
+		return
 	}
 
-	i := m - 1;
+	i := m - 1
 	for i > 0 && x[i] == y[i] {
 		i--
 	}
@@ -188,31 +188,31 @@ func cmpNN(x, y []Word) (r int) {
 	case x[i] > y[i]:
 		r = 1
 	}
-	return;
+	return
 }
 
 
 func mulAddNWW(z, x []Word, y, r Word) []Word {
-	m := len(x);
+	m := len(x)
 	if m == 0 || y == 0 {
-		return newN(z, uint64(r))	// result is r
+		return newN(z, uint64(r)) // result is r
 	}
 	// m > 0
 
-	z = makeN(z, m, false);
-	c := mulAddVWW(&z[0], &x[0], y, r, m);
+	z = makeN(z, m, false)
+	c := mulAddVWW(&z[0], &x[0], y, r, m)
 	if c > 0 {
-		z = z[0 : m+1];
-		z[m] = c;
+		z = z[0 : m+1]
+		z[m] = c
 	}
 
-	return z;
+	return z
 }
 
 
 func mulNN(z, x, y []Word) []Word {
-	m := len(x);
-	n := len(y);
+	m := len(x)
+	n := len(y)
 
 	switch {
 	case m < n:
@@ -224,39 +224,39 @@ func mulNN(z, x, y []Word) []Word {
 	}
 	// m >= n && m > 1 && n > 1
 
-	z = makeN(z, m+n, true);
+	z = makeN(z, m+n, true)
 	if &z[0] == &x[0] || &z[0] == &y[0] {
-		z = makeN(nil, m+n, true)	// z is an alias for x or y - cannot reuse
+		z = makeN(nil, m+n, true) // z is an alias for x or y - cannot reuse
 	}
 	for i := 0; i < n; i++ {
 		if f := y[i]; f != 0 {
 			z[m+i] = addMulVVW(&z[i], &x[0], f, m)
 		}
 	}
-	z = normN(z);
+	z = normN(z)
 
-	return z;
+	return z
 }
 
 
 // q = (x-r)/y, with 0 <= r < y
 func divNW(z, x []Word, y Word) (q []Word, r Word) {
-	m := len(x);
+	m := len(x)
 	switch {
 	case y == 0:
 		panic("division by zero")
 	case y == 1:
-		q = setN(z, x);	// result is x
-		return;
+		q = setN(z, x) // result is x
+		return
 	case m == 0:
-		q = setN(z, nil);	// result is 0
-		return;
+		q = setN(z, nil) // result is 0
+		return
 	}
 	// m > 0
-	z = makeN(z, m, false);
-	r = divWVW(&z[0], 0, &x[0], y, m);
-	q = normN(z);
-	return;
+	z = makeN(z, m, false)
+	r = divWVW(&z[0], 0, &x[0], y, m)
+	q = normN(z)
+	return
 }
 
 
@@ -266,25 +266,25 @@ func divNN(z, z2, u, v []Word) (q, r []Word) {
 	}
 
 	if cmpNN(u, v) < 0 {
-		q = makeN(z, 0, false);
-		r = setN(z2, u);
-		return;
+		q = makeN(z, 0, false)
+		r = setN(z2, u)
+		return
 	}
 
 	if len(v) == 1 {
-		var rprime Word;
-		q, rprime = divNW(z, u, v[0]);
+		var rprime Word
+		q, rprime = divNW(z, u, v[0])
 		if rprime > 0 {
-			r = makeN(z2, 1, false);
-			r[0] = rprime;
+			r = makeN(z2, 1, false)
+			r[0] = rprime
 		} else {
 			r = makeN(z2, 0, false)
 		}
-		return;
+		return
 	}
 
-	q, r = divLargeNN(z, z2, u, v);
-	return;
+	q, r = divLargeNN(z, z2, u, v)
+	return
 }
 
 
@@ -294,63 +294,63 @@ func divNN(z, z2, u, v []Word) (q, r []Word) {
 //    len(v) >= 2
 //    len(uIn) >= len(v)
 func divLargeNN(z, z2, uIn, v []Word) (q, r []Word) {
-	n := len(v);
-	m := len(uIn) - len(v);
+	n := len(v)
+	m := len(uIn) - len(v)
 
-	u := makeN(z2, len(uIn)+1, false);
-	qhatv := make([]Word, len(v)+1);
-	q = makeN(z, m+1, false);
+	u := makeN(z2, len(uIn)+1, false)
+	qhatv := make([]Word, len(v)+1)
+	q = makeN(z, m+1, false)
 
 	// D1.
-	shift := leadingZeroBits(v[n-1]);
-	shiftLeft(v, v, shift);
-	shiftLeft(u, uIn, shift);
-	u[len(uIn)] = uIn[len(uIn)-1] >> (_W - uint(shift));
+	shift := leadingZeroBits(v[n-1])
+	shiftLeft(v, v, shift)
+	shiftLeft(u, uIn, shift)
+	u[len(uIn)] = uIn[len(uIn)-1] >> (_W - uint(shift))
 
 	// D2.
 	for j := m; j >= 0; j-- {
 		// D3.
-		var qhat Word;
+		var qhat Word
 		if u[j+n] == v[n-1] {
 			qhat = _B - 1
 		} else {
-			var rhat Word;
-			qhat, rhat = divWW_g(u[j+n], u[j+n-1], v[n-1]);
+			var rhat Word
+			qhat, rhat = divWW_g(u[j+n], u[j+n-1], v[n-1])
 
 			// x1 | x2 = q̂v_{n-2}
-			x1, x2 := mulWW_g(qhat, v[n-2]);
+			x1, x2 := mulWW_g(qhat, v[n-2])
 			// test if q̂v_{n-2} > br̂ + u_{j+n-2}
 			for greaterThan(x1, x2, rhat, u[j+n-2]) {
-				qhat--;
-				prevRhat := rhat;
-				rhat += v[n-1];
+				qhat--
+				prevRhat := rhat
+				rhat += v[n-1]
 				// v[n-1] >= 0, so this tests for overflow.
 				if rhat < prevRhat {
 					break
 				}
-				x1, x2 = mulWW_g(qhat, v[n-2]);
+				x1, x2 = mulWW_g(qhat, v[n-2])
 			}
 		}
 
 		// D4.
-		qhatv[len(v)] = mulAddVWW(&qhatv[0], &v[0], qhat, 0, len(v));
+		qhatv[len(v)] = mulAddVWW(&qhatv[0], &v[0], qhat, 0, len(v))
 
-		c := subVV(&u[j], &u[j], &qhatv[0], len(qhatv));
+		c := subVV(&u[j], &u[j], &qhatv[0], len(qhatv))
 		if c != 0 {
-			c := addVV(&u[j], &u[j], &v[0], len(v));
-			u[j+len(v)] += c;
-			qhat--;
+			c := addVV(&u[j], &u[j], &v[0], len(v))
+			u[j+len(v)] += c
+			qhat--
 		}
 
-		q[j] = qhat;
+		q[j] = qhat
 	}
 
-	q = normN(q);
-	shiftRight(u, u, shift);
-	shiftRight(v, v, shift);
-	r = normN(u);
+	q = normN(q)
+	shiftRight(u, u, shift)
+	shiftRight(v, v, shift)
+	r = normN(u)
 
-	return q, r;
+	return q, r
 }
 
 
@@ -358,11 +358,11 @@ func divLargeNN(z, z2, uIn, v []Word) (q, r []Word) {
 // The result is the integer n for which 2^n <= x < 2^(n+1).
 // If x == 0, the result is -1.
 func log2(x Word) int {
-	n := 0;
+	n := 0
 	for ; x > 0; x >>= 1 {
 		n++
 	}
-	return n - 1;
+	return n - 1
 }
 
 
@@ -370,16 +370,16 @@ func log2(x Word) int {
 // The result is the integer n for which 2^n <= x < 2^(n+1).
 // If x == 0, the result is -1.
 func log2N(x []Word) int {
-	m := len(x);
+	m := len(x)
 	if m > 0 {
 		return (m-1)*_W + log2(x[m-1])
 	}
-	return -1;
+	return -1
 }
 
 
 func hexValue(ch byte) int {
-	var d byte;
+	var d byte
 	switch {
 	case '0' <= ch && ch <= '9':
 		d = ch - '0'
@@ -390,7 +390,7 @@ func hexValue(ch byte) int {
 	default:
 		return -1
 	}
-	return int(d);
+	return int(d)
 }
 
 
@@ -406,16 +406,16 @@ func hexValue(ch byte) int {
 //
 func scanN(z []Word, s string, base int) ([]Word, int, int) {
 	// determine base if necessary
-	i, n := 0, len(s);
+	i, n := 0, len(s)
 	if base == 0 {
-		base = 10;
+		base = 10
 		if n > 0 && s[0] == '0' {
 			if n > 1 && (s[1] == 'x' || s[1] == 'X') {
 				if n == 2 {
 					// Reject a string which is just '0x' as nonsense.
 					return nil, 0, 0
 				}
-				base, i = 16, 2;
+				base, i = 16, 2
 			} else {
 				base, i = 8, 1
 			}
@@ -426,9 +426,9 @@ func scanN(z []Word, s string, base int) ([]Word, int, int) {
 	}
 
 	// convert string
-	z = makeN(z, len(z), false);
+	z = makeN(z, len(z), false)
 	for ; i < n; i++ {
-		d := hexValue(s[i]);
+		d := hexValue(s[i])
 		if 0 <= d && d < base {
 			z = mulAddNWW(z, z, Word(base), Word(d))
 		} else {
@@ -436,7 +436,7 @@ func scanN(z []Word, s string, base int) ([]Word, int, int) {
 		}
 	}
 
-	return z, base, i;
+	return z, base, i
 }
 
 
@@ -453,40 +453,40 @@ func stringN(x []Word, base int) string {
 	}
 
 	// allocate buffer for conversion
-	i := (log2N(x)+1)/log2(Word(base)) + 1;	// +1: round up
-	s := make([]byte, i);
+	i := (log2N(x)+1)/log2(Word(base)) + 1 // +1: round up
+	s := make([]byte, i)
 
 	// don't destroy x
-	q := setN(nil, x);
+	q := setN(nil, x)
 
 	// convert
 	for len(q) > 0 {
-		i--;
-		var r Word;
-		q, r = divNW(q, q, Word(base));
-		s[i] = "0123456789abcdef"[r];
+		i--
+		var r Word
+		q, r = divNW(q, q, Word(base))
+		s[i] = "0123456789abcdef"[r]
 	}
 
-	return string(s[i:]);
+	return string(s[i:])
 }
 
 
 // leadingZeroBits returns the number of leading zero bits in x.
 func leadingZeroBits(x Word) int {
-	c := 0;
+	c := 0
 	if x < 1<<(_W/2) {
-		x <<= _W / 2;
-		c = _W / 2;
+		x <<= _W / 2
+		c = _W / 2
 	}
 
 	for i := 0; x != 0; i++ {
 		if x&(1<<(_W-1)) != 0 {
 			return i + c
 		}
-		x <<= 1;
+		x <<= 1
 	}
 
-	return _W;
+	return _W
 }
 
 const deBruijn32 = 0x077CB531
@@ -526,7 +526,7 @@ func trailingZeroBits(x Word) int {
 		panic("Unknown word size")
 	}
 
-	return 0;
+	return 0
 }
 
 
@@ -535,12 +535,12 @@ func shiftLeft(dst, src []Word, n int) {
 		return
 	}
 
-	ñ := _W - uint(n);
+	ñ := _W - uint(n)
 	for i := len(src) - 1; i >= 1; i-- {
-		dst[i] = src[i] << uint(n);
-		dst[i] |= src[i-1] >> ñ;
+		dst[i] = src[i] << uint(n)
+		dst[i] |= src[i-1] >> ñ
 	}
-	dst[0] = src[0] << uint(n);
+	dst[0] = src[0] << uint(n)
 }
 
 
@@ -549,24 +549,24 @@ func shiftRight(dst, src []Word, n int) {
 		return
 	}
 
-	ñ := _W - uint(n);
+	ñ := _W - uint(n)
 	for i := 0; i < len(src)-1; i++ {
-		dst[i] = src[i] >> uint(n);
-		dst[i] |= src[i+1] << ñ;
+		dst[i] = src[i] >> uint(n)
+		dst[i] |= src[i+1] << ñ
 	}
-	dst[len(src)-1] = src[len(src)-1] >> uint(n);
+	dst[len(src)-1] = src[len(src)-1] >> uint(n)
 }
 
 
 // greaterThan returns true iff (x1<<_W + x2) > (y1<<_W + y2)
-func greaterThan(x1, x2, y1, y2 Word) bool	{ return x1 > y1 || x1 == y1 && x2 > y2 }
+func greaterThan(x1, x2, y1, y2 Word) bool { return x1 > y1 || x1 == y1 && x2 > y2 }
 
 
 // modNW returns x % d.
 func modNW(x []Word, d Word) (r Word) {
 	// TODO(agl): we don't actually need to store the q value.
-	q := makeN(nil, len(x), false);
-	return divWVW(&q[0], 0, &x[0], d, len(x));
+	q := makeN(nil, len(x), false)
+	return divWVW(&q[0], 0, &x[0], d, len(x))
 }
 
 
@@ -576,28 +576,28 @@ func powersOfTwoDecompose(n []Word) (q []Word, k Word) {
 		return n, 0
 	}
 
-	zeroWords := 0;
+	zeroWords := 0
 	for n[zeroWords] == 0 {
 		zeroWords++
 	}
 	// One of the words must be non-zero by invariant, therefore
 	// zeroWords < len(n).
-	x := trailingZeroBits(n[zeroWords]);
+	x := trailingZeroBits(n[zeroWords])
 
-	q = makeN(nil, len(n)-zeroWords, false);
-	shiftRight(q, n[zeroWords:], x);
+	q = makeN(nil, len(n)-zeroWords, false)
+	shiftRight(q, n[zeroWords:], x)
 
-	k = Word(_W*zeroWords + x);
-	return;
+	k = Word(_W*zeroWords + x)
+	return
 }
 
 
 // randomN creates a random integer in [0..limit), using the space in z if
 // possible. n is the bit length of limit.
 func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word {
-	bitLengthOfMSW := uint(n % _W);
-	mask := Word((1 << bitLengthOfMSW) - 1);
-	z = makeN(z, len(limit), false);
+	bitLengthOfMSW := uint(n % _W)
+	mask := Word((1 << bitLengthOfMSW) - 1)
+	z = makeN(z, len(limit), false)
 
 	for {
 		for i := range z {
@@ -609,14 +609,14 @@ func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word {
 			}
 		}
 
-		z[len(limit)-1] &= mask;
+		z[len(limit)-1] &= mask
 
 		if cmpNN(z, limit) < 0 {
 			break
 		}
 	}
 
-	return z;
+	return z
 }
 
 
@@ -624,32 +624,32 @@ func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word {
 // reuses the storage of z if possible.
 func expNNN(z, x, y, m []Word) []Word {
 	if len(y) == 0 {
-		z = makeN(z, 1, false);
-		z[0] = 1;
-		return z;
+		z = makeN(z, 1, false)
+		z[0] = 1
+		return z
 	}
 
 	if m != nil {
 		// We likely end up being as long as the modulus.
 		z = makeN(z, len(m), false)
 	}
-	z = setN(z, x);
-	v := y[len(y)-1];
+	z = setN(z, x)
+	v := y[len(y)-1]
 	// It's invalid for the most significant word to be zero, therefore we
 	// will find a one bit.
-	shift := leadingZeros(v) + 1;
-	v <<= shift;
-	var q []Word;
+	shift := leadingZeros(v) + 1
+	v <<= shift
+	var q []Word
 
-	const mask = 1 << (_W - 1);
+	const mask = 1 << (_W - 1)
 
 	// We walk through the bits of the exponent one by one. Each time we
 	// see a bit, we square, thus doubling the power. If the bit is a one,
 	// we also multiply by x, thus adding one to the power.
 
-	w := _W - int(shift);
+	w := _W - int(shift)
 	for j := 0; j < w; j++ {
-		z = mulNN(z, z, z);
+		z = mulNN(z, z, z)
 
 		if v&mask != 0 {
 			z = mulNN(z, z, x)
@@ -659,14 +659,14 @@ func expNNN(z, x, y, m []Word) []Word {
 			q, z = divNN(q, z, z, m)
 		}
 
-		v <<= 1;
+		v <<= 1
 	}
 
 	for i := len(y) - 2; i >= 0; i-- {
-		v = y[i];
+		v = y[i]
 
 		for j := 0; j < _W; j++ {
-			z = mulNN(z, z, z);
+			z = mulNN(z, z, z)
 
 			if v&mask != 0 {
 				z = mulNN(z, z, x)
@@ -676,11 +676,11 @@ func expNNN(z, x, y, m []Word) []Word {
 				q, z = divNN(q, z, z, m)
 			}
 
-			v <<= 1;
+			v <<= 1
 		}
 	}
 
-	return z;
+	return z
 }
 
 
@@ -690,13 +690,13 @@ func lenN(z []Word) int {
 		return 0
 	}
 
-	return (len(z)-1)*_W + (_W - leadingZeroBits(z[len(z)-1]));
+	return (len(z)-1)*_W + (_W - leadingZeroBits(z[len(z)-1]))
 }
 
 
 const (
-	primesProduct32	= 0xC0CFD797;		// Π {p ∈ primes, 2 < p <= 29}
-	primesProduct64	= 0xE221F97C30E94E1D;	// Π {p ∈ primes, 2 < p <= 53}
+	primesProduct32 = 0xC0CFD797         // Π {p ∈ primes, 2 < p <= 29}
+	primesProduct64 = 0xE221F97C30E94E1D // Π {p ∈ primes, 2 < p <= 53}
 )
 
 var bigOne = []Word{1}
@@ -725,7 +725,7 @@ func probablyPrime(n []Word, reps int) bool {
 		}
 	}
 
-	var r Word;
+	var r Word
 	switch _W {
 	case 32:
 		r = modNW(n, primesProduct32)
@@ -745,27 +745,27 @@ func probablyPrime(n []Word, reps int) bool {
 		return false
 	}
 
-	nm1 := subNN(nil, n, bigOne);
+	nm1 := subNN(nil, n, bigOne)
 	// 1<<k * q = nm1;
-	q, k := powersOfTwoDecompose(nm1);
+	q, k := powersOfTwoDecompose(nm1)
 
-	nm3 := subNN(nil, nm1, bigTwo);
-	rand := rand.New(rand.NewSource(int64(n[0])));
+	nm3 := subNN(nil, nm1, bigTwo)
+	rand := rand.New(rand.NewSource(int64(n[0])))
 
-	var x, y, quotient []Word;
-	nm3Len := lenN(nm3);
+	var x, y, quotient []Word
+	nm3Len := lenN(nm3)
 
 NextRandom:
 	for i := 0; i < reps; i++ {
-		x = randomN(x, rand, nm3, nm3Len);
-		addNN(x, x, bigTwo);
-		y = expNNN(y, x, q, n);
+		x = randomN(x, rand, nm3, nm3Len)
+		addNN(x, x, bigTwo)
+		y = expNNN(y, x, q, n)
 		if cmpNN(y, bigOne) == 0 || cmpNN(y, nm1) == 0 {
 			continue
 		}
 		for j := Word(1); j < k; j++ {
-			y = mulNN(y, y, y);
-			quotient, y = divNN(quotient, y, y, n);
+			y = mulNN(y, y, y)
+			quotient, y = divNN(quotient, y, y, n)
 			if cmpNN(y, nm1) == 0 {
 				continue NextRandom
 			}
@@ -773,8 +773,8 @@ NextRandom:
 				return false
 			}
 		}
-		return false;
+		return false
 	}
 
-	return true;
+	return true
 }
diff --git a/src/pkg/big/nat_test.go b/src/pkg/big/nat_test.go
index b1c9c1a10..1c993bad1 100644
--- a/src/pkg/big/nat_test.go
+++ b/src/pkg/big/nat_test.go
@@ -13,7 +13,7 @@ func TestCmpNN(t *testing.T) {
 
 type funNN func(z, x, y []Word) []Word
 type argNN struct {
-	z, x, y []Word;
+	z, x, y []Word
 }
 
 
@@ -41,7 +41,7 @@ var prodNN = []argNN{
 
 func TestSetN(t *testing.T) {
 	for _, a := range sumNN {
-		z := setN(nil, a.z);
+		z := setN(nil, a.z)
 		if cmpNN(z, a.z) != 0 {
 			t.Errorf("got z = %v; want %v", z, a.z)
 		}
@@ -50,7 +50,7 @@ func TestSetN(t *testing.T) {
 
 
 func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
-	z := f(nil, a.x, a.y);
+	z := f(nil, a.x, a.y)
 	if cmpNN(z, a.z) != 0 {
 		t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z)
 	}
@@ -59,33 +59,33 @@ func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
 
 func TestFunNN(t *testing.T) {
 	for _, a := range sumNN {
-		arg := a;
-		testFunNN(t, "addNN", addNN, arg);
+		arg := a
+		testFunNN(t, "addNN", addNN, arg)
 
-		arg = argNN{a.z, a.y, a.x};
-		testFunNN(t, "addNN symmetric", addNN, arg);
+		arg = argNN{a.z, a.y, a.x}
+		testFunNN(t, "addNN symmetric", addNN, arg)
 
-		arg = argNN{a.x, a.z, a.y};
-		testFunNN(t, "subNN", subNN, arg);
+		arg = argNN{a.x, a.z, a.y}
+		testFunNN(t, "subNN", subNN, arg)
 
-		arg = argNN{a.y, a.z, a.x};
-		testFunNN(t, "subNN symmetric", subNN, arg);
+		arg = argNN{a.y, a.z, a.x}
+		testFunNN(t, "subNN symmetric", subNN, arg)
 	}
 
 	for _, a := range prodNN {
-		arg := a;
-		testFunNN(t, "mulNN", mulNN, arg);
+		arg := a
+		testFunNN(t, "mulNN", mulNN, arg)
 
-		arg = argNN{a.z, a.y, a.x};
-		testFunNN(t, "mulNN symmetric", mulNN, arg);
+		arg = argNN{a.z, a.y, a.x}
+		testFunNN(t, "mulNN symmetric", mulNN, arg)
 	}
 }
 
 
 type strN struct {
-	x	[]Word;
-	b	int;
-	s	string;
+	x []Word
+	b int
+	s string
 }
 
 
@@ -99,12 +99,12 @@ var tabN = []strN{
 
 func TestStringN(t *testing.T) {
 	for _, a := range tabN {
-		s := stringN(a.x, a.b);
+		s := stringN(a.x, a.b)
 		if s != a.s {
 			t.Errorf("stringN%+v\n\tgot s = %s; want %s", a, s, a.s)
 		}
 
-		x, b, n := scanN(nil, a.s, a.b);
+		x, b, n := scanN(nil, a.s, a.b)
 		if cmpNN(x, a.x) != 0 {
 			t.Errorf("scanN%+v\n\tgot z = %v; want %v", a, x, a.x)
 		}
@@ -119,20 +119,20 @@ func TestStringN(t *testing.T) {
 
 
 func TestLeadingZeroBits(t *testing.T) {
-	var x Word = 1 << (_W - 1);
+	var x Word = 1 << (_W - 1)
 	for i := 0; i <= _W; i++ {
 		if leadingZeroBits(x) != i {
 			t.Errorf("failed at %x: got %d want %d", x, leadingZeroBits(x), i)
 		}
-		x >>= 1;
+		x >>= 1
 	}
 }
 
 
 type shiftTest struct {
-	in	[]Word;
-	shift	int;
-	out	[]Word;
+	in    []Word
+	shift int
+	out   []Word
 }
 
 
@@ -149,12 +149,12 @@ var leftShiftTests = []shiftTest{
 
 func TestShiftLeft(t *testing.T) {
 	for i, test := range leftShiftTests {
-		dst := make([]Word, len(test.out));
-		shiftLeft(dst, test.in, test.shift);
+		dst := make([]Word, len(test.out))
+		shiftLeft(dst, test.in, test.shift)
 		for j, v := range dst {
 			if test.out[j] != v {
-				t.Errorf("#%d: got: %v want: %v", i, dst, test.out);
-				break;
+				t.Errorf("#%d: got: %v want: %v", i, dst, test.out)
+				break
 			}
 		}
 	}
@@ -175,12 +175,12 @@ var rightShiftTests = []shiftTest{
 
 func TestShiftRight(t *testing.T) {
 	for i, test := range rightShiftTests {
-		dst := make([]Word, len(test.out));
-		shiftRight(dst, test.in, test.shift);
+		dst := make([]Word, len(test.out))
+		shiftRight(dst, test.in, test.shift)
 		for j, v := range dst {
 			if test.out[j] != v {
-				t.Errorf("#%d: got: %v want: %v", i, dst, test.out);
-				break;
+				t.Errorf("#%d: got: %v want: %v", i, dst, test.out)
+				break
 			}
 		}
 	}
@@ -188,9 +188,9 @@ func TestShiftRight(t *testing.T) {
 
 
 type modNWTest struct {
-	in		string;
-	dividend	string;
-	out		string;
+	in       string
+	dividend string
+	out      string
 }
 
 
@@ -206,11 +206,11 @@ var modNWTests64 = []modNWTest{
 
 func runModNWTests(t *testing.T, tests []modNWTest) {
 	for i, test := range tests {
-		in, _ := new(Int).SetString(test.in, 10);
-		d, _ := new(Int).SetString(test.dividend, 10);
-		out, _ := new(Int).SetString(test.out, 10);
+		in, _ := new(Int).SetString(test.in, 10)
+		d, _ := new(Int).SetString(test.dividend, 10)
+		out, _ := new(Int).SetString(test.out, 10)
 
-		r := modNW(in.abs, d.abs[0]);
+		r := modNW(in.abs, d.abs[0])
 		if r != out.abs[0] {
 			t.Errorf("#%d failed: got %s want %s\n", i, r, out)
 		}
@@ -229,20 +229,20 @@ func TestModNW(t *testing.T) {
 
 
 func TestTrailingZeroBits(t *testing.T) {
-	var x Word;
-	x--;
+	var x Word
+	x--
 	for i := 0; i < _W; i++ {
 		if trailingZeroBits(x) != i {
 			t.Errorf("Failed at step %d: x: %x got: %d\n", i, x, trailingZeroBits(x))
 		}
-		x <<= 1;
+		x <<= 1
 	}
 }
 
 
 type expNNNTest struct {
-	x, y, m	string;
-	out	string;
+	x, y, m string
+	out     string
 }
 
 
@@ -263,17 +263,17 @@ var expNNNTests = []expNNNTest{
 
 func TestExpNNN(t *testing.T) {
 	for i, test := range expNNNTests {
-		x, _, _ := scanN(nil, test.x, 0);
-		y, _, _ := scanN(nil, test.y, 0);
-		out, _, _ := scanN(nil, test.out, 0);
+		x, _, _ := scanN(nil, test.x, 0)
+		y, _, _ := scanN(nil, test.y, 0)
+		out, _, _ := scanN(nil, test.out, 0)
 
-		var m []Word;
+		var m []Word
 
 		if len(test.m) > 0 {
 			m, _, _ = scanN(nil, test.m, 0)
 		}
 
-		z := expNNN(nil, x, y, m);
+		z := expNNN(nil, x, y, m)
 		if cmpNN(z, out) != 0 {
 			t.Errorf("#%d got %v want %v", i, z, out)
 		}
diff --git a/src/pkg/bignum/arith.go b/src/pkg/bignum/arith.go
index 243e34b9c..aa65dbd7a 100644
--- a/src/pkg/bignum/arith.go
+++ b/src/pkg/bignum/arith.go
@@ -18,10 +18,10 @@ func Mul128(x, y uint64) (z1, z0 uint64) {
 	// and return the product as 2 words.
 
 	const (
-		W	= uint(unsafe.Sizeof(x)) * 8;
-		W2	= W / 2;
-		B2	= 1 << W2;
-		M2	= B2 - 1;
+		W  = uint(unsafe.Sizeof(x)) * 8
+		W2 = W / 2
+		B2 = 1 << W2
+		M2 = B2 - 1
 	)
 
 	if x < y {
@@ -32,44 +32,44 @@ func Mul128(x, y uint64) (z1, z0 uint64) {
 		// y < B2 because y <= x
 		// sub-digits of x and y are (0, x) and (0, y)
 		// z = z[0] = x*y
-		z0 = x * y;
-		return;
+		z0 = x * y
+		return
 	}
 
 	if y < B2 {
 		// sub-digits of x and y are (x1, x0) and (0, y)
 		// x = (x1*B2 + x0)
 		// y = (y1*B2 + y0)
-		x1, x0 := x>>W2, x&M2;
+		x1, x0 := x>>W2, x&M2
 
 		// x*y = t2*B2*B2 + t1*B2 + t0
-		t0 := x0 * y;
-		t1 := x1 * y;
+		t0 := x0 * y
+		t1 := x1 * y
 
 		// compute result digits but avoid overflow
 		// z = z[1]*B + z[0] = x*y
-		z0 = t1<<W2 + t0;
-		z1 = (t1 + t0>>W2) >> W2;
-		return;
+		z0 = t1<<W2 + t0
+		z1 = (t1 + t0>>W2) >> W2
+		return
 	}
 
 	// general case
 	// sub-digits of x and y are (x1, x0) and (y1, y0)
 	// x = (x1*B2 + x0)
 	// y = (y1*B2 + y0)
-	x1, x0 := x>>W2, x&M2;
-	y1, y0 := y>>W2, y&M2;
+	x1, x0 := x>>W2, x&M2
+	y1, y0 := y>>W2, y&M2
 
 	// x*y = t2*B2*B2 + t1*B2 + t0
-	t0 := x0 * y0;
-	t1 := x1*y0 + x0*y1;
-	t2 := x1 * y1;
+	t0 := x0 * y0
+	t1 := x1*y0 + x0*y1
+	t2 := x1 * y1
 
 	// compute result digits but avoid overflow
 	// z = z[1]*B + z[0] = x*y
-	z0 = t1<<W2 + t0;
-	z1 = t2 + (t1+t0>>W2)>>W2;
-	return;
+	z0 = t1<<W2 + t0
+	z1 = t2 + (t1+t0>>W2)>>W2
+	return
 }
 
 
@@ -80,10 +80,10 @@ func MulAdd128(x, y, c uint64) (z1, z0 uint64) {
 	// and return the product as 2 words.
 
 	const (
-		W	= uint(unsafe.Sizeof(x)) * 8;
-		W2	= W / 2;
-		B2	= 1 << W2;
-		M2	= B2 - 1;
+		W  = uint(unsafe.Sizeof(x)) * 8
+		W2 = W / 2
+		B2 = 1 << W2
+		M2 = B2 - 1
 	)
 
 	// TODO(gri) Should implement special cases for faster execution.
@@ -92,30 +92,30 @@ func MulAdd128(x, y, c uint64) (z1, z0 uint64) {
 	// sub-digits of x, y, and c are (x1, x0), (y1, y0), (c1, c0)
 	// x = (x1*B2 + x0)
 	// y = (y1*B2 + y0)
-	x1, x0 := x>>W2, x&M2;
-	y1, y0 := y>>W2, y&M2;
-	c1, c0 := c>>W2, c&M2;
+	x1, x0 := x>>W2, x&M2
+	y1, y0 := y>>W2, y&M2
+	c1, c0 := c>>W2, c&M2
 
 	// x*y + c = t2*B2*B2 + t1*B2 + t0
-	t0 := x0*y0 + c0;
-	t1 := x1*y0 + x0*y1 + c1;
-	t2 := x1 * y1;
+	t0 := x0*y0 + c0
+	t1 := x1*y0 + x0*y1 + c1
+	t2 := x1 * y1
 
 	// compute result digits but avoid overflow
 	// z = z[1]*B + z[0] = x*y
-	z0 = t1<<W2 + t0;
-	z1 = t2 + (t1+t0>>W2)>>W2;
-	return;
+	z0 = t1<<W2 + t0
+	z1 = t2 + (t1+t0>>W2)>>W2
+	return
 }
 
 
 // q = (x1<<64 + x0)/y + r
 func Div128(x1, x0, y uint64) (q, r uint64) {
 	if x1 == 0 {
-		q, r = x0/y, x0%y;
-		return;
+		q, r = x0/y, x0%y
+		return
 	}
 
 	// TODO(gri) Implement general case.
-	panic("Div128 not implemented for x > 1<<64-1");
+	panic("Div128 not implemented for x > 1<<64-1")
 }
diff --git a/src/pkg/bignum/bignum.go b/src/pkg/bignum/bignum.go
index 8106a2664..ee7d45ba6 100644
--- a/src/pkg/bignum/bignum.go
+++ b/src/pkg/bignum/bignum.go
@@ -16,7 +16,7 @@
 package bignum
 
 import (
-	"fmt";
+	"fmt"
 )
 
 // TODO(gri) Complete the set of in-place operations.
@@ -60,25 +60,25 @@ import (
 //    in bits must be even.
 
 type (
-	digit	uint64;
-	digit2	uint32;	// half-digits for division
+	digit  uint64
+	digit2 uint32 // half-digits for division
 )
 
 
 const (
-	logW	= 64;		// word width
-	logH	= 4;		// bits for a hex digit (= small number)
-	logB	= logW - logH;	// largest bit-width available
+	logW = 64          // word width
+	logH = 4           // bits for a hex digit (= small number)
+	logB = logW - logH // largest bit-width available
 
 	// half-digits
-	_W2	= logB / 2;	// width
-	_B2	= 1 << _W2;	// base
-	_M2	= _B2 - 1;	// mask
+	_W2 = logB / 2 // width
+	_B2 = 1 << _W2 // base
+	_M2 = _B2 - 1  // mask
 
 	// full digits
-	_W	= _W2 * 2;	// width
-	_B	= 1 << _W;	// base
-	_M	= _B - 1;	// mask
+	_W = _W2 * 2 // width
+	_B = 1 << _W // base
+	_M = _B - 1  // mask
 )
 
 
@@ -92,7 +92,7 @@ func assert(p bool) {
 }
 
 
-func isSmall(x digit) bool	{ return x < 1<<logH }
+func isSmall(x digit) bool { return x < 1<<logH }
 
 
 // For debugging. Keep around.
@@ -119,7 +119,7 @@ type Natural []digit
 //
 func Nat(x uint64) Natural {
 	if x == 0 {
-		return nil	// len == 0
+		return nil // len == 0
 	}
 
 	// single-digit values
@@ -132,19 +132,19 @@ func Nat(x uint64) Natural {
 	// compute number of digits required to represent x
 	// (this is usually 1 or 2, but the algorithm works
 	// for any base)
-	n := 0;
+	n := 0
 	for t := x; t > 0; t >>= _W {
 		n++
 	}
 
 	// split x into digits
-	z := make(Natural, n);
+	z := make(Natural, n)
 	for i := 0; i < n; i++ {
-		z[i] = digit(x & _M);
-		x >>= _W;
+		z[i] = digit(x & _M)
+		x >>= _W
 	}
 
-	return z;
+	return z
 }
 
 
@@ -152,7 +152,7 @@ func Nat(x uint64) Natural {
 //
 func (x Natural) Value() uint64 {
 	// single-digit values
-	n := len(x);
+	n := len(x)
 	switch n {
 	case 0:
 		return 0
@@ -163,14 +163,14 @@ func (x Natural) Value() uint64 {
 	// multi-digit values
 	// (this is usually 1 or 2, but the algorithm works
 	// for any base)
-	z := uint64(0);
-	s := uint(0);
+	z := uint64(0)
+	s := uint(0)
 	for i := 0; i < n && s < 64; i++ {
-		z += uint64(x[i]) << s;
-		s += _W;
+		z += uint64(x[i]) << s
+		s += _W
 	}
 
-	return z;
+	return z
 }
 
 
@@ -178,17 +178,17 @@ func (x Natural) Value() uint64 {
 
 // IsEven returns true iff x is divisible by 2.
 //
-func (x Natural) IsEven() bool	{ return len(x) == 0 || x[0]&1 == 0 }
+func (x Natural) IsEven() bool { return len(x) == 0 || x[0]&1 == 0 }
 
 
 // IsOdd returns true iff x is not divisible by 2.
 //
-func (x Natural) IsOdd() bool	{ return len(x) > 0 && x[0]&1 != 0 }
+func (x Natural) IsOdd() bool { return len(x) > 0 && x[0]&1 != 0 }
 
 
 // IsZero returns true iff x == 0.
 //
-func (x Natural) IsZero() bool	{ return len(x) == 0 }
+func (x Natural) IsZero() bool { return len(x) == 0 }
 
 
 // Operations
@@ -201,11 +201,11 @@ func (x Natural) IsZero() bool	{ return len(x) == 0 }
 // n, m   len(x), len(y)
 
 func normalize(x Natural) Natural {
-	n := len(x);
+	n := len(x)
 	for n > 0 && x[n-1] == 0 {
 		n--
 	}
-	return x[0:n];
+	return x[0:n]
 }
 
 
@@ -214,14 +214,14 @@ func normalize(x Natural) Natural {
 // Natural is allocated.
 //
 func nalloc(z Natural, n int) Natural {
-	size := n;
+	size := n
 	if size <= 0 {
 		size = 4
 	}
 	if size <= cap(z) {
 		return z[0:n]
 	}
-	return make(Natural, n, size);
+	return make(Natural, n, size)
 }
 
 
@@ -229,40 +229,40 @@ func nalloc(z Natural, n int) Natural {
 // *zp may be x or y.
 //
 func Nadd(zp *Natural, x, y Natural) {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
-		Nadd(zp, y, x);
-		return;
+		Nadd(zp, y, x)
+		return
 	}
 
-	z := nalloc(*zp, n+1);
-	c := digit(0);
-	i := 0;
+	z := nalloc(*zp, n+1)
+	c := digit(0)
+	i := 0
 	for i < m {
-		t := c + x[i] + y[i];
-		c, z[i] = t>>_W, t&_M;
-		i++;
+		t := c + x[i] + y[i]
+		c, z[i] = t>>_W, t&_M
+		i++
 	}
 	for i < n {
-		t := c + x[i];
-		c, z[i] = t>>_W, t&_M;
-		i++;
+		t := c + x[i]
+		c, z[i] = t>>_W, t&_M
+		i++
 	}
 	if c != 0 {
-		z[i] = c;
-		i++;
+		z[i] = c
+		i++
 	}
-	*zp = z[0:i];
+	*zp = z[0:i]
 }
 
 
 // Add returns the sum z = x + y.
 //
 func (x Natural) Add(y Natural) Natural {
-	var z Natural;
-	Nadd(&z, x, y);
-	return z;
+	var z Natural
+	Nadd(&z, x, y)
+	return z
 }
 
 
@@ -271,29 +271,29 @@ func (x Natural) Add(y Natural) Natural {
 // *zp may be x or y.
 //
 func Nsub(zp *Natural, x, y Natural) {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		panic("underflow")
 	}
 
-	z := nalloc(*zp, n);
-	c := digit(0);
-	i := 0;
+	z := nalloc(*zp, n)
+	c := digit(0)
+	i := 0
 	for i < m {
-		t := c + x[i] - y[i];
-		c, z[i] = digit(int64(t)>>_W), t&_M;	// requires arithmetic shift!
-		i++;
+		t := c + x[i] - y[i]
+		c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift!
+		i++
 	}
 	for i < n {
-		t := c + x[i];
-		c, z[i] = digit(int64(t)>>_W), t&_M;	// requires arithmetic shift!
-		i++;
+		t := c + x[i]
+		c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift!
+		i++
 	}
 	if int64(c) < 0 {
 		panic("underflow")
 	}
-	*zp = normalize(z);
+	*zp = normalize(z)
 }
 
 
@@ -301,17 +301,17 @@ func Nsub(zp *Natural, x, y Natural) {
 // If x < y, an underflow run-time error occurs (use Cmp to test if x >= y).
 //
 func (x Natural) Sub(y Natural) Natural {
-	var z Natural;
-	Nsub(&z, x, y);
-	return z;
+	var z Natural
+	Nsub(&z, x, y)
+	return z
 }
 
 
 // Returns z1 = (x*y + c) div B, z0 = (x*y + c) mod B.
 //
 func muladd11(x, y, c digit) (digit, digit) {
-	z1, z0 := MulAdd128(uint64(x), uint64(y), uint64(c));
-	return digit(z1<<(64-logB) | z0>>logB), digit(z0 & _M);
+	z1, z0 := MulAdd128(uint64(x), uint64(y), uint64(c))
+	return digit(z1<<(64-logB) | z0>>logB), digit(z0 & _M)
 }
 
 
@@ -319,7 +319,7 @@ func mul1(z, x Natural, y digit) (c digit) {
 	for i := 0; i < len(x); i++ {
 		c, z[i] = muladd11(x[i], y, c)
 	}
-	return;
+	return
 }
 
 
@@ -328,29 +328,29 @@ func mul1(z, x Natural, y digit) (c digit) {
 func Nscale(z *Natural, d uint64) {
 	switch {
 	case d == 0:
-		*z = Nat(0);
-		return;
+		*z = Nat(0)
+		return
 	case d == 1:
 		return
 	case d >= _B:
-		*z = z.Mul1(d);
-		return;
+		*z = z.Mul1(d)
+		return
 	}
 
-	c := mul1(*z, *z, digit(d));
+	c := mul1(*z, *z, digit(d))
 
 	if c != 0 {
-		n := len(*z);
+		n := len(*z)
 		if n >= cap(*z) {
-			zz := make(Natural, n+1);
+			zz := make(Natural, n+1)
 			for i, d := range *z {
 				zz[i] = d
 			}
-			*z = zz;
+			*z = zz
 		} else {
 			*z = (*z)[0 : n+1]
 		}
-		(*z)[n] = c;
+		(*z)[n] = c
 	}
 }
 
@@ -358,17 +358,17 @@ func Nscale(z *Natural, d uint64) {
 // Computes x = x*d + c for small d's.
 //
 func muladd1(x Natural, d, c digit) Natural {
-	assert(isSmall(d-1) && isSmall(c));
-	n := len(x);
-	z := make(Natural, n+1);
+	assert(isSmall(d-1) && isSmall(c))
+	n := len(x)
+	z := make(Natural, n+1)
 
 	for i := 0; i < n; i++ {
-		t := c + x[i]*d;
-		c, z[i] = t>>_W, t&_M;
+		t := c + x[i]*d
+		c, z[i] = t>>_W, t&_M
 	}
-	z[n] = c;
+	z[n] = c
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
@@ -386,18 +386,18 @@ func (x Natural) Mul1(d uint64) Natural {
 		return x.Mul(Nat(d))
 	}
 
-	z := make(Natural, len(x)+1);
-	c := mul1(z, x, digit(d));
-	z[len(x)] = c;
-	return normalize(z);
+	z := make(Natural, len(x)+1)
+	c := mul1(z, x, digit(d))
+	z[len(x)] = c
+	return normalize(z)
 }
 
 
 // Mul returns the product x * y.
 //
 func (x Natural) Mul(y Natural) Natural {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		return y.Mul(x)
 	}
@@ -410,19 +410,19 @@ func (x Natural) Mul(y Natural) Natural {
 		return x.Mul1(uint64(y[0]))
 	}
 
-	z := make(Natural, n+m);
+	z := make(Natural, n+m)
 	for j := 0; j < m; j++ {
-		d := y[j];
+		d := y[j]
 		if d != 0 {
-			c := digit(0);
+			c := digit(0)
 			for i := 0; i < n; i++ {
 				c, z[i+j] = muladd11(x[i], d, z[i+j]+c)
 			}
-			z[n+j] = c;
+			z[n+j] = c
 		}
 	}
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
@@ -432,57 +432,57 @@ func (x Natural) Mul(y Natural) Natural {
 // DivMod, and then pack the results again.
 
 func unpack(x Natural) []digit2 {
-	n := len(x);
-	z := make([]digit2, n*2+1);	// add space for extra digit (used by DivMod)
+	n := len(x)
+	z := make([]digit2, n*2+1) // add space for extra digit (used by DivMod)
 	for i := 0; i < n; i++ {
-		t := x[i];
-		z[i*2] = digit2(t & _M2);
-		z[i*2+1] = digit2(t >> _W2 & _M2);
+		t := x[i]
+		z[i*2] = digit2(t & _M2)
+		z[i*2+1] = digit2(t >> _W2 & _M2)
 	}
 
 	// normalize result
-	k := 2 * n;
+	k := 2 * n
 	for k > 0 && z[k-1] == 0 {
 		k--
 	}
-	return z[0:k];	// trim leading 0's
+	return z[0:k] // trim leading 0's
 }
 
 
 func pack(x []digit2) Natural {
-	n := (len(x) + 1) / 2;
-	z := make(Natural, n);
+	n := (len(x) + 1) / 2
+	z := make(Natural, n)
 	if len(x)&1 == 1 {
 		// handle odd len(x)
-		n--;
-		z[n] = digit(x[n*2]);
+		n--
+		z[n] = digit(x[n*2])
 	}
 	for i := 0; i < n; i++ {
 		z[i] = digit(x[i*2+1])<<_W2 | digit(x[i*2])
 	}
-	return normalize(z);
+	return normalize(z)
 }
 
 
 func mul21(z, x []digit2, y digit2) digit2 {
-	c := digit(0);
-	f := digit(y);
+	c := digit(0)
+	f := digit(y)
 	for i := 0; i < len(x); i++ {
-		t := c + digit(x[i])*f;
-		c, z[i] = t>>_W2, digit2(t&_M2);
+		t := c + digit(x[i])*f
+		c, z[i] = t>>_W2, digit2(t&_M2)
 	}
-	return digit2(c);
+	return digit2(c)
 }
 
 
 func div21(z, x []digit2, y digit2) digit2 {
-	c := digit(0);
-	d := digit(y);
+	c := digit(0)
+	d := digit(y)
 	for i := len(x) - 1; i >= 0; i-- {
-		t := c<<_W2 + digit(x[i]);
-		c, z[i] = t%d, digit2(t/d);
+		t := c<<_W2 + digit(x[i])
+		c, z[i] = t%d, digit2(t/d)
 	}
-	return digit2(c);
+	return digit2(c)
 }
 
 
@@ -507,14 +507,14 @@ func div21(z, x []digit2, y digit2) digit2 {
 //    579-601. John Wiley & Sons, Ltd.
 
 func divmod(x, y []digit2) ([]digit2, []digit2) {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if m == 0 {
 		panic("division by zero")
 	}
-	assert(n+1 <= cap(x));	// space for one extra digit
-	x = x[0 : n+1];
-	assert(x[n] == 0);
+	assert(n+1 <= cap(x)) // space for one extra digit
+	x = x[0 : n+1]
+	assert(x[n] == 0)
 
 	if m == 1 {
 		// division by single digit
@@ -528,27 +528,27 @@ func divmod(x, y []digit2) ([]digit2, []digit2) {
 
 	} else {
 		// general case
-		assert(2 <= m && m <= n);
+		assert(2 <= m && m <= n)
 
 		// normalize x and y
 		// TODO Instead of multiplying, it would be sufficient to
 		//      shift y such that the normalization condition is
 		//      satisfied (as done in Hacker's Delight).
-		f := _B2 / (digit(y[m-1]) + 1);
+		f := _B2 / (digit(y[m-1]) + 1)
 		if f != 1 {
-			mul21(x, x, digit2(f));
-			mul21(y, y, digit2(f));
+			mul21(x, x, digit2(f))
+			mul21(y, y, digit2(f))
 		}
-		assert(_B2/2 <= y[m-1] && y[m-1] < _B2);	// incorrect scaling
+		assert(_B2/2 <= y[m-1] && y[m-1] < _B2) // incorrect scaling
 
-		y1, y2 := digit(y[m-1]), digit(y[m-2]);
+		y1, y2 := digit(y[m-1]), digit(y[m-2])
 		for i := n - m; i >= 0; i-- {
-			k := i + m;
+			k := i + m
 
 			// compute trial digit (Knuth)
-			var q digit;
+			var q digit
 			{
-				x0, x1, x2 := digit(x[k]), digit(x[k-1]), digit(x[k-2]);
+				x0, x1, x2 := digit(x[k]), digit(x[k-1]), digit(x[k-2])
 				if x0 != y1 {
 					q = (x0<<_W2 + x1) / y1
 				} else {
@@ -560,36 +560,36 @@ func divmod(x, y []digit2) ([]digit2, []digit2) {
 			}
 
 			// subtract y*q
-			c := digit(0);
+			c := digit(0)
 			for j := 0; j < m; j++ {
-				t := c + digit(x[i+j]) - digit(y[j])*q;
-				c, x[i+j] = digit(int64(t)>>_W2), digit2(t&_M2);	// requires arithmetic shift!
+				t := c + digit(x[i+j]) - digit(y[j])*q
+				c, x[i+j] = digit(int64(t)>>_W2), digit2(t&_M2) // requires arithmetic shift!
 			}
 
 			// correct if trial digit was too large
 			if c+digit(x[k]) != 0 {
 				// add y
-				c := digit(0);
+				c := digit(0)
 				for j := 0; j < m; j++ {
-					t := c + digit(x[i+j]) + digit(y[j]);
-					c, x[i+j] = t>>_W2, digit2(t&_M2);
+					t := c + digit(x[i+j]) + digit(y[j])
+					c, x[i+j] = t>>_W2, digit2(t&_M2)
 				}
-				assert(c+digit(x[k]) == 0);
+				assert(c+digit(x[k]) == 0)
 				// correct trial digit
-				q--;
+				q--
 			}
 
-			x[k] = digit2(q);
+			x[k] = digit2(q)
 		}
 
 		// undo normalization for remainder
 		if f != 1 {
-			c := div21(x[0:m], x[0:m], digit2(f));
-			assert(c == 0);
+			c := div21(x[0:m], x[0:m], digit2(f))
+			assert(c == 0)
 		}
 	}
 
-	return x[m : n+1], x[0:m];
+	return x[m : n+1], x[0:m]
 }
 
 
@@ -598,8 +598,8 @@ func divmod(x, y []digit2) ([]digit2, []digit2) {
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x Natural) Div(y Natural) Natural {
-	q, _ := divmod(unpack(x), unpack(y));
-	return pack(q);
+	q, _ := divmod(unpack(x), unpack(y))
+	return pack(q)
 }
 
 
@@ -608,8 +608,8 @@ func (x Natural) Div(y Natural) Natural {
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x Natural) Mod(y Natural) Natural {
-	_, r := divmod(unpack(x), unpack(y));
-	return pack(r);
+	_, r := divmod(unpack(x), unpack(y))
+	return pack(r)
 }
 
 
@@ -617,78 +617,78 @@ func (x Natural) Mod(y Natural) Natural {
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x Natural) DivMod(y Natural) (Natural, Natural) {
-	q, r := divmod(unpack(x), unpack(y));
-	return pack(q), pack(r);
+	q, r := divmod(unpack(x), unpack(y))
+	return pack(q), pack(r)
 }
 
 
 func shl(z, x Natural, s uint) digit {
-	assert(s <= _W);
-	n := len(x);
-	c := digit(0);
+	assert(s <= _W)
+	n := len(x)
+	c := digit(0)
 	for i := 0; i < n; i++ {
 		c, z[i] = x[i]>>(_W-s), x[i]<<s&_M|c
 	}
-	return c;
+	return c
 }
 
 
 // Shl implements ``shift left'' x << s. It returns x * 2^s.
 //
 func (x Natural) Shl(s uint) Natural {
-	n := uint(len(x));
-	m := n + s/_W;
-	z := make(Natural, m+1);
+	n := uint(len(x))
+	m := n + s/_W
+	z := make(Natural, m+1)
 
-	z[m] = shl(z[m-n:m], x, s%_W);
+	z[m] = shl(z[m-n:m], x, s%_W)
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
 func shr(z, x Natural, s uint) digit {
-	assert(s <= _W);
-	n := len(x);
-	c := digit(0);
+	assert(s <= _W)
+	n := len(x)
+	c := digit(0)
 	for i := n - 1; i >= 0; i-- {
 		c, z[i] = x[i]<<(_W-s)&_M, x[i]>>s|c
 	}
-	return c;
+	return c
 }
 
 
 // Shr implements ``shift right'' x >> s. It returns x / 2^s.
 //
 func (x Natural) Shr(s uint) Natural {
-	n := uint(len(x));
-	m := n - s/_W;
-	if m > n {	// check for underflow
+	n := uint(len(x))
+	m := n - s/_W
+	if m > n { // check for underflow
 		m = 0
 	}
-	z := make(Natural, m);
+	z := make(Natural, m)
 
-	shr(z, x[n-m:n], s%_W);
+	shr(z, x[n-m:n], s%_W)
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
 // And returns the ``bitwise and'' x & y for the 2's-complement representation of x and y.
 //
 func (x Natural) And(y Natural) Natural {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		return y.And(x)
 	}
 
-	z := make(Natural, m);
+	z := make(Natural, m)
 	for i := 0; i < m; i++ {
 		z[i] = x[i] & y[i]
 	}
 	// upper bits are 0
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
@@ -702,57 +702,57 @@ func copy(z, x Natural) {
 // AndNot returns the ``bitwise clear'' x &^ y for the 2's-complement representation of x and y.
 //
 func (x Natural) AndNot(y Natural) Natural {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		m = n
 	}
 
-	z := make(Natural, n);
+	z := make(Natural, n)
 	for i := 0; i < m; i++ {
 		z[i] = x[i] &^ y[i]
 	}
-	copy(z[m:n], x[m:n]);
+	copy(z[m:n], x[m:n])
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
 // Or returns the ``bitwise or'' x | y for the 2's-complement representation of x and y.
 //
 func (x Natural) Or(y Natural) Natural {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		return y.Or(x)
 	}
 
-	z := make(Natural, n);
+	z := make(Natural, n)
 	for i := 0; i < m; i++ {
 		z[i] = x[i] | y[i]
 	}
-	copy(z[m:n], x[m:n]);
+	copy(z[m:n], x[m:n])
 
-	return z;
+	return z
 }
 
 
 // Xor returns the ``bitwise exclusive or'' x ^ y for the 2's-complement representation of x and y.
 //
 func (x Natural) Xor(y Natural) Natural {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 	if n < m {
 		return y.Xor(x)
 	}
 
-	z := make(Natural, n);
+	z := make(Natural, n)
 	for i := 0; i < m; i++ {
 		z[i] = x[i] ^ y[i]
 	}
-	copy(z[m:n], x[m:n]);
+	copy(z[m:n], x[m:n])
 
-	return normalize(z);
+	return normalize(z)
 }
 
 
@@ -763,19 +763,19 @@ func (x Natural) Xor(y Natural) Natural {
 //   >  0 if x >  y
 //
 func (x Natural) Cmp(y Natural) int {
-	n := len(x);
-	m := len(y);
+	n := len(x)
+	m := len(y)
 
 	if n != m || n == 0 {
 		return n - m
 	}
 
-	i := n - 1;
+	i := n - 1
 	for i > 0 && x[i] == y[i] {
 		i--
 	}
 
-	d := 0;
+	d := 0
 	switch {
 	case x[i] < y[i]:
 		d = -1
@@ -783,7 +783,7 @@ func (x Natural) Cmp(y Natural) int {
 		d = 1
 	}
 
-	return d;
+	return d
 }
 
 
@@ -792,13 +792,13 @@ func (x Natural) Cmp(y Natural) int {
 // If x == 0 a run-time error occurs.
 //
 func log2(x uint64) uint {
-	assert(x > 0);
-	n := uint(0);
+	assert(x > 0)
+	n := uint(0)
 	for x > 0 {
-		x >>= 1;
-		n++;
+		x >>= 1
+		n++
 	}
-	return n - 1;
+	return n - 1
 }
 
 
@@ -807,11 +807,11 @@ func log2(x uint64) uint {
 // If x == 0 a run-time error occurs.
 //
 func (x Natural) Log2() uint {
-	n := len(x);
+	n := len(x)
 	if n > 0 {
 		return (uint(n)-1)*_W + log2(uint64(x[n-1]))
 	}
-	panic("Log2(0)");
+	panic("Log2(0)")
 }
 
 
@@ -819,15 +819,15 @@ func (x Natural) Log2() uint {
 // Returns updated x and x mod d.
 //
 func divmod1(x Natural, d digit) (Natural, digit) {
-	assert(0 < d && isSmall(d-1));
+	assert(0 < d && isSmall(d-1))
 
-	c := digit(0);
+	c := digit(0)
 	for i := len(x) - 1; i >= 0; i-- {
-		t := c<<_W + x[i];
-		c, x[i] = t%d, t/d;
+		t := c<<_W + x[i]
+		c, x[i] = t%d, t/d
 	}
 
-	return normalize(x), c;
+	return normalize(x), c
 }
 
 
@@ -839,31 +839,31 @@ func (x Natural) ToString(base uint) string {
 	}
 
 	// allocate buffer for conversion
-	assert(2 <= base && base <= 16);
-	n := (x.Log2()+1)/log2(uint64(base)) + 1;	// +1: round up
-	s := make([]byte, n);
+	assert(2 <= base && base <= 16)
+	n := (x.Log2()+1)/log2(uint64(base)) + 1 // +1: round up
+	s := make([]byte, n)
 
 	// don't destroy x
-	t := make(Natural, len(x));
-	copy(t, x);
+	t := make(Natural, len(x))
+	copy(t, x)
 
 	// convert
-	i := n;
+	i := n
 	for !t.IsZero() {
-		i--;
-		var d digit;
-		t, d = divmod1(t, digit(base));
-		s[i] = "0123456789abcdef"[d];
+		i--
+		var d digit
+		t, d = divmod1(t, digit(base))
+		s[i] = "0123456789abcdef"[d]
 	}
 
-	return string(s[i:n]);
+	return string(s[i:n])
 }
 
 
 // String converts x to its decimal string representation.
 // x.String() is the same as x.ToString(10).
 //
-func (x Natural) String() string	{ return x.ToString(10) }
+func (x Natural) String() string { return x.ToString(10) }
 
 
 func fmtbase(c int) uint {
@@ -875,18 +875,18 @@ func fmtbase(c int) uint {
 	case 'x':
 		return 16
 	}
-	return 10;
+	return 10
 }
 
 
 // Format is a support routine for fmt.Formatter. It accepts
 // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal).
 //
-func (x Natural) Format(h fmt.State, c int)	{ fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
+func (x Natural) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
 
 
 func hexvalue(ch byte) uint {
-	d := uint(1 << logH);
+	d := uint(1 << logH)
 	switch {
 	case '0' <= ch && ch <= '9':
 		d = uint(ch - '0')
@@ -895,7 +895,7 @@ func hexvalue(ch byte) uint {
 	case 'A' <= ch && ch <= 'F':
 		d = uint(ch-'A') + 10
 	}
-	return d;
+	return d
 }
 
 
@@ -911,9 +911,9 @@ func hexvalue(ch byte) uint {
 //
 func NatFromString(s string, base uint) (Natural, uint, int) {
 	// determine base if necessary
-	i, n := 0, len(s);
+	i, n := 0, len(s)
 	if base == 0 {
-		base = 10;
+		base = 10
 		if n > 0 && s[0] == '0' {
 			if n > 1 && (s[1] == 'x' || s[1] == 'X') {
 				base, i = 16, 2
@@ -924,10 +924,10 @@ func NatFromString(s string, base uint) (Natural, uint, int) {
 	}
 
 	// convert string
-	assert(2 <= base && base <= 16);
-	x := Nat(0);
+	assert(2 <= base && base <= 16)
+	x := Nat(0)
 	for ; i < n; i++ {
-		d := hexvalue(s[i]);
+		d := hexvalue(s[i])
 		if d < base {
 			x = muladd1(x, digit(base), digit(d))
 		} else {
@@ -935,46 +935,46 @@ func NatFromString(s string, base uint) (Natural, uint, int) {
 		}
 	}
 
-	return x, base, i;
+	return x, base, i
 }
 
 
 // Natural number functions
 
 func pop1(x digit) uint {
-	n := uint(0);
+	n := uint(0)
 	for x != 0 {
-		x &= x - 1;
-		n++;
+		x &= x - 1
+		n++
 	}
-	return n;
+	return n
 }
 
 
 // Pop computes the ``population count'' of (the number of 1 bits in) x.
 //
 func (x Natural) Pop() uint {
-	n := uint(0);
+	n := uint(0)
 	for i := len(x) - 1; i >= 0; i-- {
 		n += pop1(x[i])
 	}
-	return n;
+	return n
 }
 
 
 // Pow computes x to the power of n.
 //
 func (xp Natural) Pow(n uint) Natural {
-	z := Nat(1);
-	x := xp;
+	z := Nat(1)
+	x := xp
 	for n > 0 {
 		// z * x^n == x^n0
 		if n&1 == 1 {
 			z = z.Mul(x)
 		}
-		x, n = x.Mul(x), n/2;
+		x, n = x.Mul(x), n/2
 	}
-	return z;
+	return z
 }
 
 
@@ -990,9 +990,9 @@ func MulRange(a, b uint) Natural {
 	case a+1 == b:
 		return Nat(uint64(a)).Mul(Nat(uint64(b)))
 	}
-	m := (a + b) >> 1;
-	assert(a <= m && m < b);
-	return MulRange(a, m).Mul(MulRange(m+1, b));
+	m := (a + b) >> 1
+	assert(a <= m && m < b)
+	return MulRange(a, m).Mul(MulRange(m+1, b))
 }
 
 
@@ -1007,16 +1007,16 @@ func Fact(n uint) Natural {
 
 // Binomial computes the binomial coefficient of (n, k).
 //
-func Binomial(n, k uint) Natural	{ return MulRange(n-k+1, n).Div(MulRange(1, k)) }
+func Binomial(n, k uint) Natural { return MulRange(n-k+1, n).Div(MulRange(1, k)) }
 
 
 // Gcd computes the gcd of x and y.
 //
 func (x Natural) Gcd(y Natural) Natural {
 	// Euclidean algorithm.
-	a, b := x, y;
+	a, b := x, y
 	for !b.IsZero() {
 		a, b = b, a.Mod(b)
 	}
-	return a;
+	return a
 }
diff --git a/src/pkg/bignum/bignum_test.go b/src/pkg/bignum/bignum_test.go
index 73edc9345..532fc9740 100644
--- a/src/pkg/bignum/bignum_test.go
+++ b/src/pkg/bignum/bignum_test.go
@@ -5,62 +5,62 @@
 package bignum
 
 import (
-	"fmt";
-	"testing";
+	"fmt"
+	"testing"
 )
 
 const (
-	sa	= "991";
-	sb	= "2432902008176640000";	// 20!
-	sc	= "933262154439441526816992388562667004907159682643816214685929" +
+	sa = "991"
+	sb = "2432902008176640000" // 20!
+	sc = "933262154439441526816992388562667004907159682643816214685929" +
 		"638952175999932299156089414639761565182862536979208272237582" +
-		"51185210916864000000000000000000000000";	// 100!
-	sp	= "170141183460469231731687303715884105727";	// prime
+		"51185210916864000000000000000000000000" // 100!
+	sp = "170141183460469231731687303715884105727" // prime
 )
 
 func natFromString(s string, base uint, slen *int) Natural {
-	x, _, len := NatFromString(s, base);
+	x, _, len := NatFromString(s, base)
 	if slen != nil {
 		*slen = len
 	}
-	return x;
+	return x
 }
 
 
 func intFromString(s string, base uint, slen *int) *Integer {
-	x, _, len := IntFromString(s, base);
+	x, _, len := IntFromString(s, base)
 	if slen != nil {
 		*slen = len
 	}
-	return x;
+	return x
 }
 
 
 func ratFromString(s string, base uint, slen *int) *Rational {
-	x, _, len := RatFromString(s, base);
+	x, _, len := RatFromString(s, base)
 	if slen != nil {
 		*slen = len
 	}
-	return x;
+	return x
 }
 
 
 var (
-	nat_zero	= Nat(0);
-	nat_one		= Nat(1);
-	nat_two		= Nat(2);
-	a		= natFromString(sa, 10, nil);
-	b		= natFromString(sb, 10, nil);
-	c		= natFromString(sc, 10, nil);
-	p		= natFromString(sp, 10, nil);
-	int_zero	= Int(0);
-	int_one		= Int(1);
-	int_two		= Int(2);
-	ip		= intFromString(sp, 10, nil);
-	rat_zero	= Rat(0, 1);
-	rat_half	= Rat(1, 2);
-	rat_one		= Rat(1, 1);
-	rat_two		= Rat(2, 1);
+	nat_zero = Nat(0)
+	nat_one  = Nat(1)
+	nat_two  = Nat(2)
+	a        = natFromString(sa, 10, nil)
+	b        = natFromString(sb, 10, nil)
+	c        = natFromString(sc, 10, nil)
+	p        = natFromString(sp, 10, nil)
+	int_zero = Int(0)
+	int_one  = Int(1)
+	int_two  = Int(2)
+	ip       = intFromString(sp, 10, nil)
+	rat_zero = Rat(0, 1)
+	rat_half = Rat(1, 2)
+	rat_one  = Rat(1, 1)
+	rat_two  = Rat(2, 1)
 )
 
 
@@ -96,11 +96,11 @@ func rat_eq(n uint, x, y *Rational) {
 
 
 func TestNatConv(t *testing.T) {
-	tester = t;
-	test_msg = "NatConvA";
+	tester = t
+	test_msg = "NatConvA"
 	type entry1 struct {
-		x	uint64;
-		s	string;
+		x uint64
+		s string
 	}
 	tab := []entry1{
 		entry1{0, "0"},
@@ -108,51 +108,51 @@ func TestNatConv(t *testing.T) {
 		entry1{65535, "65535"},
 		entry1{4294967295, "4294967295"},
 		entry1{18446744073709551615, "18446744073709551615"},
-	};
+	}
 	for i, e := range tab {
-		test(100+uint(i), Nat(e.x).String() == e.s);
-		test(200+uint(i), natFromString(e.s, 0, nil).Value() == e.x);
+		test(100+uint(i), Nat(e.x).String() == e.s)
+		test(200+uint(i), natFromString(e.s, 0, nil).Value() == e.x)
 	}
 
-	test_msg = "NatConvB";
+	test_msg = "NatConvB"
 	for i := uint(0); i < 100; i++ {
 		test(i, Nat(uint64(i)).String() == fmt.Sprintf("%d", i))
 	}
 
-	test_msg = "NatConvC";
-	z := uint64(7);
+	test_msg = "NatConvC"
+	z := uint64(7)
 	for i := uint(0); i <= 64; i++ {
-		test(i, Nat(z).Value() == z);
-		z <<= 1;
-	}
-
-	test_msg = "NatConvD";
-	nat_eq(0, a, Nat(991));
-	nat_eq(1, b, Fact(20));
-	nat_eq(2, c, Fact(100));
-	test(3, a.String() == sa);
-	test(4, b.String() == sb);
-	test(5, c.String() == sc);
-
-	test_msg = "NatConvE";
-	var slen int;
-	nat_eq(10, natFromString("0", 0, nil), nat_zero);
-	nat_eq(11, natFromString("123", 0, nil), Nat(123));
-	nat_eq(12, natFromString("077", 0, nil), Nat(7*8+7));
-	nat_eq(13, natFromString("0x1f", 0, nil), Nat(1*16+15));
-	nat_eq(14, natFromString("0x1fg", 0, &slen), Nat(1*16+15));
-	test(4, slen == 4);
-
-	test_msg = "NatConvF";
-	tmp := c.Mul(c);
+		test(i, Nat(z).Value() == z)
+		z <<= 1
+	}
+
+	test_msg = "NatConvD"
+	nat_eq(0, a, Nat(991))
+	nat_eq(1, b, Fact(20))
+	nat_eq(2, c, Fact(100))
+	test(3, a.String() == sa)
+	test(4, b.String() == sb)
+	test(5, c.String() == sc)
+
+	test_msg = "NatConvE"
+	var slen int
+	nat_eq(10, natFromString("0", 0, nil), nat_zero)
+	nat_eq(11, natFromString("123", 0, nil), Nat(123))
+	nat_eq(12, natFromString("077", 0, nil), Nat(7*8+7))
+	nat_eq(13, natFromString("0x1f", 0, nil), Nat(1*16+15))
+	nat_eq(14, natFromString("0x1fg", 0, &slen), Nat(1*16+15))
+	test(4, slen == 4)
+
+	test_msg = "NatConvF"
+	tmp := c.Mul(c)
 	for base := uint(2); base <= 16; base++ {
 		nat_eq(base, natFromString(tmp.ToString(base), base, nil), tmp)
 	}
 
-	test_msg = "NatConvG";
-	x := Nat(100);
-	y, _, _ := NatFromString(fmt.Sprintf("%b", &x), 2);
-	nat_eq(100, y, x);
+	test_msg = "NatConvG"
+	x := Nat(100)
+	y, _, _ := NatFromString(fmt.Sprintf("%b", &x), 2)
+	nat_eq(100, y, x)
 }
 
 
@@ -160,16 +160,16 @@ func abs(x int64) uint64 {
 	if x < 0 {
 		x = -x
 	}
-	return uint64(x);
+	return uint64(x)
 }
 
 
 func TestIntConv(t *testing.T) {
-	tester = t;
-	test_msg = "IntConvA";
+	tester = t
+	test_msg = "IntConvA"
 	type entry2 struct {
-		x	int64;
-		s	string;
+		x int64
+		s string
 	}
 	tab := []entry2{
 		entry2{0, "0"},
@@ -181,92 +181,92 @@ func TestIntConv(t *testing.T) {
 		entry2{2147483647, "2147483647"},
 		entry2{-9223372036854775808, "-9223372036854775808"},
 		entry2{9223372036854775807, "9223372036854775807"},
-	};
+	}
 	for i, e := range tab {
-		test(100+uint(i), Int(e.x).String() == e.s);
-		test(200+uint(i), intFromString(e.s, 0, nil).Value() == e.x);
-		test(300+uint(i), Int(e.x).Abs().Value() == abs(e.x));
-	}
-
-	test_msg = "IntConvB";
-	var slen int;
-	int_eq(0, intFromString("0", 0, nil), int_zero);
-	int_eq(1, intFromString("-0", 0, nil), int_zero);
-	int_eq(2, intFromString("123", 0, nil), Int(123));
-	int_eq(3, intFromString("-123", 0, nil), Int(-123));
-	int_eq(4, intFromString("077", 0, nil), Int(7*8+7));
-	int_eq(5, intFromString("-077", 0, nil), Int(-(7*8 + 7)));
-	int_eq(6, intFromString("0x1f", 0, nil), Int(1*16+15));
-	int_eq(7, intFromString("-0x1f", 0, &slen), Int(-(1*16 + 15)));
-	test(7, slen == 5);
-	int_eq(8, intFromString("+0x1f", 0, &slen), Int(+(1*16 + 15)));
-	test(8, slen == 5);
-	int_eq(9, intFromString("0x1fg", 0, &slen), Int(1*16+15));
-	test(9, slen == 4);
-	int_eq(10, intFromString("-0x1fg", 0, &slen), Int(-(1*16 + 15)));
-	test(10, slen == 5);
+		test(100+uint(i), Int(e.x).String() == e.s)
+		test(200+uint(i), intFromString(e.s, 0, nil).Value() == e.x)
+		test(300+uint(i), Int(e.x).Abs().Value() == abs(e.x))
+	}
+
+	test_msg = "IntConvB"
+	var slen int
+	int_eq(0, intFromString("0", 0, nil), int_zero)
+	int_eq(1, intFromString("-0", 0, nil), int_zero)
+	int_eq(2, intFromString("123", 0, nil), Int(123))
+	int_eq(3, intFromString("-123", 0, nil), Int(-123))
+	int_eq(4, intFromString("077", 0, nil), Int(7*8+7))
+	int_eq(5, intFromString("-077", 0, nil), Int(-(7*8 + 7)))
+	int_eq(6, intFromString("0x1f", 0, nil), Int(1*16+15))
+	int_eq(7, intFromString("-0x1f", 0, &slen), Int(-(1*16 + 15)))
+	test(7, slen == 5)
+	int_eq(8, intFromString("+0x1f", 0, &slen), Int(+(1*16 + 15)))
+	test(8, slen == 5)
+	int_eq(9, intFromString("0x1fg", 0, &slen), Int(1*16+15))
+	test(9, slen == 4)
+	int_eq(10, intFromString("-0x1fg", 0, &slen), Int(-(1*16 + 15)))
+	test(10, slen == 5)
 }
 
 
 func TestRatConv(t *testing.T) {
-	tester = t;
-	test_msg = "RatConv";
-	var slen int;
-	rat_eq(0, ratFromString("0", 0, nil), rat_zero);
-	rat_eq(1, ratFromString("0/1", 0, nil), rat_zero);
-	rat_eq(2, ratFromString("0/01", 0, nil), rat_zero);
-	rat_eq(3, ratFromString("0x14/10", 0, &slen), rat_two);
-	test(4, slen == 7);
-	rat_eq(5, ratFromString("0.", 0, nil), rat_zero);
-	rat_eq(6, ratFromString("0.001f", 10, nil), Rat(1, 1000));
-	rat_eq(7, ratFromString(".1", 0, nil), Rat(1, 10));
-	rat_eq(8, ratFromString("10101.0101", 2, nil), Rat(0x155, 1<<4));
-	rat_eq(9, ratFromString("-0003.145926", 10, &slen), Rat(-3145926, 1000000));
-	test(10, slen == 12);
-	rat_eq(11, ratFromString("1e2", 0, nil), Rat(100, 1));
-	rat_eq(12, ratFromString("1e-2", 0, nil), Rat(1, 100));
-	rat_eq(13, ratFromString("1.1e2", 0, nil), Rat(110, 1));
-	rat_eq(14, ratFromString(".1e2x", 0, &slen), Rat(10, 1));
-	test(15, slen == 4);
+	tester = t
+	test_msg = "RatConv"
+	var slen int
+	rat_eq(0, ratFromString("0", 0, nil), rat_zero)
+	rat_eq(1, ratFromString("0/1", 0, nil), rat_zero)
+	rat_eq(2, ratFromString("0/01", 0, nil), rat_zero)
+	rat_eq(3, ratFromString("0x14/10", 0, &slen), rat_two)
+	test(4, slen == 7)
+	rat_eq(5, ratFromString("0.", 0, nil), rat_zero)
+	rat_eq(6, ratFromString("0.001f", 10, nil), Rat(1, 1000))
+	rat_eq(7, ratFromString(".1", 0, nil), Rat(1, 10))
+	rat_eq(8, ratFromString("10101.0101", 2, nil), Rat(0x155, 1<<4))
+	rat_eq(9, ratFromString("-0003.145926", 10, &slen), Rat(-3145926, 1000000))
+	test(10, slen == 12)
+	rat_eq(11, ratFromString("1e2", 0, nil), Rat(100, 1))
+	rat_eq(12, ratFromString("1e-2", 0, nil), Rat(1, 100))
+	rat_eq(13, ratFromString("1.1e2", 0, nil), Rat(110, 1))
+	rat_eq(14, ratFromString(".1e2x", 0, &slen), Rat(10, 1))
+	test(15, slen == 4)
 }
 
 
 func add(x, y Natural) Natural {
-	z1 := x.Add(y);
-	z2 := y.Add(x);
+	z1 := x.Add(y)
+	z2 := y.Add(x)
 	if z1.Cmp(z2) != 0 {
 		tester.Fatalf("addition not symmetric:\n\tx = %v\n\ty = %t", x, y)
 	}
-	return z1;
+	return z1
 }
 
 
 func sum(n uint64, scale Natural) Natural {
-	s := nat_zero;
+	s := nat_zero
 	for ; n > 0; n-- {
 		s = add(s, Nat(n).Mul(scale))
 	}
-	return s;
+	return s
 }
 
 
 func TestNatAdd(t *testing.T) {
-	tester = t;
-	test_msg = "NatAddA";
-	nat_eq(0, add(nat_zero, nat_zero), nat_zero);
-	nat_eq(1, add(nat_zero, c), c);
+	tester = t
+	test_msg = "NatAddA"
+	nat_eq(0, add(nat_zero, nat_zero), nat_zero)
+	nat_eq(1, add(nat_zero, c), c)
 
-	test_msg = "NatAddB";
+	test_msg = "NatAddB"
 	for i := uint64(0); i < 100; i++ {
-		t := Nat(i);
-		nat_eq(uint(i), sum(i, c), t.Mul(t).Add(t).Shr(1).Mul(c));
+		t := Nat(i)
+		nat_eq(uint(i), sum(i, c), t.Mul(t).Add(t).Shr(1).Mul(c))
 	}
 }
 
 
 func mul(x, y Natural) Natural {
-	z1 := x.Mul(y);
-	z2 := y.Mul(x);
+	z1 := x.Mul(y)
+	z2 := y.Mul(x)
 	if z1.Cmp(z2) != 0 {
 		tester.Fatalf("multiplication not symmetric:\n\tx = %v\n\ty = %t", x, y)
 	}
@@ -276,40 +276,40 @@ func mul(x, y Natural) Natural {
 	if !y.IsZero() && z1.Div(y).Cmp(x) != 0 {
 		tester.Fatalf("multiplication/division not inverse (B):\n\tx = %v\n\ty = %t", x, y)
 	}
-	return z1;
+	return z1
 }
 
 
 func TestNatSub(t *testing.T) {
-	tester = t;
-	test_msg = "NatSubA";
-	nat_eq(0, nat_zero.Sub(nat_zero), nat_zero);
-	nat_eq(1, c.Sub(nat_zero), c);
+	tester = t
+	test_msg = "NatSubA"
+	nat_eq(0, nat_zero.Sub(nat_zero), nat_zero)
+	nat_eq(1, c.Sub(nat_zero), c)
 
-	test_msg = "NatSubB";
+	test_msg = "NatSubB"
 	for i := uint64(0); i < 100; i++ {
-		t := sum(i, c);
+		t := sum(i, c)
 		for j := uint64(0); j <= i; j++ {
 			t = t.Sub(mul(Nat(j), c))
 		}
-		nat_eq(uint(i), t, nat_zero);
+		nat_eq(uint(i), t, nat_zero)
 	}
 }
 
 
 func TestNatMul(t *testing.T) {
-	tester = t;
-	test_msg = "NatMulA";
-	nat_eq(0, mul(c, nat_zero), nat_zero);
-	nat_eq(1, mul(c, nat_one), c);
-
-	test_msg = "NatMulB";
-	nat_eq(0, b.Mul(MulRange(0, 100)), nat_zero);
-	nat_eq(1, b.Mul(MulRange(21, 100)), c);
-
-	test_msg = "NatMulC";
-	const n = 100;
-	p := b.Mul(c).Shl(n);
+	tester = t
+	test_msg = "NatMulA"
+	nat_eq(0, mul(c, nat_zero), nat_zero)
+	nat_eq(1, mul(c, nat_one), c)
+
+	test_msg = "NatMulB"
+	nat_eq(0, b.Mul(MulRange(0, 100)), nat_zero)
+	nat_eq(1, b.Mul(MulRange(21, 100)), c)
+
+	test_msg = "NatMulC"
+	const n = 100
+	p := b.Mul(c).Shl(n)
 	for i := uint(0); i < n; i++ {
 		nat_eq(i, mul(b.Shl(i), c.Shl(n-i)), p)
 	}
@@ -317,17 +317,17 @@ func TestNatMul(t *testing.T) {
 
 
 func TestNatDiv(t *testing.T) {
-	tester = t;
-	test_msg = "NatDivA";
-	nat_eq(0, c.Div(nat_one), c);
-	nat_eq(1, c.Div(Nat(100)), Fact(99));
-	nat_eq(2, b.Div(c), nat_zero);
-	nat_eq(4, nat_one.Shl(100).Div(nat_one.Shl(90)), nat_one.Shl(10));
-	nat_eq(5, c.Div(b), MulRange(21, 100));
-
-	test_msg = "NatDivB";
-	const n = 100;
-	p := Fact(n);
+	tester = t
+	test_msg = "NatDivA"
+	nat_eq(0, c.Div(nat_one), c)
+	nat_eq(1, c.Div(Nat(100)), Fact(99))
+	nat_eq(2, b.Div(c), nat_zero)
+	nat_eq(4, nat_one.Shl(100).Div(nat_one.Shl(90)), nat_one.Shl(10))
+	nat_eq(5, c.Div(b), MulRange(21, 100))
+
+	test_msg = "NatDivB"
+	const n = 100
+	p := Fact(n)
 	for i := uint(0); i < n; i++ {
 		nat_eq(100+i, p.Div(MulRange(1, i)), MulRange(i+1, n))
 	}
@@ -335,10 +335,10 @@ func TestNatDiv(t *testing.T) {
 
 
 func TestIntQuoRem(t *testing.T) {
-	tester = t;
-	test_msg = "IntQuoRem";
+	tester = t
+	test_msg = "IntQuoRem"
 	type T struct {
-		x, y, q, r int64;
+		x, y, q, r int64
 	}
 	a := []T{
 		T{+8, +3, +2, +2},
@@ -349,25 +349,25 @@ func TestIntQuoRem(t *testing.T) {
 		T{+1, -2, 0, +1},
 		T{-1, +2, 0, -1},
 		T{-1, -2, 0, -1},
-	};
+	}
 	for i := uint(0); i < uint(len(a)); i++ {
-		e := &a[i];
-		x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip);
-		q, r := Int(e.q), Int(e.r).Mul(ip);
-		qq, rr := x.QuoRem(y);
-		int_eq(4*i+0, x.Quo(y), q);
-		int_eq(4*i+1, x.Rem(y), r);
-		int_eq(4*i+2, qq, q);
-		int_eq(4*i+3, rr, r);
+		e := &a[i]
+		x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip)
+		q, r := Int(e.q), Int(e.r).Mul(ip)
+		qq, rr := x.QuoRem(y)
+		int_eq(4*i+0, x.Quo(y), q)
+		int_eq(4*i+1, x.Rem(y), r)
+		int_eq(4*i+2, qq, q)
+		int_eq(4*i+3, rr, r)
 	}
 }
 
 
 func TestIntDivMod(t *testing.T) {
-	tester = t;
-	test_msg = "IntDivMod";
+	tester = t
+	test_msg = "IntDivMod"
 	type T struct {
-		x, y, q, r int64;
+		x, y, q, r int64
 	}
 	a := []T{
 		T{+8, +3, +2, +2},
@@ -378,144 +378,144 @@ func TestIntDivMod(t *testing.T) {
 		T{+1, -2, 0, +1},
 		T{-1, +2, -1, +1},
 		T{-1, -2, +1, +1},
-	};
+	}
 	for i := uint(0); i < uint(len(a)); i++ {
-		e := &a[i];
-		x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip);
-		q, r := Int(e.q), Int(e.r).Mul(ip);
-		qq, rr := x.DivMod(y);
-		int_eq(4*i+0, x.Div(y), q);
-		int_eq(4*i+1, x.Mod(y), r);
-		int_eq(4*i+2, qq, q);
-		int_eq(4*i+3, rr, r);
+		e := &a[i]
+		x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip)
+		q, r := Int(e.q), Int(e.r).Mul(ip)
+		qq, rr := x.DivMod(y)
+		int_eq(4*i+0, x.Div(y), q)
+		int_eq(4*i+1, x.Mod(y), r)
+		int_eq(4*i+2, qq, q)
+		int_eq(4*i+3, rr, r)
 	}
 }
 
 
 func TestNatMod(t *testing.T) {
-	tester = t;
-	test_msg = "NatModA";
+	tester = t
+	test_msg = "NatModA"
 	for i := uint(0); ; i++ {
-		d := nat_one.Shl(i);
+		d := nat_one.Shl(i)
 		if d.Cmp(c) < 0 {
 			nat_eq(i, c.Add(d).Mod(c), d)
 		} else {
-			nat_eq(i, c.Add(d).Div(c), nat_two);
-			nat_eq(i, c.Add(d).Mod(c), d.Sub(c));
-			break;
+			nat_eq(i, c.Add(d).Div(c), nat_two)
+			nat_eq(i, c.Add(d).Mod(c), d.Sub(c))
+			break
 		}
 	}
 }
 
 
 func TestNatShift(t *testing.T) {
-	tester = t;
-	test_msg = "NatShift1L";
-	test(0, b.Shl(0).Cmp(b) == 0);
-	test(1, c.Shl(1).Cmp(c) > 0);
+	tester = t
+	test_msg = "NatShift1L"
+	test(0, b.Shl(0).Cmp(b) == 0)
+	test(1, c.Shl(1).Cmp(c) > 0)
 
-	test_msg = "NatShift1R";
-	test(3, b.Shr(0).Cmp(b) == 0);
-	test(4, c.Shr(1).Cmp(c) < 0);
+	test_msg = "NatShift1R"
+	test(3, b.Shr(0).Cmp(b) == 0)
+	test(4, c.Shr(1).Cmp(c) < 0)
 
-	test_msg = "NatShift2";
+	test_msg = "NatShift2"
 	for i := uint(0); i < 100; i++ {
 		test(i, c.Shl(i).Shr(i).Cmp(c) == 0)
 	}
 
-	test_msg = "NatShift3L";
+	test_msg = "NatShift3L"
 	{
-		const m = 3;
-		p := b;
-		f := Nat(1 << m);
+		const m = 3
+		p := b
+		f := Nat(1 << m)
 		for i := uint(0); i < 100; i++ {
-			nat_eq(i, b.Shl(i*m), p);
-			p = mul(p, f);
+			nat_eq(i, b.Shl(i*m), p)
+			p = mul(p, f)
 		}
 	}
 
-	test_msg = "NatShift3R";
+	test_msg = "NatShift3R"
 	{
-		p := c;
+		p := c
 		for i := uint(0); !p.IsZero(); i++ {
-			nat_eq(i, c.Shr(i), p);
-			p = p.Shr(1);
+			nat_eq(i, c.Shr(i), p)
+			p = p.Shr(1)
 		}
 	}
 }
 
 
 func TestIntShift(t *testing.T) {
-	tester = t;
-	test_msg = "IntShift1L";
-	test(0, ip.Shl(0).Cmp(ip) == 0);
-	test(1, ip.Shl(1).Cmp(ip) > 0);
+	tester = t
+	test_msg = "IntShift1L"
+	test(0, ip.Shl(0).Cmp(ip) == 0)
+	test(1, ip.Shl(1).Cmp(ip) > 0)
 
-	test_msg = "IntShift1R";
-	test(0, ip.Shr(0).Cmp(ip) == 0);
-	test(1, ip.Shr(1).Cmp(ip) < 0);
+	test_msg = "IntShift1R"
+	test(0, ip.Shr(0).Cmp(ip) == 0)
+	test(1, ip.Shr(1).Cmp(ip) < 0)
 
-	test_msg = "IntShift2";
+	test_msg = "IntShift2"
 	for i := uint(0); i < 100; i++ {
 		test(i, ip.Shl(i).Shr(i).Cmp(ip) == 0)
 	}
 
-	test_msg = "IntShift3L";
+	test_msg = "IntShift3L"
 	{
-		const m = 3;
-		p := ip;
-		f := Int(1 << m);
+		const m = 3
+		p := ip
+		f := Int(1 << m)
 		for i := uint(0); i < 100; i++ {
-			int_eq(i, ip.Shl(i*m), p);
-			p = p.Mul(f);
+			int_eq(i, ip.Shl(i*m), p)
+			p = p.Mul(f)
 		}
 	}
 
-	test_msg = "IntShift3R";
+	test_msg = "IntShift3R"
 	{
-		p := ip;
+		p := ip
 		for i := uint(0); p.IsPos(); i++ {
-			int_eq(i, ip.Shr(i), p);
-			p = p.Shr(1);
+			int_eq(i, ip.Shr(i), p)
+			p = p.Shr(1)
 		}
 	}
 
-	test_msg = "IntShift4R";
-	int_eq(0, Int(-43).Shr(1), Int(-43>>1));
-	int_eq(0, Int(-1024).Shr(100), Int(-1));
-	int_eq(1, ip.Neg().Shr(10), ip.Neg().Div(Int(1).Shl(10)));
+	test_msg = "IntShift4R"
+	int_eq(0, Int(-43).Shr(1), Int(-43>>1))
+	int_eq(0, Int(-1024).Shr(100), Int(-1))
+	int_eq(1, ip.Neg().Shr(10), ip.Neg().Div(Int(1).Shl(10)))
 }
 
 
 func TestNatBitOps(t *testing.T) {
-	tester = t;
+	tester = t
 
-	x := uint64(0xf08e6f56bd8c3941);
-	y := uint64(0x3984ef67834bc);
+	x := uint64(0xf08e6f56bd8c3941)
+	y := uint64(0x3984ef67834bc)
 
-	bx := Nat(x);
-	by := Nat(y);
+	bx := Nat(x)
+	by := Nat(y)
 
-	test_msg = "NatAnd";
-	bz := Nat(x & y);
+	test_msg = "NatAnd"
+	bz := Nat(x & y)
 	for i := uint(0); i < 100; i++ {
 		nat_eq(i, bx.Shl(i).And(by.Shl(i)), bz.Shl(i))
 	}
 
-	test_msg = "NatAndNot";
-	bz = Nat(x &^ y);
+	test_msg = "NatAndNot"
+	bz = Nat(x &^ y)
 	for i := uint(0); i < 100; i++ {
 		nat_eq(i, bx.Shl(i).AndNot(by.Shl(i)), bz.Shl(i))
 	}
 
-	test_msg = "NatOr";
-	bz = Nat(x | y);
+	test_msg = "NatOr"
+	bz = Nat(x | y)
 	for i := uint(0); i < 100; i++ {
 		nat_eq(i, bx.Shl(i).Or(by.Shl(i)), bz.Shl(i))
 	}
 
-	test_msg = "NatXor";
-	bz = Nat(x ^ y);
+	test_msg = "NatXor"
+	bz = Nat(x ^ y)
 	for i := uint(0); i < 100; i++ {
 		nat_eq(i, bx.Shl(i).Xor(by.Shl(i)), bz.Shl(i))
 	}
@@ -523,77 +523,77 @@ func TestNatBitOps(t *testing.T) {
 
 
 func TestIntBitOps1(t *testing.T) {
-	tester = t;
-	test_msg = "IntBitOps1";
+	tester = t
+	test_msg = "IntBitOps1"
 	type T struct {
-		x, y int64;
+		x, y int64
 	}
 	a := []T{
 		T{+7, +3},
 		T{+7, -3},
 		T{-7, +3},
 		T{-7, -3},
-	};
+	}
 	for i := uint(0); i < uint(len(a)); i++ {
-		e := &a[i];
-		int_eq(4*i+0, Int(e.x).And(Int(e.y)), Int(e.x&e.y));
-		int_eq(4*i+1, Int(e.x).AndNot(Int(e.y)), Int(e.x&^e.y));
-		int_eq(4*i+2, Int(e.x).Or(Int(e.y)), Int(e.x|e.y));
-		int_eq(4*i+3, Int(e.x).Xor(Int(e.y)), Int(e.x^e.y));
+		e := &a[i]
+		int_eq(4*i+0, Int(e.x).And(Int(e.y)), Int(e.x&e.y))
+		int_eq(4*i+1, Int(e.x).AndNot(Int(e.y)), Int(e.x&^e.y))
+		int_eq(4*i+2, Int(e.x).Or(Int(e.y)), Int(e.x|e.y))
+		int_eq(4*i+3, Int(e.x).Xor(Int(e.y)), Int(e.x^e.y))
 	}
 }
 
 
 func TestIntBitOps2(t *testing.T) {
-	tester = t;
+	tester = t
 
-	test_msg = "IntNot";
-	int_eq(0, Int(-2).Not(), Int(1));
-	int_eq(0, Int(-1).Not(), Int(0));
-	int_eq(0, Int(0).Not(), Int(-1));
-	int_eq(0, Int(1).Not(), Int(-2));
-	int_eq(0, Int(2).Not(), Int(-3));
+	test_msg = "IntNot"
+	int_eq(0, Int(-2).Not(), Int(1))
+	int_eq(0, Int(-1).Not(), Int(0))
+	int_eq(0, Int(0).Not(), Int(-1))
+	int_eq(0, Int(1).Not(), Int(-2))
+	int_eq(0, Int(2).Not(), Int(-3))
 
-	test_msg = "IntAnd";
+	test_msg = "IntAnd"
 	for x := int64(-15); x < 5; x++ {
-		bx := Int(x);
+		bx := Int(x)
 		for y := int64(-5); y < 15; y++ {
-			by := Int(y);
-			for i := uint(50); i < 70; i++ {	// shift across 64bit boundary
+			by := Int(y)
+			for i := uint(50); i < 70; i++ { // shift across 64bit boundary
 				int_eq(i, bx.Shl(i).And(by.Shl(i)), Int(x&y).Shl(i))
 			}
 		}
 	}
 
-	test_msg = "IntAndNot";
+	test_msg = "IntAndNot"
 	for x := int64(-15); x < 5; x++ {
-		bx := Int(x);
+		bx := Int(x)
 		for y := int64(-5); y < 15; y++ {
-			by := Int(y);
-			for i := uint(50); i < 70; i++ {	// shift across 64bit boundary
-				int_eq(2*i+0, bx.Shl(i).AndNot(by.Shl(i)), Int(x&^y).Shl(i));
-				int_eq(2*i+1, bx.Shl(i).And(by.Shl(i).Not()), Int(x&^y).Shl(i));
+			by := Int(y)
+			for i := uint(50); i < 70; i++ { // shift across 64bit boundary
+				int_eq(2*i+0, bx.Shl(i).AndNot(by.Shl(i)), Int(x&^y).Shl(i))
+				int_eq(2*i+1, bx.Shl(i).And(by.Shl(i).Not()), Int(x&^y).Shl(i))
 			}
 		}
 	}
 
-	test_msg = "IntOr";
+	test_msg = "IntOr"
 	for x := int64(-15); x < 5; x++ {
-		bx := Int(x);
+		bx := Int(x)
 		for y := int64(-5); y < 15; y++ {
-			by := Int(y);
-			for i := uint(50); i < 70; i++ {	// shift across 64bit boundary
+			by := Int(y)
+			for i := uint(50); i < 70; i++ { // shift across 64bit boundary
 				int_eq(i, bx.Shl(i).Or(by.Shl(i)), Int(x|y).Shl(i))
 			}
 		}
 	}
 
-	test_msg = "IntXor";
+	test_msg = "IntXor"
 	for x := int64(-15); x < 5; x++ {
-		bx := Int(x);
+		bx := Int(x)
 		for y := int64(-5); y < 15; y++ {
-			by := Int(y);
-			for i := uint(50); i < 70; i++ {	// shift across 64bit boundary
+			by := Int(y)
+			for i := uint(50); i < 70; i++ { // shift across 64bit boundary
 				int_eq(i, bx.Shl(i).Xor(by.Shl(i)), Int(x^y).Shl(i))
 			}
 		}
@@ -602,27 +602,27 @@ func TestIntBitOps2(t *testing.T) {
 
 
 func TestNatCmp(t *testing.T) {
-	tester = t;
-	test_msg = "NatCmp";
-	test(0, a.Cmp(a) == 0);
-	test(1, a.Cmp(b) < 0);
-	test(2, b.Cmp(a) > 0);
-	test(3, a.Cmp(c) < 0);
-	d := c.Add(b);
-	test(4, c.Cmp(d) < 0);
-	test(5, d.Cmp(c) > 0);
+	tester = t
+	test_msg = "NatCmp"
+	test(0, a.Cmp(a) == 0)
+	test(1, a.Cmp(b) < 0)
+	test(2, b.Cmp(a) > 0)
+	test(3, a.Cmp(c) < 0)
+	d := c.Add(b)
+	test(4, c.Cmp(d) < 0)
+	test(5, d.Cmp(c) > 0)
 }
 
 
 func TestNatLog2(t *testing.T) {
-	tester = t;
-	test_msg = "NatLog2A";
-	test(0, nat_one.Log2() == 0);
-	test(1, nat_two.Log2() == 1);
-	test(2, Nat(3).Log2() == 1);
-	test(3, Nat(4).Log2() == 2);
-
-	test_msg = "NatLog2B";
+	tester = t
+	test_msg = "NatLog2A"
+	test(0, nat_one.Log2() == 0)
+	test(1, nat_two.Log2() == 1)
+	test(2, Nat(3).Log2() == 1)
+	test(3, Nat(4).Log2() == 2)
+
+	test_msg = "NatLog2B"
 	for i := uint(0); i < 100; i++ {
 		test(i, nat_one.Shl(i).Log2() == i)
 	}
@@ -630,19 +630,19 @@ func TestNatLog2(t *testing.T) {
 
 
 func TestNatGcd(t *testing.T) {
-	tester = t;
-	test_msg = "NatGcdA";
-	f := Nat(99991);
-	nat_eq(0, b.Mul(f).Gcd(c.Mul(f)), MulRange(1, 20).Mul(f));
+	tester = t
+	test_msg = "NatGcdA"
+	f := Nat(99991)
+	nat_eq(0, b.Mul(f).Gcd(c.Mul(f)), MulRange(1, 20).Mul(f))
 }
 
 
 func TestNatPow(t *testing.T) {
-	tester = t;
-	test_msg = "NatPowA";
-	nat_eq(0, nat_two.Pow(0), nat_one);
+	tester = t
+	test_msg = "NatPowA"
+	nat_eq(0, nat_two.Pow(0), nat_one)
 
-	test_msg = "NatPowB";
+	test_msg = "NatPowB"
 	for i := uint(0); i < 100; i++ {
 		nat_eq(i, nat_two.Pow(i), nat_one.Shl(i))
 	}
@@ -650,15 +650,15 @@ func TestNatPow(t *testing.T) {
 
 
 func TestNatPop(t *testing.T) {
-	tester = t;
-	test_msg = "NatPopA";
-	test(0, nat_zero.Pop() == 0);
-	test(1, nat_one.Pop() == 1);
-	test(2, Nat(10).Pop() == 2);
-	test(3, Nat(30).Pop() == 4);
-	test(4, Nat(0x1248f).Shl(33).Pop() == 8);
-
-	test_msg = "NatPopB";
+	tester = t
+	test_msg = "NatPopA"
+	test(0, nat_zero.Pop() == 0)
+	test(1, nat_one.Pop() == 1)
+	test(2, Nat(10).Pop() == 2)
+	test(3, Nat(30).Pop() == 4)
+	test(4, Nat(0x1248f).Shl(33).Pop() == 8)
+
+	test_msg = "NatPopB"
 	for i := uint(0); i < 100; i++ {
 		test(i, nat_one.Shl(i).Sub(nat_one).Pop() == i)
 	}
diff --git a/src/pkg/bignum/integer.go b/src/pkg/bignum/integer.go
index 3d382473e..873b2664a 100644
--- a/src/pkg/bignum/integer.go
+++ b/src/pkg/bignum/integer.go
@@ -10,7 +10,7 @@
 package bignum
 
 import (
-	"fmt";
+	"fmt"
 )
 
 // TODO(gri) Complete the set of in-place operations.
@@ -18,8 +18,8 @@ import (
 // Integer represents a signed integer value of arbitrary precision.
 //
 type Integer struct {
-	sign	bool;
-	mant	Natural;
+	sign bool
+	mant Natural
 }
 
 
@@ -29,16 +29,16 @@ type Integer struct {
 //
 func MakeInt(sign bool, mant Natural) *Integer {
 	if mant.IsZero() {
-		sign = false	// normalize
+		sign = false // normalize
 	}
-	return &Integer{sign, mant};
+	return &Integer{sign, mant}
 }
 
 
 // Int creates a small integer with value x.
 //
 func Int(x int64) *Integer {
-	var ux uint64;
+	var ux uint64
 	if x < 0 {
 		// For the most negative x, -x == x, and
 		// the bit pattern has the correct value.
@@ -46,7 +46,7 @@ func Int(x int64) *Integer {
 	} else {
 		ux = uint64(x)
 	}
-	return MakeInt(x < 0, Nat(ux));
+	return MakeInt(x < 0, Nat(ux))
 }
 
 
@@ -54,51 +54,51 @@ func Int(x int64) *Integer {
 // otherwise the result is undefined.
 //
 func (x *Integer) Value() int64 {
-	z := int64(x.mant.Value());
+	z := int64(x.mant.Value())
 	if x.sign {
 		z = -z
 	}
-	return z;
+	return z
 }
 
 
 // Abs returns the absolute value of x.
 //
-func (x *Integer) Abs() Natural	{ return x.mant }
+func (x *Integer) Abs() Natural { return x.mant }
 
 
 // Predicates
 
 // IsEven returns true iff x is divisible by 2.
 //
-func (x *Integer) IsEven() bool	{ return x.mant.IsEven() }
+func (x *Integer) IsEven() bool { return x.mant.IsEven() }
 
 
 // IsOdd returns true iff x is not divisible by 2.
 //
-func (x *Integer) IsOdd() bool	{ return x.mant.IsOdd() }
+func (x *Integer) IsOdd() bool { return x.mant.IsOdd() }
 
 
 // IsZero returns true iff x == 0.
 //
-func (x *Integer) IsZero() bool	{ return x.mant.IsZero() }
+func (x *Integer) IsZero() bool { return x.mant.IsZero() }
 
 
 // IsNeg returns true iff x < 0.
 //
-func (x *Integer) IsNeg() bool	{ return x.sign && !x.mant.IsZero() }
+func (x *Integer) IsNeg() bool { return x.sign && !x.mant.IsZero() }
 
 
 // IsPos returns true iff x >= 0.
 //
-func (x *Integer) IsPos() bool	{ return !x.sign && !x.mant.IsZero() }
+func (x *Integer) IsPos() bool { return !x.sign && !x.mant.IsZero() }
 
 
 // Operations
 
 // Neg returns the negated value of x.
 //
-func (x *Integer) Neg() *Integer	{ return MakeInt(!x.sign, x.mant) }
+func (x *Integer) Neg() *Integer { return MakeInt(!x.sign, x.mant) }
 
 
 // Iadd sets z to the sum x + y.
@@ -108,17 +108,17 @@ func Iadd(z, x, y *Integer) {
 	if x.sign == y.sign {
 		// x + y == x + y
 		// (-x) + (-y) == -(x + y)
-		z.sign = x.sign;
-		Nadd(&z.mant, x.mant, y.mant);
+		z.sign = x.sign
+		Nadd(&z.mant, x.mant, y.mant)
 	} else {
 		// x + (-y) == x - y == -(y - x)
 		// (-x) + y == y - x == -(x - y)
 		if x.mant.Cmp(y.mant) >= 0 {
-			z.sign = x.sign;
-			Nsub(&z.mant, x.mant, y.mant);
+			z.sign = x.sign
+			Nsub(&z.mant, x.mant, y.mant)
 		} else {
-			z.sign = !x.sign;
-			Nsub(&z.mant, y.mant, x.mant);
+			z.sign = !x.sign
+			Nsub(&z.mant, y.mant, x.mant)
 		}
 	}
 }
@@ -127,9 +127,9 @@ func Iadd(z, x, y *Integer) {
 // Add returns the sum x + y.
 //
 func (x *Integer) Add(y *Integer) *Integer {
-	var z Integer;
-	Iadd(&z, x, y);
-	return &z;
+	var z Integer
+	Iadd(&z, x, y)
+	return &z
 }
 
 
@@ -137,17 +137,17 @@ func Isub(z, x, y *Integer) {
 	if x.sign != y.sign {
 		// x - (-y) == x + y
 		// (-x) - y == -(x + y)
-		z.sign = x.sign;
-		Nadd(&z.mant, x.mant, y.mant);
+		z.sign = x.sign
+		Nadd(&z.mant, x.mant, y.mant)
 	} else {
 		// x - y == x - y == -(y - x)
 		// (-x) - (-y) == y - x == -(x - y)
 		if x.mant.Cmp(y.mant) >= 0 {
-			z.sign = x.sign;
-			Nsub(&z.mant, x.mant, y.mant);
+			z.sign = x.sign
+			Nsub(&z.mant, x.mant, y.mant)
 		} else {
-			z.sign = !x.sign;
-			Nsub(&z.mant, y.mant, x.mant);
+			z.sign = !x.sign
+			Nsub(&z.mant, y.mant, x.mant)
 		}
 	}
 }
@@ -156,32 +156,32 @@ func Isub(z, x, y *Integer) {
 // Sub returns the difference x - y.
 //
 func (x *Integer) Sub(y *Integer) *Integer {
-	var z Integer;
-	Isub(&z, x, y);
-	return &z;
+	var z Integer
+	Isub(&z, x, y)
+	return &z
 }
 
 
 // Nscale sets *z to the scaled value (*z) * d.
 //
 func Iscale(z *Integer, d int64) {
-	f := uint64(d);
+	f := uint64(d)
 	if d < 0 {
 		f = uint64(-d)
 	}
-	z.sign = z.sign != (d < 0);
-	Nscale(&z.mant, f);
+	z.sign = z.sign != (d < 0)
+	Nscale(&z.mant, f)
 }
 
 
 // Mul1 returns the product x * d.
 //
 func (x *Integer) Mul1(d int64) *Integer {
-	f := uint64(d);
+	f := uint64(d)
 	if d < 0 {
 		f = uint64(-d)
 	}
-	return MakeInt(x.sign != (d < 0), x.mant.Mul1(f));
+	return MakeInt(x.sign != (d < 0), x.mant.Mul1(f))
 }
 
 
@@ -242,8 +242,8 @@ func (x *Integer) Rem(y *Integer) *Integer {
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x *Integer) QuoRem(y *Integer) (*Integer, *Integer) {
-	q, r := x.mant.DivMod(y.mant);
-	return MakeInt(x.sign != y.sign, q), MakeInt(x.sign, r);
+	q, r := x.mant.DivMod(y.mant)
+	return MakeInt(x.sign != y.sign, q), MakeInt(x.sign, r)
 }
 
 
@@ -261,7 +261,7 @@ func (x *Integer) QuoRem(y *Integer) (*Integer, *Integer) {
 // ACM press.)
 //
 func (x *Integer) Div(y *Integer) *Integer {
-	q, r := x.QuoRem(y);
+	q, r := x.QuoRem(y)
 	if r.IsNeg() {
 		if y.IsPos() {
 			q = q.Sub(Int(1))
@@ -269,7 +269,7 @@ func (x *Integer) Div(y *Integer) *Integer {
 			q = q.Add(Int(1))
 		}
 	}
-	return q;
+	return q
 }
 
 
@@ -278,7 +278,7 @@ func (x *Integer) Div(y *Integer) *Integer {
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x *Integer) Mod(y *Integer) *Integer {
-	r := x.Rem(y);
+	r := x.Rem(y)
 	if r.IsNeg() {
 		if y.IsPos() {
 			r = r.Add(y)
@@ -286,30 +286,30 @@ func (x *Integer) Mod(y *Integer) *Integer {
 			r = r.Sub(y)
 		}
 	}
-	return r;
+	return r
 }
 
 
 // DivMod returns the pair (x.Div(y), x.Mod(y)).
 //
 func (x *Integer) DivMod(y *Integer) (*Integer, *Integer) {
-	q, r := x.QuoRem(y);
+	q, r := x.QuoRem(y)
 	if r.IsNeg() {
 		if y.IsPos() {
-			q = q.Sub(Int(1));
-			r = r.Add(y);
+			q = q.Sub(Int(1))
+			r = r.Add(y)
 		} else {
-			q = q.Add(Int(1));
-			r = r.Sub(y);
+			q = q.Add(Int(1))
+			r = r.Sub(y)
 		}
 	}
-	return q, r;
+	return q, r
 }
 
 
 // Shl implements ``shift left'' x << s. It returns x * 2^s.
 //
-func (x *Integer) Shl(s uint) *Integer	{ return MakeInt(x.sign, x.mant.Shl(s)) }
+func (x *Integer) Shl(s uint) *Integer { return MakeInt(x.sign, x.mant.Shl(s)) }
 
 
 // The bitwise operations on integers are defined on the 2's-complement
@@ -336,7 +336,7 @@ func (x *Integer) Shr(s uint) *Integer {
 		return MakeInt(true, x.mant.Sub(Nat(1)).Shr(s).Add(Nat(1)))
 	}
 
-	return MakeInt(false, x.mant.Shr(s));
+	return MakeInt(false, x.mant.Shr(s))
 }
 
 
@@ -348,7 +348,7 @@ func (x *Integer) Not() *Integer {
 	}
 
 	// ^x == -x-1 == -(x+1)
-	return MakeInt(true, x.mant.Add(Nat(1)));
+	return MakeInt(true, x.mant.Add(Nat(1)))
 }
 
 
@@ -362,16 +362,16 @@ func (x *Integer) And(y *Integer) *Integer {
 		}
 
 		// x & y == x & y
-		return MakeInt(false, x.mant.And(y.mant));
+		return MakeInt(false, x.mant.And(y.mant))
 	}
 
 	// x.sign != y.sign
 	if x.sign {
-		x, y = y, x	// & is symmetric
+		x, y = y, x // & is symmetric
 	}
 
 	// x & (-y) == x & ^(y-1) == x &^ (y-1)
-	return MakeInt(false, x.mant.AndNot(y.mant.Sub(Nat(1))));
+	return MakeInt(false, x.mant.AndNot(y.mant.Sub(Nat(1))))
 }
 
 
@@ -385,7 +385,7 @@ func (x *Integer) AndNot(y *Integer) *Integer {
 		}
 
 		// x &^ y == x &^ y
-		return MakeInt(false, x.mant.AndNot(y.mant));
+		return MakeInt(false, x.mant.AndNot(y.mant))
 	}
 
 	if x.sign {
@@ -394,7 +394,7 @@ func (x *Integer) AndNot(y *Integer) *Integer {
 	}
 
 	// x &^ (-y) == x &^ ^(y-1) == x & (y-1)
-	return MakeInt(false, x.mant.And(y.mant.Sub(Nat(1))));
+	return MakeInt(false, x.mant.And(y.mant.Sub(Nat(1))))
 }
 
 
@@ -408,16 +408,16 @@ func (x *Integer) Or(y *Integer) *Integer {
 		}
 
 		// x | y == x | y
-		return MakeInt(false, x.mant.Or(y.mant));
+		return MakeInt(false, x.mant.Or(y.mant))
 	}
 
 	// x.sign != y.sign
 	if x.sign {
-		x, y = y, x	// | or symmetric
+		x, y = y, x // | or symmetric
 	}
 
 	// x | (-y) == x | ^(y-1) == ^((y-1) &^ x) == -(^((y-1) &^ x) + 1)
-	return MakeInt(true, y.mant.Sub(Nat(1)).AndNot(x.mant).Add(Nat(1)));
+	return MakeInt(true, y.mant.Sub(Nat(1)).AndNot(x.mant).Add(Nat(1)))
 }
 
 
@@ -431,16 +431,16 @@ func (x *Integer) Xor(y *Integer) *Integer {
 		}
 
 		// x ^ y == x ^ y
-		return MakeInt(false, x.mant.Xor(y.mant));
+		return MakeInt(false, x.mant.Xor(y.mant))
 	}
 
 	// x.sign != y.sign
 	if x.sign {
-		x, y = y, x	// ^ is symmetric
+		x, y = y, x // ^ is symmetric
 	}
 
 	// x ^ (-y) == x ^ ^(y-1) == ^(x ^ (y-1)) == -((x ^ (y-1)) + 1)
-	return MakeInt(true, x.mant.Xor(y.mant.Sub(Nat(1))).Add(Nat(1)));
+	return MakeInt(true, x.mant.Xor(y.mant.Sub(Nat(1))).Add(Nat(1)))
 }
 
 
@@ -455,10 +455,10 @@ func (x *Integer) Cmp(y *Integer) int {
 	// x cmp (-y) == x
 	// (-x) cmp y == y
 	// (-x) cmp (-y) == -(x cmp y)
-	var r int;
+	var r int
 	switch {
 	case x.sign == y.sign:
-		r = x.mant.Cmp(y.mant);
+		r = x.mant.Cmp(y.mant)
 		if x.sign {
 			r = -r
 		}
@@ -467,7 +467,7 @@ func (x *Integer) Cmp(y *Integer) int {
 	case y.sign:
 		r = 1
 	}
-	return r;
+	return r
 }
 
 
@@ -477,24 +477,24 @@ func (x *Integer) ToString(base uint) string {
 	if x.mant.IsZero() {
 		return "0"
 	}
-	var s string;
+	var s string
 	if x.sign {
 		s = "-"
 	}
-	return s + x.mant.ToString(base);
+	return s + x.mant.ToString(base)
 }
 
 
 // String converts x to its decimal string representation.
 // x.String() is the same as x.ToString(10).
 //
-func (x *Integer) String() string	{ return x.ToString(10) }
+func (x *Integer) String() string { return x.ToString(10) }
 
 
 // Format is a support routine for fmt.Formatter. It accepts
 // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal).
 //
-func (x *Integer) Format(h fmt.State, c int)	{ fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
+func (x *Integer) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
 
 
 // IntFromString returns the integer corresponding to the
@@ -509,12 +509,12 @@ func (x *Integer) Format(h fmt.State, c int)	{ fmt.Fprintf(h, "%s", x.ToString(f
 //
 func IntFromString(s string, base uint) (*Integer, uint, int) {
 	// skip sign, if any
-	i0 := 0;
+	i0 := 0
 	if len(s) > 0 && (s[0] == '-' || s[0] == '+') {
 		i0 = 1
 	}
 
-	mant, base, slen := NatFromString(s[i0:], base);
+	mant, base, slen := NatFromString(s[i0:], base)
 
-	return MakeInt(i0 > 0 && s[0] == '-', mant), base, i0 + slen;
+	return MakeInt(i0 > 0 && s[0] == '-', mant), base, i0 + slen
 }
diff --git a/src/pkg/bignum/nrdiv_test.go b/src/pkg/bignum/nrdiv_test.go
index 724eecec3..725b1acea 100644
--- a/src/pkg/bignum/nrdiv_test.go
+++ b/src/pkg/bignum/nrdiv_test.go
@@ -21,8 +21,8 @@ import "testing"
 // value of an fpNat x is x.m * 2^x.e .
 //
 type fpNat struct {
-	m	Natural;
-	e	int;
+	m Natural
+	e int
 }
 
 
@@ -34,16 +34,16 @@ func (x fpNat) sub(y fpNat) fpNat {
 	case d > 0:
 		return fpNat{x.m.Shl(uint(d)).Sub(y.m), y.e}
 	}
-	return fpNat{x.m.Sub(y.m), x.e};
+	return fpNat{x.m.Sub(y.m), x.e}
 }
 
 
 // mul2 computes x*2.
-func (x fpNat) mul2() fpNat	{ return fpNat{x.m, x.e + 1} }
+func (x fpNat) mul2() fpNat { return fpNat{x.m, x.e + 1} }
 
 
 // mul computes x*y.
-func (x fpNat) mul(y fpNat) fpNat	{ return fpNat{x.m.Mul(y.m), x.e + y.e} }
+func (x fpNat) mul(y fpNat) fpNat { return fpNat{x.m.Mul(y.m), x.e + y.e} }
 
 
 // mant computes the (possibly truncated) Natural representation
@@ -56,7 +56,7 @@ func (x fpNat) mant() Natural {
 	case x.e < 0:
 		return x.m.Shr(uint(-x.e))
 	}
-	return x.m;
+	return x.m
 }
 
 
@@ -65,8 +65,8 @@ func (x fpNat) mant() Natural {
 //
 func nrDivEst(x0, y0 Natural) Natural {
 	if y0.IsZero() {
-		panic("division by zero");
-		return nil;
+		panic("division by zero")
+		return nil
 	}
 	// y0 > 0
 
@@ -84,78 +84,78 @@ func nrDivEst(x0, y0 Natural) Natural {
 	// x0 > y0 > 1
 
 	// Determine maximum result length.
-	maxLen := int(x0.Log2() - y0.Log2() + 1);
+	maxLen := int(x0.Log2() - y0.Log2() + 1)
 
 	// In the following, each number x is represented
 	// as a mantissa x.m and an exponent x.e such that
 	// x = xm * 2^x.e.
-	x := fpNat{x0, 0};
-	y := fpNat{y0, 0};
+	x := fpNat{x0, 0}
+	y := fpNat{y0, 0}
 
 	// Determine a scale factor f = 2^e such that
 	// 0.5 <= y/f == y*(2^-e) < 1.0
 	// and scale y accordingly.
-	e := int(y.m.Log2()) + 1;
-	y.e -= e;
+	e := int(y.m.Log2()) + 1
+	y.e -= e
 
 	// t1
-	var c = 2.9142;
-	const n = 14;
-	t1 := fpNat{Nat(uint64(c * (1 << n))), -n};
+	var c = 2.9142
+	const n = 14
+	t1 := fpNat{Nat(uint64(c * (1 << n))), -n}
 
 	// Compute initial value r0 for the reciprocal of y/f.
 	// r0 = t1 - 2*y
-	r := t1.sub(y.mul2());
-	two := fpNat{Nat(2), 0};
+	r := t1.sub(y.mul2())
+	two := fpNat{Nat(2), 0}
 
 	// Newton-Raphson iteration
-	p := Nat(0);
+	p := Nat(0)
 	for i := 0; ; i++ {
 		// check if we are done
 		// TODO: Need to come up with a better test here
 		//       as it will reduce computation time significantly.
 		// q = x*r/f
-		q := x.mul(r);
-		q.e -= e;
-		res := q.mant();
+		q := x.mul(r)
+		q.e -= e
+		res := q.mant()
 		if res.Cmp(p) == 0 {
 			return res
 		}
-		p = res;
+		p = res
 
 		// r' = r*(2 - y*r)
-		r = r.mul(two.sub(y.mul(r)));
+		r = r.mul(two.sub(y.mul(r)))
 
 		// reduce mantissa size
 		// TODO: Find smaller bound as it will reduce
 		//       computation time massively.
-		d := int(r.m.Log2()+1) - maxLen;
+		d := int(r.m.Log2()+1) - maxLen
 		if d > 0 {
 			r = fpNat{r.m.Shr(uint(d)), r.e + d}
 		}
 	}
 
-	panic("unreachable");
-	return nil;
+	panic("unreachable")
+	return nil
 }
 
 
 func nrdiv(x, y Natural) (q, r Natural) {
-	q = nrDivEst(x, y);
-	r = x.Sub(y.Mul(q));
+	q = nrDivEst(x, y)
+	r = x.Sub(y.Mul(q))
 	// if r is too large, correct q and r
 	// (usually one iteration)
 	for r.Cmp(y) >= 0 {
-		q = q.Add(Nat(1));
-		r = r.Sub(y);
+		q = q.Add(Nat(1))
+		r = r.Sub(y)
 	}
-	return;
+	return
 }
 
 
 func div(t *testing.T, x, y Natural) {
-	q, r := nrdiv(x, y);
-	qx, rx := x.DivMod(y);
+	q, r := nrdiv(x, y)
+	qx, rx := x.DivMod(y)
 	if q.Cmp(qx) != 0 {
 		t.Errorf("x = %s, y = %s, got q = %s, want q = %s", x, y, q, qx)
 	}
@@ -165,24 +165,24 @@ func div(t *testing.T, x, y Natural) {
 }
 
 
-func idiv(t *testing.T, x0, y0 uint64)	{ div(t, Nat(x0), Nat(y0)) }
+func idiv(t *testing.T, x0, y0 uint64) { div(t, Nat(x0), Nat(y0)) }
 
 
 func TestNRDiv(t *testing.T) {
-	idiv(t, 17, 18);
-	idiv(t, 17, 17);
-	idiv(t, 17, 1);
-	idiv(t, 17, 16);
-	idiv(t, 17, 10);
-	idiv(t, 17, 9);
-	idiv(t, 17, 8);
-	idiv(t, 17, 5);
-	idiv(t, 17, 3);
-	idiv(t, 1025, 512);
-	idiv(t, 7489595, 2);
-	idiv(t, 5404679459, 78495);
-	idiv(t, 7484890589595, 7484890589594);
-	div(t, Fact(100), Fact(91));
-	div(t, Fact(1000), Fact(991));
+	idiv(t, 17, 18)
+	idiv(t, 17, 17)
+	idiv(t, 17, 1)
+	idiv(t, 17, 16)
+	idiv(t, 17, 10)
+	idiv(t, 17, 9)
+	idiv(t, 17, 8)
+	idiv(t, 17, 5)
+	idiv(t, 17, 3)
+	idiv(t, 1025, 512)
+	idiv(t, 7489595, 2)
+	idiv(t, 5404679459, 78495)
+	idiv(t, 7484890589595, 7484890589594)
+	div(t, Fact(100), Fact(91))
+	div(t, Fact(1000), Fact(991))
 	//div(t, Fact(10000), Fact(9991));  // takes too long - disabled for now
 }
diff --git a/src/pkg/bignum/rational.go b/src/pkg/bignum/rational.go
index 9e9c3a8e0..378585e5f 100644
--- a/src/pkg/bignum/rational.go
+++ b/src/pkg/bignum/rational.go
@@ -12,31 +12,31 @@ import "fmt"
 // Rational represents a quotient a/b of arbitrary precision.
 //
 type Rational struct {
-	a	*Integer;	// numerator
-	b	Natural;	// denominator
+	a *Integer // numerator
+	b Natural  // denominator
 }
 
 
 // MakeRat makes a rational number given a numerator a and a denominator b.
 //
 func MakeRat(a *Integer, b Natural) *Rational {
-	f := a.mant.Gcd(b);	// f > 0
+	f := a.mant.Gcd(b) // f > 0
 	if f.Cmp(Nat(1)) != 0 {
-		a = MakeInt(a.sign, a.mant.Div(f));
-		b = b.Div(f);
+		a = MakeInt(a.sign, a.mant.Div(f))
+		b = b.Div(f)
 	}
-	return &Rational{a, b};
+	return &Rational{a, b}
 }
 
 
 // Rat creates a small rational number with value a0/b0.
 //
 func Rat(a0 int64, b0 int64) *Rational {
-	a, b := Int(a0), Int(b0);
+	a, b := Int(a0), Int(b0)
 	if b.sign {
 		a = a.Neg()
 	}
-	return MakeRat(a, b.mant);
+	return MakeRat(a, b.mant)
 }
 
 
@@ -51,30 +51,30 @@ func (x *Rational) Value() (numerator *Integer, denominator Natural) {
 
 // IsZero returns true iff x == 0.
 //
-func (x *Rational) IsZero() bool	{ return x.a.IsZero() }
+func (x *Rational) IsZero() bool { return x.a.IsZero() }
 
 
 // IsNeg returns true iff x < 0.
 //
-func (x *Rational) IsNeg() bool	{ return x.a.IsNeg() }
+func (x *Rational) IsNeg() bool { return x.a.IsNeg() }
 
 
 // IsPos returns true iff x > 0.
 //
-func (x *Rational) IsPos() bool	{ return x.a.IsPos() }
+func (x *Rational) IsPos() bool { return x.a.IsPos() }
 
 
 // IsInt returns true iff x can be written with a denominator 1
 // in the form x == x'/1; i.e., if x is an integer value.
 //
-func (x *Rational) IsInt() bool	{ return x.b.Cmp(Nat(1)) == 0 }
+func (x *Rational) IsInt() bool { return x.b.Cmp(Nat(1)) == 0 }
 
 
 // Operations
 
 // Neg returns the negated value of x.
 //
-func (x *Rational) Neg() *Rational	{ return MakeRat(x.a.Neg(), x.b) }
+func (x *Rational) Neg() *Rational { return MakeRat(x.a.Neg(), x.b) }
 
 
 // Add returns the sum x + y.
@@ -93,19 +93,19 @@ func (x *Rational) Sub(y *Rational) *Rational {
 
 // Mul returns the product x * y.
 //
-func (x *Rational) Mul(y *Rational) *Rational	{ return MakeRat(x.a.Mul(y.a), x.b.Mul(y.b)) }
+func (x *Rational) Mul(y *Rational) *Rational { return MakeRat(x.a.Mul(y.a), x.b.Mul(y.b)) }
 
 
 // Quo returns the quotient x / y for y != 0.
 // If y == 0, a division-by-zero run-time error occurs.
 //
 func (x *Rational) Quo(y *Rational) *Rational {
-	a := x.a.MulNat(y.b);
-	b := y.a.MulNat(x.b);
+	a := x.a.MulNat(y.b)
+	b := y.a.MulNat(x.b)
 	if b.IsNeg() {
 		a = a.Neg()
 	}
-	return MakeRat(a, b.mant);
+	return MakeRat(a, b.mant)
 }
 
 
@@ -115,7 +115,7 @@ func (x *Rational) Quo(y *Rational) *Rational {
 //   == 0 if x == y
 //   >  0 if x >  y
 //
-func (x *Rational) Cmp(y *Rational) int	{ return (x.a.MulNat(y.b)).Cmp(y.a.MulNat(x.b)) }
+func (x *Rational) Cmp(y *Rational) int { return (x.a.MulNat(y.b)).Cmp(y.a.MulNat(x.b)) }
 
 
 // ToString converts x to a string for a given base, with 2 <= base <= 16.
@@ -123,24 +123,24 @@ func (x *Rational) Cmp(y *Rational) int	{ return (x.a.MulNat(y.b)).Cmp(y.a.MulNa
 // it is of form "n/d".
 //
 func (x *Rational) ToString(base uint) string {
-	s := x.a.ToString(base);
+	s := x.a.ToString(base)
 	if !x.IsInt() {
 		s += "/" + x.b.ToString(base)
 	}
-	return s;
+	return s
 }
 
 
 // String converts x to its decimal string representation.
 // x.String() is the same as x.ToString(10).
 //
-func (x *Rational) String() string	{ return x.ToString(10) }
+func (x *Rational) String() string { return x.ToString(10) }
 
 
 // Format is a support routine for fmt.Formatter. It accepts
 // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal).
 //
-func (x *Rational) Format(h fmt.State, c int)	{ fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
+func (x *Rational) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) }
 
 
 // RatFromString returns the rational number corresponding to the
@@ -164,35 +164,35 @@ func (x *Rational) Format(h fmt.State, c int)	{ fmt.Fprintf(h, "%s", x.ToString(
 //
 func RatFromString(s string, base uint) (*Rational, uint, int) {
 	// read numerator
-	a, abase, alen := IntFromString(s, base);
-	b := Nat(1);
+	a, abase, alen := IntFromString(s, base)
+	b := Nat(1)
 
 	// read denominator or fraction, if any
-	var blen int;
+	var blen int
 	if alen < len(s) {
-		ch := s[alen];
+		ch := s[alen]
 		if ch == '/' {
-			alen++;
-			b, base, blen = NatFromString(s[alen:], base);
+			alen++
+			b, base, blen = NatFromString(s[alen:], base)
 		} else if ch == '.' {
-			alen++;
-			b, base, blen = NatFromString(s[alen:], abase);
-			assert(base == abase);
-			f := Nat(uint64(base)).Pow(uint(blen));
-			a = MakeInt(a.sign, a.mant.Mul(f).Add(b));
-			b = f;
+			alen++
+			b, base, blen = NatFromString(s[alen:], abase)
+			assert(base == abase)
+			f := Nat(uint64(base)).Pow(uint(blen))
+			a = MakeInt(a.sign, a.mant.Mul(f).Add(b))
+			b = f
 		}
 	}
 
 	// read exponent, if any
-	rlen := alen + blen;
+	rlen := alen + blen
 	if rlen < len(s) {
-		ch := s[rlen];
+		ch := s[rlen]
 		if ch == 'e' || ch == 'E' {
-			rlen++;
-			e, _, elen := IntFromString(s[rlen:], 10);
-			rlen += elen;
-			m := Nat(10).Pow(uint(e.mant.Value()));
+			rlen++
+			e, _, elen := IntFromString(s[rlen:], 10)
+			rlen += elen
+			m := Nat(10).Pow(uint(e.mant.Value()))
 			if e.sign {
 				b = b.Mul(m)
 			} else {
@@ -201,5 +201,5 @@ func RatFromString(s string, base uint) (*Rational, uint, int) {
 		}
 	}
 
-	return MakeRat(a, b), base, rlen;
+	return MakeRat(a, b), base, rlen
 }
diff --git a/src/pkg/bufio/bufio.go b/src/pkg/bufio/bufio.go
index 782bfe2c4..00bc53cd7 100644
--- a/src/pkg/bufio/bufio.go
+++ b/src/pkg/bufio/bufio.go
@@ -8,27 +8,27 @@
 package bufio
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"strconv";
-	"utf8";
+	"bytes"
+	"io"
+	"os"
+	"strconv"
+	"utf8"
 )
 
 
 const (
-	defaultBufSize = 4096;
+	defaultBufSize = 4096
 )
 
 // Errors introduced by this package.
 type Error struct {
-	os.ErrorString;
+	os.ErrorString
 }
 
 var (
-	ErrInvalidUnreadByte	os.Error	= &Error{"bufio: invalid use of UnreadByte"};
-	ErrBufferFull		os.Error	= &Error{"bufio: buffer full"};
-	errInternal		os.Error	= &Error{"bufio: internal error"};
+	ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}
+	ErrBufferFull        os.Error = &Error{"bufio: buffer full"}
+	errInternal          os.Error = &Error{"bufio: internal error"}
 )
 
 // BufSizeError is the error representing an invalid buffer size.
@@ -43,11 +43,11 @@ func (b BufSizeError) String() string {
 
 // Reader implements buffering for an io.Reader object.
 type Reader struct {
-	buf		[]byte;
-	rd		io.Reader;
-	r, w		int;
-	err		os.Error;
-	lastbyte	int;
+	buf      []byte
+	rd       io.Reader
+	r, w     int
+	err      os.Error
+	lastbyte int
 }
 
 // NewReaderSize creates a new Reader whose buffer has the specified size,
@@ -59,41 +59,41 @@ func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
 		return nil, BufSizeError(size)
 	}
 	// Is it already a Reader?
-	b, ok := rd.(*Reader);
+	b, ok := rd.(*Reader)
 	if ok && len(b.buf) >= size {
 		return b, nil
 	}
-	b = new(Reader);
-	b.buf = make([]byte, size);
-	b.rd = rd;
-	b.lastbyte = -1;
-	return b, nil;
+	b = new(Reader)
+	b.buf = make([]byte, size)
+	b.rd = rd
+	b.lastbyte = -1
+	return b, nil
 }
 
 // NewReader returns a new Reader whose buffer has the default size.
 func NewReader(rd io.Reader) *Reader {
-	b, err := NewReaderSize(rd, defaultBufSize);
+	b, err := NewReaderSize(rd, defaultBufSize)
 	if err != nil {
 		// cannot happen - defaultBufSize is a valid size
 		panic("bufio: NewReader: ", err.String())
 	}
-	return b;
+	return b
 }
 
 // fill reads a new chunk into the buffer.
 func (b *Reader) fill() {
 	// Slide existing data to beginning.
 	if b.w > b.r {
-		copy(b.buf[0:b.w-b.r], b.buf[b.r:b.w]);
-		b.w -= b.r;
+		copy(b.buf[0:b.w-b.r], b.buf[b.r:b.w])
+		b.w -= b.r
 	} else {
 		b.w = 0
 	}
-	b.r = 0;
+	b.r = 0
 
 	// Read new data.
-	n, e := b.rd.Read(b.buf[b.w:]);
-	b.w += n;
+	n, e := b.rd.Read(b.buf[b.w:])
+	b.w += n
 	if e != nil {
 		b.err = e
 	}
@@ -105,9 +105,9 @@ func (b *Reader) fill() {
 // why the read is short.  At EOF, the count will be
 // zero and err will be os.EOF.
 func (b *Reader) Read(p []byte) (nn int, err os.Error) {
-	nn = 0;
+	nn = 0
 	for len(p) > 0 {
-		n := len(p);
+		n := len(p)
 		if b.w == b.r {
 			if b.err != nil {
 				return nn, b.err
@@ -115,27 +115,27 @@ func (b *Reader) Read(p []byte) (nn int, err os.Error) {
 			if len(p) >= len(b.buf) {
 				// Large read, empty buffer.
 				// Read directly into p to avoid copy.
-				n, b.err = b.rd.Read(p);
+				n, b.err = b.rd.Read(p)
 				if n > 0 {
 					b.lastbyte = int(p[n-1])
 				}
-				p = p[n:];
-				nn += n;
-				continue;
+				p = p[n:]
+				nn += n
+				continue
 			}
-			b.fill();
-			continue;
+			b.fill()
+			continue
 		}
 		if n > b.w-b.r {
 			n = b.w - b.r
 		}
-		copy(p[0:n], b.buf[b.r:b.r+n]);
-		p = p[n:];
-		b.r += n;
-		b.lastbyte = int(b.buf[b.r-1]);
-		nn += n;
+		copy(p[0:n], b.buf[b.r:b.r+n])
+		p = p[n:]
+		b.r += n
+		b.lastbyte = int(b.buf[b.r-1])
+		nn += n
 	}
-	return nn, nil;
+	return nn, nil
 }
 
 // ReadByte reads and returns a single byte.
@@ -145,29 +145,29 @@ func (b *Reader) ReadByte() (c byte, err os.Error) {
 		if b.err != nil {
 			return 0, b.err
 		}
-		b.fill();
+		b.fill()
 	}
-	c = b.buf[b.r];
-	b.r++;
-	b.lastbyte = int(c);
-	return c, nil;
+	c = b.buf[b.r]
+	b.r++
+	b.lastbyte = int(c)
+	return c, nil
 }
 
 // UnreadByte unreads the last byte.  Only the most recently read byte can be unread.
 func (b *Reader) UnreadByte() os.Error {
 	if b.r == b.w && b.lastbyte >= 0 {
-		b.w = 1;
-		b.r = 0;
-		b.buf[0] = byte(b.lastbyte);
-		b.lastbyte = -1;
-		return nil;
+		b.w = 1
+		b.r = 0
+		b.buf[0] = byte(b.lastbyte)
+		b.lastbyte = -1
+		return nil
 	}
 	if b.r <= 0 {
 		return ErrInvalidUnreadByte
 	}
-	b.r--;
-	b.lastbyte = -1;
-	return nil;
+	b.r--
+	b.lastbyte = -1
+	return nil
 }
 
 // ReadRune reads a single UTF-8 encoded Unicode character and returns the
@@ -179,17 +179,17 @@ func (b *Reader) ReadRune() (rune int, size int, err os.Error) {
 	if b.r == b.w {
 		return 0, 0, b.err
 	}
-	rune, size = int(b.buf[b.r]), 1;
+	rune, size = int(b.buf[b.r]), 1
 	if rune >= 0x80 {
 		rune, size = utf8.DecodeRune(b.buf[b.r:b.w])
 	}
-	b.r += size;
-	b.lastbyte = int(b.buf[b.r-1]);
-	return rune, size, nil;
+	b.r += size
+	b.lastbyte = int(b.buf[b.r-1])
+	return rune, size, nil
 }
 
 // Buffered returns the number of bytes that can be read from the current buffer.
-func (b *Reader) Buffered() int	{ return b.w - b.r }
+func (b *Reader) Buffered() int { return b.w - b.r }
 
 // ReadSlice reads until the first occurrence of delim in the input,
 // returning a slice pointing at the bytes in the buffer.
@@ -204,27 +204,27 @@ func (b *Reader) Buffered() int	{ return b.w - b.r }
 func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
 	// Look in buffer.
 	if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
-		line1 := b.buf[b.r : b.r+i+1];
-		b.r += i + 1;
-		return line1, nil;
+		line1 := b.buf[b.r : b.r+i+1]
+		b.r += i + 1
+		return line1, nil
 	}
 
 	// Read more into buffer, until buffer fills or we find delim.
 	for {
 		if b.err != nil {
-			line := b.buf[b.r:b.w];
-			b.r = b.w;
-			return line, b.err;
+			line := b.buf[b.r:b.w]
+			b.r = b.w
+			return line, b.err
 		}
 
-		n := b.Buffered();
-		b.fill();
+		n := b.Buffered()
+		b.fill()
 
 		// Search new part of buffer
 		if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 {
-			line := b.buf[0 : n+i+1];
-			b.r = n + i + 1;
-			return line, nil;
+			line := b.buf[0 : n+i+1]
+			b.r = n + i + 1
+			return line, nil
 		}
 
 		// Buffer is full?
@@ -232,7 +232,7 @@ func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
 			return nil, ErrBufferFull
 		}
 	}
-	panic("not reached");
+	panic("not reached")
 }
 
 // ReadBytes reads until the first occurrence of delim in the input,
@@ -243,69 +243,69 @@ func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
 func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
 	// Use ReadSlice to look for array,
 	// accumulating full buffers.
-	var frag []byte;
-	var full [][]byte;
-	nfull := 0;
-	err = nil;
+	var frag []byte
+	var full [][]byte
+	nfull := 0
+	err = nil
 
 	for {
-		var e os.Error;
-		frag, e = b.ReadSlice(delim);
-		if e == nil {	// got final fragment
+		var e os.Error
+		frag, e = b.ReadSlice(delim)
+		if e == nil { // got final fragment
 			break
 		}
-		if e != ErrBufferFull {	// unexpected error
-			err = e;
-			break;
+		if e != ErrBufferFull { // unexpected error
+			err = e
+			break
 		}
 
 		// Read bytes out of buffer.
-		buf := make([]byte, b.Buffered());
-		var n int;
-		n, e = b.Read(buf);
+		buf := make([]byte, b.Buffered())
+		var n int
+		n, e = b.Read(buf)
 		if e != nil {
-			frag = buf[0:n];
-			err = e;
-			break;
+			frag = buf[0:n]
+			err = e
+			break
 		}
 		if n != len(buf) {
-			frag = buf[0:n];
-			err = errInternal;
-			break;
+			frag = buf[0:n]
+			err = errInternal
+			break
 		}
 
 		// Grow list if needed.
 		if full == nil {
 			full = make([][]byte, 16)
 		} else if nfull >= len(full) {
-			newfull := make([][]byte, len(full)*2);
+			newfull := make([][]byte, len(full)*2)
 			for i := 0; i < len(full); i++ {
 				newfull[i] = full[i]
 			}
-			full = newfull;
+			full = newfull
 		}
 
 		// Save buffer
-		full[nfull] = buf;
-		nfull++;
+		full[nfull] = buf
+		nfull++
 	}
 
 	// Allocate new buffer to hold the full pieces and the fragment.
-	n := 0;
+	n := 0
 	for i := 0; i < nfull; i++ {
 		n += len(full[i])
 	}
-	n += len(frag);
+	n += len(frag)
 
 	// Copy full pieces and fragment in.
-	buf := make([]byte, n);
-	n = 0;
+	buf := make([]byte, n)
+	n = 0
 	for i := 0; i < nfull; i++ {
-		copy(buf[n:n+len(full[i])], full[i]);
-		n += len(full[i]);
+		copy(buf[n:n+len(full[i])], full[i])
+		n += len(full[i])
 	}
-	copy(buf[n:n+len(frag)], frag);
-	return buf, err;
+	copy(buf[n:n+len(frag)], frag)
+	return buf, err
 }
 
 // ReadString reads until the first occurrence of delim in the input,
@@ -314,8 +314,8 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadString returns err != nil if and only if line does not end in delim.
 func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
-	bytes, e := b.ReadBytes(delim);
-	return string(bytes), e;
+	bytes, e := b.ReadBytes(delim)
+	return string(bytes), e
 }
 
 
@@ -323,10 +323,10 @@ func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
 
 // Writer implements buffering for an io.Writer object.
 type Writer struct {
-	err	os.Error;
-	buf	[]byte;
-	n	int;
-	wr	io.Writer;
+	err os.Error
+	buf []byte
+	n   int
+	wr  io.Writer
 }
 
 // NewWriterSize creates a new Writer whose buffer has the specified size,
@@ -338,24 +338,24 @@ func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
 		return nil, BufSizeError(size)
 	}
 	// Is it already a Writer?
-	b, ok := wr.(*Writer);
+	b, ok := wr.(*Writer)
 	if ok && len(b.buf) >= size {
 		return b, nil
 	}
-	b = new(Writer);
-	b.buf = make([]byte, size);
-	b.wr = wr;
-	return b, nil;
+	b = new(Writer)
+	b.buf = make([]byte, size)
+	b.wr = wr
+	return b, nil
 }
 
 // NewWriter returns a new Writer whose buffer has the default size.
 func NewWriter(wr io.Writer) *Writer {
-	b, err := NewWriterSize(wr, defaultBufSize);
+	b, err := NewWriterSize(wr, defaultBufSize)
 	if err != nil {
 		// cannot happen - defaultBufSize is valid size
 		panic("bufio: NewWriter: ", err.String())
 	}
-	return b;
+	return b
 }
 
 // Flush writes any buffered data to the underlying io.Writer.
@@ -363,7 +363,7 @@ func (b *Writer) Flush() os.Error {
 	if b.err != nil {
 		return b.err
 	}
-	n, e := b.wr.Write(b.buf[0:b.n]);
+	n, e := b.wr.Write(b.buf[0:b.n])
 	if n < b.n && e == nil {
 		e = io.ErrShortWrite
 	}
@@ -371,19 +371,19 @@ func (b *Writer) Flush() os.Error {
 		if n > 0 && n < b.n {
 			copy(b.buf[0:b.n-n], b.buf[n:b.n])
 		}
-		b.n -= n;
-		b.err = e;
-		return e;
+		b.n -= n
+		b.err = e
+		return e
 	}
-	b.n = 0;
-	return nil;
+	b.n = 0
+	return nil
 }
 
 // Available returns how many bytes are unused in the buffer.
-func (b *Writer) Available() int	{ return len(b.buf) - b.n }
+func (b *Writer) Available() int { return len(b.buf) - b.n }
 
 // Buffered returns the number of bytes that have been written into the current buffer.
-func (b *Writer) Buffered() int	{ return b.n }
+func (b *Writer) Buffered() int { return b.n }
 
 // Write writes the contents of p into the buffer.
 // It returns the number of bytes written.
@@ -393,35 +393,35 @@ func (b *Writer) Write(p []byte) (nn int, err os.Error) {
 	if b.err != nil {
 		return 0, b.err
 	}
-	nn = 0;
+	nn = 0
 	for len(p) > 0 {
-		n := b.Available();
+		n := b.Available()
 		if n <= 0 {
 			if b.Flush(); b.err != nil {
 				break
 			}
-			n = b.Available();
+			n = b.Available()
 		}
 		if b.Available() == 0 && len(p) >= len(b.buf) {
 			// Large write, empty buffer.
 			// Write directly from p to avoid copy.
-			n, b.err = b.wr.Write(p);
-			nn += n;
-			p = p[n:];
+			n, b.err = b.wr.Write(p)
+			nn += n
+			p = p[n:]
 			if b.err != nil {
 				break
 			}
-			continue;
+			continue
 		}
 		if n > len(p) {
 			n = len(p)
 		}
-		copy(b.buf[b.n:b.n+n], p[0:n]);
-		b.n += n;
-		nn += n;
-		p = p[n:];
+		copy(b.buf[b.n:b.n+n], p[0:n])
+		b.n += n
+		nn += n
+		p = p[n:]
 	}
-	return nn, b.err;
+	return nn, b.err
 }
 
 // WriteByte writes a single byte.
@@ -432,9 +432,9 @@ func (b *Writer) WriteByte(c byte) os.Error {
 	if b.Available() <= 0 && b.Flush() != nil {
 		return b.err
 	}
-	b.buf[b.n] = c;
-	b.n++;
-	return nil;
+	b.buf[b.n] = c
+	b.n++
+	return nil
 }
 
 // WriteString writes a string.
@@ -444,16 +444,16 @@ func (b *Writer) WriteString(s string) os.Error {
 	}
 	// Common case, worth making fast.
 	if b.Available() >= len(s) || len(b.buf) >= len(s) && b.Flush() == nil {
-		for i := 0; i < len(s); i++ {	// loop over bytes, not runes.
-			b.buf[b.n] = s[i];
-			b.n++;
+		for i := 0; i < len(s); i++ { // loop over bytes, not runes.
+			b.buf[b.n] = s[i]
+			b.n++
 		}
-		return nil;
+		return nil
 	}
-	for i := 0; i < len(s); i++ {	// loop over bytes, not runes.
+	for i := 0; i < len(s); i++ { // loop over bytes, not runes.
 		b.WriteByte(s[i])
 	}
-	return b.err;
+	return b.err
 }
 
 // buffered input and output
@@ -461,8 +461,8 @@ func (b *Writer) WriteString(s string) os.Error {
 // ReadWriter stores pointers to a Reader and a Writer.
 // It implements io.ReadWriter.
 type ReadWriter struct {
-	*Reader;
-	*Writer;
+	*Reader
+	*Writer
 }
 
 // NewReadWriter allocates a new ReadWriter that dispatches to r and w.
diff --git a/src/pkg/bufio/bufio_test.go b/src/pkg/bufio/bufio_test.go
index bdd4800b4..83152e926 100644
--- a/src/pkg/bufio/bufio_test.go
+++ b/src/pkg/bufio/bufio_test.go
@@ -5,68 +5,68 @@
 package bufio
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"os";
-	"strings";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"testing"
+	"testing/iotest"
 )
 
 // Reads from a reader and rot13s the result.
 type rot13Reader struct {
-	r io.Reader;
+	r io.Reader
 }
 
 func newRot13Reader(r io.Reader) *rot13Reader {
-	r13 := new(rot13Reader);
-	r13.r = r;
-	return r13;
+	r13 := new(rot13Reader)
+	r13.r = r
+	return r13
 }
 
 func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
-	n, e := r13.r.Read(p);
+	n, e := r13.r.Read(p)
 	if e != nil {
 		return n, e
 	}
 	for i := 0; i < n; i++ {
-		c := p[i] | 0x20;	// lowercase byte
+		c := p[i] | 0x20 // lowercase byte
 		if 'a' <= c && c <= 'm' {
 			p[i] += 13
 		} else if 'n' <= c && c <= 'z' {
 			p[i] -= 13
 		}
 	}
-	return n, nil;
+	return n, nil
 }
 
 // Call ReadByte to accumulate the text of a file
 func readBytes(buf *Reader) string {
-	var b [1000]byte;
-	nb := 0;
+	var b [1000]byte
+	nb := 0
 	for {
-		c, e := buf.ReadByte();
+		c, e := buf.ReadByte()
 		if e == os.EOF {
 			break
 		}
 		if e != nil {
 			panic("Data: " + e.String())
 		}
-		b[nb] = c;
-		nb++;
+		b[nb] = c
+		nb++
 	}
-	return string(b[0:nb]);
+	return string(b[0:nb])
 }
 
 func TestReaderSimple(t *testing.T) {
-	data := "hello world";
-	b := NewReader(bytes.NewBufferString(data));
+	data := "hello world"
+	b := NewReader(bytes.NewBufferString(data))
 	if s := readBytes(b); s != "hello world" {
 		t.Errorf("simple hello world test failed: got %q", s)
 	}
 
-	b = NewReader(newRot13Reader(bytes.NewBufferString(data)));
+	b = NewReader(newRot13Reader(bytes.NewBufferString(data)))
 	if s := readBytes(b); s != "uryyb jbeyq" {
 		t.Error("rot13 hello world test failed: got %q", s)
 	}
@@ -74,8 +74,8 @@ func TestReaderSimple(t *testing.T) {
 
 
 type readMaker struct {
-	name	string;
-	fn	func(io.Reader) io.Reader;
+	name string
+	fn   func(io.Reader) io.Reader
 }
 
 var readMakers = []readMaker{
@@ -88,37 +88,37 @@ var readMakers = []readMaker{
 // Call ReadString (which ends up calling everything else)
 // to accumulate the text of a file.
 func readLines(b *Reader) string {
-	s := "";
+	s := ""
 	for {
-		s1, e := b.ReadString('\n');
+		s1, e := b.ReadString('\n')
 		if e == os.EOF {
 			break
 		}
 		if e != nil {
 			panic("GetLines: " + e.String())
 		}
-		s += s1;
+		s += s1
 	}
-	return s;
+	return s
 }
 
 // Call Read to accumulate the text of a file
 func reads(buf *Reader, m int) string {
-	var b [1000]byte;
-	nb := 0;
+	var b [1000]byte
+	nb := 0
 	for {
-		n, e := buf.Read(b[nb : nb+m]);
-		nb += n;
+		n, e := buf.Read(b[nb : nb+m])
+		nb += n
 		if e == os.EOF {
 			break
 		}
 	}
-	return string(b[0:nb]);
+	return string(b[0:nb])
 }
 
 type bufReader struct {
-	name	string;
-	fn	func(*Reader) string;
+	name string
+	fn   func(*Reader) string
 }
 
 var bufreaders = []bufReader{
@@ -138,27 +138,27 @@ var bufsizes = []int{
 }
 
 func TestReader(t *testing.T) {
-	var texts [31]string;
-	str := "";
-	all := "";
+	var texts [31]string
+	str := ""
+	all := ""
 	for i := 0; i < len(texts)-1; i++ {
-		texts[i] = str + "\n";
-		all += texts[i];
-		str += string(i%26 + 'a');
+		texts[i] = str + "\n"
+		all += texts[i]
+		str += string(i%26 + 'a')
 	}
-	texts[len(texts)-1] = all;
+	texts[len(texts)-1] = all
 
 	for h := 0; h < len(texts); h++ {
-		text := texts[h];
+		text := texts[h]
 		for i := 0; i < len(readMakers); i++ {
 			for j := 0; j < len(bufreaders); j++ {
 				for k := 0; k < len(bufsizes); k++ {
-					readmaker := readMakers[i];
-					bufreader := bufreaders[j];
-					bufsize := bufsizes[k];
-					read := readmaker.fn(bytes.NewBufferString(text));
-					buf, _ := NewReaderSize(read, bufsize);
-					s := bufreader.fn(buf);
+					readmaker := readMakers[i]
+					bufreader := bufreaders[j]
+					bufsize := bufsizes[k]
+					read := readmaker.fn(bytes.NewBufferString(text))
+					buf, _ := NewReaderSize(read, bufsize)
+					s := bufreader.fn(buf)
 					if s != text {
 						t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
 							readmaker.name, bufreader.name, bufsize, text, s)
@@ -171,37 +171,37 @@ func TestReader(t *testing.T) {
 
 // A StringReader delivers its data one string segment at a time via Read.
 type StringReader struct {
-	data	[]string;
-	step	int;
+	data []string
+	step int
 }
 
 func (r *StringReader) Read(p []byte) (n int, err os.Error) {
 	if r.step < len(r.data) {
-		s := r.data[r.step];
+		s := r.data[r.step]
 		for i := 0; i < len(s); i++ {
 			p[i] = s[i]
 		}
-		n = len(s);
-		r.step++;
+		n = len(s)
+		r.step++
 	} else {
 		err = os.EOF
 	}
-	return;
+	return
 }
 
 func readRuneSegments(t *testing.T, segments []string) {
-	got := "";
-	want := strings.Join(segments, "");
-	r := NewReader(&StringReader{data: segments});
+	got := ""
+	want := strings.Join(segments, "")
+	r := NewReader(&StringReader{data: segments})
 	for {
-		rune, _, err := r.ReadRune();
+		rune, _, err := r.ReadRune()
 		if err != nil {
 			if err != os.EOF {
 				return
 			}
-			break;
+			break
 		}
-		got += string(rune);
+		got += string(rune)
 	}
 	if got != want {
 		t.Errorf("segments=%v got=%s want=%s", segments, got, want)
@@ -226,46 +226,46 @@ func TestReadRune(t *testing.T) {
 }
 
 func TestWriter(t *testing.T) {
-	var data [8192]byte;
+	var data [8192]byte
 
 	for i := 0; i < len(data); i++ {
 		data[i] = byte(' ' + i%('~'-' '))
 	}
-	w := new(bytes.Buffer);
+	w := new(bytes.Buffer)
 	for i := 0; i < len(bufsizes); i++ {
 		for j := 0; j < len(bufsizes); j++ {
-			nwrite := bufsizes[i];
-			bs := bufsizes[j];
+			nwrite := bufsizes[i]
+			bs := bufsizes[j]
 
 			// Write nwrite bytes using buffer size bs.
 			// Check that the right amount makes it out
 			// and that the data is correct.
 
-			w.Reset();
-			buf, e := NewWriterSize(w, bs);
-			context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs);
+			w.Reset()
+			buf, e := NewWriterSize(w, bs)
+			context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
 			if e != nil {
-				t.Errorf("%s: NewWriterSize %d: %v", context, bs, e);
-				continue;
+				t.Errorf("%s: NewWriterSize %d: %v", context, bs, e)
+				continue
 			}
-			n, e1 := buf.Write(data[0:nwrite]);
+			n, e1 := buf.Write(data[0:nwrite])
 			if e1 != nil || n != nwrite {
-				t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1);
-				continue;
+				t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1)
+				continue
 			}
 			if e = buf.Flush(); e != nil {
 				t.Errorf("%s: buf.Flush = %v", context, e)
 			}
 
-			written := w.Bytes();
+			written := w.Bytes()
 			if len(written) != nwrite {
 				t.Errorf("%s: %d bytes written", context, len(written))
 			}
 			for l := 0; l < len(written); l++ {
 				if written[i] != data[i] {
-					t.Errorf("%s: wrong bytes written");
-					t.Errorf("want=%s", data[0:len(written)]);
-					t.Errorf("have=%s", written);
+					t.Errorf("%s: wrong bytes written")
+					t.Errorf("want=%s", data[0:len(written)])
+					t.Errorf("have=%s", written)
 				}
 			}
 		}
@@ -275,9 +275,9 @@ func TestWriter(t *testing.T) {
 // Check that write errors are returned properly.
 
 type errorWriterTest struct {
-	n, m	int;
-	err	os.Error;
-	expect	os.Error;
+	n, m   int
+	err    os.Error
+	expect os.Error
 }
 
 func (w errorWriterTest) Write(p []byte) (int, os.Error) {
@@ -295,13 +295,13 @@ var errorWriterTests = []errorWriterTest{
 
 func TestWriteErrors(t *testing.T) {
 	for _, w := range errorWriterTests {
-		buf := NewWriter(w);
-		_, e := buf.Write(strings.Bytes("hello world"));
+		buf := NewWriter(w)
+		_, e := buf.Write(strings.Bytes("hello world"))
 		if e != nil {
-			t.Errorf("Write hello to %v: %v", w, e);
-			continue;
+			t.Errorf("Write hello to %v: %v", w, e)
+			continue
 		}
-		e = buf.Flush();
+		e = buf.Flush()
 		if e != w.expect {
 			t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
 		}
@@ -309,13 +309,13 @@ func TestWriteErrors(t *testing.T) {
 }
 
 func TestNewReaderSizeIdempotent(t *testing.T) {
-	const BufSize = 1000;
-	b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize);
+	const BufSize = 1000
+	b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize)
 	if err != nil {
 		t.Error("NewReaderSize create fail", err)
 	}
 	// Does it recognize itself?
-	b1, err2 := NewReaderSize(b, BufSize);
+	b1, err2 := NewReaderSize(b, BufSize)
 	if err2 != nil {
 		t.Error("NewReaderSize #2 create fail", err2)
 	}
@@ -323,7 +323,7 @@ func TestNewReaderSizeIdempotent(t *testing.T) {
 		t.Error("NewReaderSize did not detect underlying Reader")
 	}
 	// Does it wrap if existing buffer is too small?
-	b2, err3 := NewReaderSize(b, 2*BufSize);
+	b2, err3 := NewReaderSize(b, 2*BufSize)
 	if err3 != nil {
 		t.Error("NewReaderSize #3 create fail", err3)
 	}
@@ -333,13 +333,13 @@ func TestNewReaderSizeIdempotent(t *testing.T) {
 }
 
 func TestNewWriterSizeIdempotent(t *testing.T) {
-	const BufSize = 1000;
-	b, err := NewWriterSize(new(bytes.Buffer), BufSize);
+	const BufSize = 1000
+	b, err := NewWriterSize(new(bytes.Buffer), BufSize)
 	if err != nil {
 		t.Error("NewWriterSize create fail", err)
 	}
 	// Does it recognize itself?
-	b1, err2 := NewWriterSize(b, BufSize);
+	b1, err2 := NewWriterSize(b, BufSize)
 	if err2 != nil {
 		t.Error("NewWriterSize #2 create fail", err2)
 	}
@@ -347,7 +347,7 @@ func TestNewWriterSizeIdempotent(t *testing.T) {
 		t.Error("NewWriterSize did not detect underlying Writer")
 	}
 	// Does it wrap if existing buffer is too small?
-	b2, err3 := NewWriterSize(b, 2*BufSize);
+	b2, err3 := NewWriterSize(b, 2*BufSize)
 	if err3 != nil {
 		t.Error("NewWriterSize #3 create fail", err3)
 	}
@@ -357,22 +357,22 @@ func TestNewWriterSizeIdempotent(t *testing.T) {
 }
 
 func TestWriteString(t *testing.T) {
-	const BufSize = 8;
-	buf := new(bytes.Buffer);
-	b, err := NewWriterSize(buf, BufSize);
+	const BufSize = 8
+	buf := new(bytes.Buffer)
+	b, err := NewWriterSize(buf, BufSize)
 	if err != nil {
 		t.Error("NewWriterSize create fail", err)
 	}
-	b.WriteString("0");				// easy
-	b.WriteString("123456");			// still easy
-	b.WriteString("7890");				// easy after flush
-	b.WriteString("abcdefghijklmnopqrstuvwxy");	// hard
-	b.WriteString("z");
-	b.Flush();
+	b.WriteString("0")                         // easy
+	b.WriteString("123456")                    // still easy
+	b.WriteString("7890")                      // easy after flush
+	b.WriteString("abcdefghijklmnopqrstuvwxy") // hard
+	b.WriteString("z")
+	b.Flush()
 	if b.err != nil {
 		t.Error("WriteString", b.err)
 	}
-	s := "01234567890abcdefghijklmnopqrstuvwxyz";
+	s := "01234567890abcdefghijklmnopqrstuvwxyz"
 	if string(buf.Bytes()) != s {
 		t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
 	}
diff --git a/src/pkg/bytes/buffer.go b/src/pkg/bytes/buffer.go
index b302b65fa..bbca70b06 100644
--- a/src/pkg/bytes/buffer.go
+++ b/src/pkg/bytes/buffer.go
@@ -7,15 +7,15 @@ package bytes
 // Simple byte buffer for marshaling data.
 
 import (
-	"io";
-	"os";
+	"io"
+	"os"
 )
 
 // Copy from string to byte array at offset doff.  Assume there's room.
 func copyString(dst []byte, doff int, str string) {
 	for soff := 0; soff < len(str); soff++ {
-		dst[doff] = str[soff];
-		doff++;
+		dst[doff] = str[soff]
+		doff++
 	}
 }
 
@@ -23,15 +23,15 @@ func copyString(dst []byte, doff int, str string) {
 // with Read and Write methods.
 // The zero value for Buffer is an empty buffer ready to use.
 type Buffer struct {
-	buf		[]byte;		// contents are the bytes buf[off : len(buf)]
-	off		int;		// read at &buf[off], write at &buf[len(buf)]
-	oneByte		[1]byte;	// avoid allocation of slice on each WriteByte
-	bootstrap	[64]byte;	// memory to hold first slice; helps small buffers (Printf) avoid allocation.
+	buf       []byte   // contents are the bytes buf[off : len(buf)]
+	off       int      // read at &buf[off], write at &buf[len(buf)]
+	oneByte   [1]byte  // avoid allocation of slice on each WriteByte
+	bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation.
 }
 
 // Bytes returns the contents of the unread portion of the buffer;
 // len(b.Bytes()) == b.Len().
-func (b *Buffer) Bytes() []byte	{ return b.buf[b.off:] }
+func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }
 
 // String returns the contents of the unread portion of the buffer
 // as a string.  If the Buffer is a nil pointer, it returns "<nil>".
@@ -40,12 +40,12 @@ func (b *Buffer) String() string {
 		// Special case, useful in debugging.
 		return "<nil>"
 	}
-	return string(b.buf[b.off:]);
+	return string(b.buf[b.off:])
 }
 
 // Len returns the number of bytes of the unread portion of the buffer;
 // b.Len() == len(b.Bytes()).
-func (b *Buffer) Len() int	{ return len(b.buf) - b.off }
+func (b *Buffer) Len() int { return len(b.buf) - b.off }
 
 // Truncate discards all but the first n unread bytes from the buffer.
 // It is an error to call b.Truncate(n) with n > b.Len().
@@ -54,64 +54,64 @@ func (b *Buffer) Truncate(n int) {
 		// Reuse buffer space.
 		b.off = 0
 	}
-	b.buf = b.buf[0 : b.off+n];
+	b.buf = b.buf[0 : b.off+n]
 }
 
 // Reset resets the buffer so it has no content.
 // b.Reset() is the same as b.Truncate(0).
-func (b *Buffer) Reset()	{ b.Truncate(0) }
+func (b *Buffer) Reset() { b.Truncate(0) }
 
 // Resize buffer to guarantee enough space for n more bytes.
 // After this call, the state of b.buf is inconsistent.
 // It must be fixed up as is done in Write and WriteString.
 func (b *Buffer) resize(n int) {
-	var buf []byte;
+	var buf []byte
 	if b.buf == nil && n <= len(b.bootstrap) {
 		buf = &b.bootstrap
 	} else {
-		buf = b.buf;
+		buf = b.buf
 		if len(b.buf)+n > cap(b.buf) {
 			// not enough space anywhere
 			buf = make([]byte, 2*cap(b.buf)+n)
 		}
-		copy(buf, b.buf[b.off:]);
+		copy(buf, b.buf[b.off:])
 	}
-	b.buf = buf;
-	b.off = 0;
+	b.buf = buf
+	b.off = 0
 }
 
 // Write appends the contents of p to the buffer.  The return
 // value n is the length of p; err is always nil.
 func (b *Buffer) Write(p []byte) (n int, err os.Error) {
-	m := b.Len();
+	m := b.Len()
 	// If buffer is empty, reset to recover space.
 	if m == 0 && b.off != 0 {
 		b.Truncate(0)
 	}
-	n = len(p);
+	n = len(p)
 	if len(b.buf)+n > cap(b.buf) {
 		b.resize(n)
 	}
-	b.buf = b.buf[0 : b.off+m+n];
-	copy(b.buf[b.off+m:], p);
-	return n, nil;
+	b.buf = b.buf[0 : b.off+m+n]
+	copy(b.buf[b.off+m:], p)
+	return n, nil
 }
 
 // WriteString appends the contents of s to the buffer.  The return
 // value n is the length of s; err is always nil.
 func (b *Buffer) WriteString(s string) (n int, err os.Error) {
-	m := b.Len();
+	m := b.Len()
 	// If buffer is empty, reset to recover space.
 	if m == 0 && b.off != 0 {
 		b.Truncate(0)
 	}
-	n = len(s);
+	n = len(s)
 	if len(b.buf)+n > cap(b.buf) {
 		b.resize(n)
 	}
-	b.buf = b.buf[0 : b.off+m+n];
-	copyString(b.buf, b.off+m, s);
-	return n, nil;
+	b.buf = b.buf[0 : b.off+m+n]
+	copyString(b.buf, b.off+m, s)
+	return n, nil
 }
 
 // MinRead is the minimum slice size passed to a Read call by
@@ -131,7 +131,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
 	}
 	for {
 		if cap(b.buf)-len(b.buf) < MinRead {
-			var newBuf []byte;
+			var newBuf []byte
 			// can we get space without allocation?
 			if b.off+cap(b.buf)-len(b.buf) >= MinRead {
 				// reuse beginning of buffer
@@ -140,13 +140,13 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
 				// not enough space at end; put space on end
 				newBuf = make([]byte, len(b.buf)-b.off, 2*(cap(b.buf)-b.off)+MinRead)
 			}
-			copy(newBuf, b.buf[b.off:]);
-			b.buf = newBuf;
-			b.off = 0;
+			copy(newBuf, b.buf[b.off:])
+			b.buf = newBuf
+			b.off = 0
 		}
-		m, e := r.Read(b.buf[len(b.buf):cap(b.buf)]);
-		b.buf = b.buf[b.off : len(b.buf)+m];
-		n += int64(m);
+		m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
+		b.buf = b.buf[b.off : len(b.buf)+m]
+		n += int64(m)
 		if e == os.EOF {
 			break
 		}
@@ -154,7 +154,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
 			return n, e
 		}
 	}
-	return n, nil;	// err is EOF, so return nil explicitly
+	return n, nil // err is EOF, so return nil explicitly
 }
 
 // WriteTo writes data to w until the buffer is drained or an error
@@ -162,25 +162,25 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) {
 // Any error encountered during the write is also returned.
 func (b *Buffer) WriteTo(w io.Writer) (n int64, err os.Error) {
 	for b.off < len(b.buf) {
-		m, e := w.Write(b.buf[b.off:]);
-		n += int64(m);
-		b.off += m;
+		m, e := w.Write(b.buf[b.off:])
+		n += int64(m)
+		b.off += m
 		if e != nil {
 			return n, e
 		}
 	}
 	// Buffer is now empty; reset.
-	b.Truncate(0);
-	return;
+	b.Truncate(0)
+	return
 }
 
 // WriteByte appends the byte c to the buffer.
 // The returned error is always nil, but is included
 // to match bufio.Writer's WriteByte.
 func (b *Buffer) WriteByte(c byte) os.Error {
-	b.oneByte[0] = c;
-	b.Write(&b.oneByte);
-	return nil;
+	b.oneByte[0] = c
+	b.Write(&b.oneByte)
+	return nil
 }
 
 // Read reads the next len(p) bytes from the buffer or until the buffer
@@ -190,20 +190,20 @@ func (b *Buffer) WriteByte(c byte) os.Error {
 func (b *Buffer) Read(p []byte) (n int, err os.Error) {
 	if b.off >= len(b.buf) {
 		// Buffer is empty, reset to recover space.
-		b.Truncate(0);
-		return 0, os.EOF;
+		b.Truncate(0)
+		return 0, os.EOF
 	}
-	m := b.Len();
-	n = len(p);
+	m := b.Len()
+	n = len(p)
 
 	if n > m {
 		// more bytes requested than available
 		n = m
 	}
 
-	copy(p, b.buf[b.off:b.off+n]);
-	b.off += n;
-	return n, err;
+	copy(p, b.buf[b.off:b.off+n])
+	b.off += n
+	return n, err
 }
 
 // ReadByte reads and returns the next byte from the buffer.
@@ -211,22 +211,22 @@ func (b *Buffer) Read(p []byte) (n int, err os.Error) {
 func (b *Buffer) ReadByte() (c byte, err os.Error) {
 	if b.off >= len(b.buf) {
 		// Buffer is empty, reset to recover space.
-		b.Truncate(0);
-		return 0, os.EOF;
+		b.Truncate(0)
+		return 0, os.EOF
 	}
-	c = b.buf[b.off];
-	b.off++;
-	return c, nil;
+	c = b.buf[b.off]
+	b.off++
+	return c, nil
 }
 
 // NewBuffer creates and initializes a new Buffer
 // using buf as its initial contents.
-func NewBuffer(buf []byte) *Buffer	{ return &Buffer{buf: buf} }
+func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
 
 // NewBufferString creates and initializes a new Buffer
 // using string s as its initial contents.
 func NewBufferString(s string) *Buffer {
-	buf := make([]byte, len(s));
-	copyString(buf, 0, s);
-	return &Buffer{buf: buf};
+	buf := make([]byte, len(s))
+	copyString(buf, 0, s)
+	return &Buffer{buf: buf}
 }
diff --git a/src/pkg/bytes/buffer_test.go b/src/pkg/bytes/buffer_test.go
index c9dafad40..af637cf63 100644
--- a/src/pkg/bytes/buffer_test.go
+++ b/src/pkg/bytes/buffer_test.go
@@ -5,29 +5,29 @@
 package bytes_test
 
 import (
-	. "bytes";
-	"rand";
-	"testing";
+	. "bytes"
+	"rand"
+	"testing"
 )
 
 
-const N = 10000		// make this bigger for a larger (and slower) test
-var data string		// test data for write tests
-var bytes []byte	// test data; same as data but as a slice.
+const N = 10000  // make this bigger for a larger (and slower) test
+var data string  // test data for write tests
+var bytes []byte // test data; same as data but as a slice.
 
 
 func init() {
-	bytes = make([]byte, N);
+	bytes = make([]byte, N)
 	for i := 0; i < N; i++ {
 		bytes[i] = 'a' + byte(i%26)
 	}
-	data = string(bytes);
+	data = string(bytes)
 }
 
 // Verify that contents of buf match the string s.
 func check(t *testing.T, testname string, buf *Buffer, s string) {
-	bytes := buf.Bytes();
-	str := buf.String();
+	bytes := buf.Bytes()
+	str := buf.String()
 	if buf.Len() != len(bytes) {
 		t.Errorf("%s: buf.Len() == %d, len(buf.Bytes()) == %d\n", testname, buf.Len(), len(bytes))
 	}
@@ -50,19 +50,19 @@ func check(t *testing.T, testname string, buf *Buffer, s string) {
 // The initial contents of buf corresponds to the string s;
 // the result is the final contents of buf returned as a string.
 func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus string) string {
-	check(t, testname+" (fill 1)", buf, s);
+	check(t, testname+" (fill 1)", buf, s)
 	for ; n > 0; n-- {
-		m, err := buf.WriteString(fus);
+		m, err := buf.WriteString(fus)
 		if m != len(fus) {
 			t.Errorf(testname+" (fill 2): m == %d, expected %d\n", m, len(fus))
 		}
 		if err != nil {
 			t.Errorf(testname+" (fill 3): err should always be nil, found err == %s\n", err)
 		}
-		s += fus;
-		check(t, testname+" (fill 4)", buf, s);
+		s += fus
+		check(t, testname+" (fill 4)", buf, s)
 	}
-	return s;
+	return s
 }
 
 
@@ -70,103 +70,103 @@ func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus
 // The initial contents of buf corresponds to the string s;
 // the result is the final contents of buf returned as a string.
 func fillBytes(t *testing.T, testname string, buf *Buffer, s string, n int, fub []byte) string {
-	check(t, testname+" (fill 1)", buf, s);
+	check(t, testname+" (fill 1)", buf, s)
 	for ; n > 0; n-- {
-		m, err := buf.Write(fub);
+		m, err := buf.Write(fub)
 		if m != len(fub) {
 			t.Errorf(testname+" (fill 2): m == %d, expected %d\n", m, len(fub))
 		}
 		if err != nil {
 			t.Errorf(testname+" (fill 3): err should always be nil, found err == %s\n", err)
 		}
-		s += string(fub);
-		check(t, testname+" (fill 4)", buf, s);
+		s += string(fub)
+		check(t, testname+" (fill 4)", buf, s)
 	}
-	return s;
+	return s
 }
 
 
 func TestNewBuffer(t *testing.T) {
-	buf := NewBuffer(bytes);
-	check(t, "NewBuffer", buf, data);
+	buf := NewBuffer(bytes)
+	check(t, "NewBuffer", buf, data)
 }
 
 
 func TestNewBufferString(t *testing.T) {
-	buf := NewBufferString(data);
-	check(t, "NewBufferString", buf, data);
+	buf := NewBufferString(data)
+	check(t, "NewBufferString", buf, data)
 }
 
 
 // Empty buf through repeated reads into fub.
 // The initial contents of buf corresponds to the string s.
 func empty(t *testing.T, testname string, buf *Buffer, s string, fub []byte) {
-	check(t, testname+" (empty 1)", buf, s);
+	check(t, testname+" (empty 1)", buf, s)
 
 	for {
-		n, err := buf.Read(fub);
+		n, err := buf.Read(fub)
 		if n == 0 {
 			break
 		}
 		if err != nil {
 			t.Errorf(testname+" (empty 2): err should always be nil, found err == %s\n", err)
 		}
-		s = s[n:];
-		check(t, testname+" (empty 3)", buf, s);
+		s = s[n:]
+		check(t, testname+" (empty 3)", buf, s)
 	}
 
-	check(t, testname+" (empty 4)", buf, "");
+	check(t, testname+" (empty 4)", buf, "")
 }
 
 
 func TestBasicOperations(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 
 	for i := 0; i < 5; i++ {
-		check(t, "TestBasicOperations (1)", &buf, "");
+		check(t, "TestBasicOperations (1)", &buf, "")
 
-		buf.Reset();
-		check(t, "TestBasicOperations (2)", &buf, "");
+		buf.Reset()
+		check(t, "TestBasicOperations (2)", &buf, "")
 
-		buf.Truncate(0);
-		check(t, "TestBasicOperations (3)", &buf, "");
+		buf.Truncate(0)
+		check(t, "TestBasicOperations (3)", &buf, "")
 
-		n, err := buf.Write(Bytes(data[0:1]));
+		n, err := buf.Write(Bytes(data[0:1]))
 		if n != 1 {
 			t.Errorf("wrote 1 byte, but n == %d\n", n)
 		}
 		if err != nil {
 			t.Errorf("err should always be nil, but err == %s\n", err)
 		}
-		check(t, "TestBasicOperations (4)", &buf, "a");
+		check(t, "TestBasicOperations (4)", &buf, "a")
 
-		buf.WriteByte(data[1]);
-		check(t, "TestBasicOperations (5)", &buf, "ab");
+		buf.WriteByte(data[1])
+		check(t, "TestBasicOperations (5)", &buf, "ab")
 
-		n, err = buf.Write(Bytes(data[2:26]));
+		n, err = buf.Write(Bytes(data[2:26]))
 		if n != 24 {
 			t.Errorf("wrote 25 bytes, but n == %d\n", n)
 		}
-		check(t, "TestBasicOperations (6)", &buf, string(data[0:26]));
+		check(t, "TestBasicOperations (6)", &buf, string(data[0:26]))
 
-		buf.Truncate(26);
-		check(t, "TestBasicOperations (7)", &buf, string(data[0:26]));
+		buf.Truncate(26)
+		check(t, "TestBasicOperations (7)", &buf, string(data[0:26]))
 
-		buf.Truncate(20);
-		check(t, "TestBasicOperations (8)", &buf, string(data[0:20]));
+		buf.Truncate(20)
+		check(t, "TestBasicOperations (8)", &buf, string(data[0:20]))
 
-		empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5));
-		empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100));
+		empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5))
+		empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100))
 
-		buf.WriteByte(data[1]);
-		c, err := buf.ReadByte();
+		buf.WriteByte(data[1])
+		c, err := buf.ReadByte()
 		if err != nil {
 			t.Errorf("ReadByte unexpected eof\n")
 		}
 		if c != data[1] {
 			t.Errorf("ReadByte wrong value c=%v\n", c)
 		}
-		c, err = buf.ReadByte();
+		c, err = buf.ReadByte()
 		if err == nil {
 			t.Errorf("ReadByte unexpected not eof\n")
 		}
@@ -175,67 +175,67 @@ func TestBasicOperations(t *testing.T) {
 
 
 func TestLargeStringWrites(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, data);
-		empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(data)/i));
+		s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, data)
+		empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(data)/i))
 	}
-	check(t, "TestLargeStringWrites (3)", &buf, "");
+	check(t, "TestLargeStringWrites (3)", &buf, "")
 }
 
 
 func TestLargeByteWrites(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, bytes);
-		empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i));
+		s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, bytes)
+		empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i))
 	}
-	check(t, "TestLargeByteWrites (3)", &buf, "");
+	check(t, "TestLargeByteWrites (3)", &buf, "")
 }
 
 
 func TestLargeStringReads(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillString(t, "TestLargeReads (1)", &buf, "", 5, data[0:len(data)/i]);
-		empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)));
+		s := fillString(t, "TestLargeReads (1)", &buf, "", 5, data[0:len(data)/i])
+		empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)))
 	}
-	check(t, "TestLargeStringReads (3)", &buf, "");
+	check(t, "TestLargeStringReads (3)", &buf, "")
 }
 
 
 func TestLargeByteReads(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, bytes[0:len(bytes)/i]);
-		empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)));
+		s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, bytes[0:len(bytes)/i])
+		empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)))
 	}
-	check(t, "TestLargeByteReads (3)", &buf, "");
+	check(t, "TestLargeByteReads (3)", &buf, "")
 }
 
 
 func TestMixedReadsAndWrites(t *testing.T) {
-	var buf Buffer;
-	s := "";
+	var buf Buffer
+	s := ""
 	for i := 0; i < 50; i++ {
-		wlen := rand.Intn(len(data));
+		wlen := rand.Intn(len(data))
 		if i%2 == 0 {
 			s = fillString(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, data[0:wlen])
 		} else {
 			s = fillBytes(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, bytes[0:wlen])
 		}
 
-		rlen := rand.Intn(len(data));
-		fub := make([]byte, rlen);
-		n, _ := buf.Read(fub);
-		s = s[n:];
+		rlen := rand.Intn(len(data))
+		fub := make([]byte, rlen)
+		n, _ := buf.Read(fub)
+		s = s[n:]
 	}
-	empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len()));
+	empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len()))
 }
 
 
 func TestNil(t *testing.T) {
-	var b *Buffer;
+	var b *Buffer
 	if b.String() != "<nil>" {
 		t.Error("expcted <nil>; got %q", b.String())
 	}
@@ -243,22 +243,22 @@ func TestNil(t *testing.T) {
 
 
 func TestReadFrom(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]);
-		var b Buffer;
-		b.ReadFrom(&buf);
-		empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)));
+		s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i])
+		var b Buffer
+		b.ReadFrom(&buf)
+		empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)))
 	}
 }
 
 
 func TestWriteTo(t *testing.T) {
-	var buf Buffer;
+	var buf Buffer
 	for i := 3; i < 30; i += 3 {
-		s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]);
-		var b Buffer;
-		buf.WriteTo(&b);
-		empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)));
+		s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i])
+		var b Buffer
+		buf.WriteTo(&b)
+		empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)))
 	}
 }
diff --git a/src/pkg/bytes/bytes.go b/src/pkg/bytes/bytes.go
index 85d4f9fd7..0a2146413 100644
--- a/src/pkg/bytes/bytes.go
+++ b/src/pkg/bytes/bytes.go
@@ -7,8 +7,8 @@
 package bytes
 
 import (
-	"unicode";
-	"utf8";
+	"unicode"
+	"utf8"
 )
 
 // Compare returns an integer comparing the two byte arrays lexicographically.
@@ -28,7 +28,7 @@ func Compare(a, b []byte) int {
 	case len(a) > len(b):
 		return 1
 	}
-	return 0;
+	return 0
 }
 
 // Equal returns a boolean reporting whether a == b.
@@ -41,7 +41,7 @@ func Equal(a, b []byte) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 // explode splits s into an array of UTF-8 sequences, one per Unicode character (still arrays of bytes),
@@ -50,21 +50,21 @@ func explode(s []byte, n int) [][]byte {
 	if n <= 0 {
 		n = len(s)
 	}
-	a := make([][]byte, n);
-	var size int;
-	na := 0;
+	a := make([][]byte, n)
+	var size int
+	na := 0
 	for len(s) > 0 {
 		if na+1 >= n {
-			a[na] = s;
-			na++;
-			break;
+			a[na] = s
+			na++
+			break
 		}
-		_, size = utf8.DecodeRune(s);
-		a[na] = s[0:size];
-		s = s[size:];
-		na++;
+		_, size = utf8.DecodeRune(s)
+		a[na] = s[0:size]
+		s = s[size:]
+		na++
 	}
-	return a[0:na];
+	return a[0:na]
 }
 
 // Count counts the number of non-overlapping instances of sep in s.
@@ -72,34 +72,34 @@ func Count(s, sep []byte) int {
 	if len(sep) == 0 {
 		return utf8.RuneCount(s) + 1
 	}
-	c := sep[0];
-	n := 0;
+	c := sep[0]
+	n := 0
 	for i := 0; i+len(sep) <= len(s); i++ {
 		if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
-			n++;
-			i += len(sep) - 1;
+			n++
+			i += len(sep) - 1
 		}
 	}
-	return n;
+	return n
 }
 
 // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
 func Index(s, sep []byte) int {
-	n := len(sep);
+	n := len(sep)
 	if n == 0 {
 		return 0
 	}
-	c := sep[0];
+	c := sep[0]
 	for i := 0; i+n <= len(s); i++ {
 		if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
-func IndexByte(s []byte, c byte) int	// asm_$GOARCH.s
+func IndexByte(s []byte, c byte) int // asm_$GOARCH.s
 
 func indexBytePortable(s []byte, c byte) int {
 	for i, b := range s {
@@ -107,22 +107,22 @@ func indexBytePortable(s []byte, c byte) int {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
 func LastIndex(s, sep []byte) int {
-	n := len(sep);
+	n := len(sep)
 	if n == 0 {
 		return len(s)
 	}
-	c := sep[0];
+	c := sep[0]
 	for i := len(s) - n; i >= 0; i-- {
 		if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // Generic split: splits after each instance of sep,
@@ -134,26 +134,26 @@ func genSplit(s, sep []byte, sepSave, n int) [][]byte {
 	if n <= 0 {
 		n = Count(s, sep) + 1
 	}
-	c := sep[0];
-	start := 0;
-	a := make([][]byte, n);
-	na := 0;
+	c := sep[0]
+	start := 0
+	a := make([][]byte, n)
+	na := 0
 	for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
 		if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
-			a[na] = s[start : i+sepSave];
-			na++;
-			start = i + len(sep);
-			i += len(sep) - 1;
+			a[na] = s[start : i+sepSave]
+			na++
+			start = i + len(sep)
+			i += len(sep) - 1
 		}
 	}
-	a[na] = s[start:];
-	return a[0 : na+1];
+	a[na] = s[start:]
+	return a[0 : na+1]
 }
 
 // Split splits the array s around each instance of sep, returning an array of subarrays of s.
 // If sep is empty, Split splits s after each UTF-8 sequence.
 // If n > 0, Split splits s into at most n subarrays; the last subarray will contain an unsplit remainder.
-func Split(s, sep []byte, n int) [][]byte	{ return genSplit(s, sep, 0, n) }
+func Split(s, sep []byte, n int) [][]byte { return genSplit(s, sep, 0, n) }
 
 // SplitAfter splits the array s after each instance of sep, returning an array of subarrays of s.
 // If sep is empty, SplitAfter splits s after each UTF-8 sequence.
@@ -172,28 +172,28 @@ func Join(a [][]byte, sep []byte) []byte {
 	if len(a) == 1 {
 		return a[0]
 	}
-	n := len(sep) * (len(a) - 1);
+	n := len(sep) * (len(a) - 1)
 	for i := 0; i < len(a); i++ {
 		n += len(a[i])
 	}
 
-	b := make([]byte, n);
-	bp := 0;
+	b := make([]byte, n)
+	bp := 0
 	for i := 0; i < len(a); i++ {
-		s := a[i];
+		s := a[i]
 		for j := 0; j < len(s); j++ {
-			b[bp] = s[j];
-			bp++;
+			b[bp] = s[j]
+			bp++
 		}
 		if i+1 < len(a) {
-			s = sep;
+			s = sep
 			for j := 0; j < len(s); j++ {
-				b[bp] = s[j];
-				bp++;
+				b[bp] = s[j]
+				bp++
 			}
 		}
 	}
-	return b;
+	return b
 }
 
 // HasPrefix tests whether the byte array s begins with prefix.
@@ -213,88 +213,88 @@ func Map(mapping func(rune int) int, s []byte) []byte {
 	// In the worst case, the array can grow when mapped, making
 	// things unpleasant.  But it's so rare we barge in assuming it's
 	// fine.  It could also shrink but that falls out naturally.
-	maxbytes := len(s);	// length of b
-	nbytes := 0;		// number of bytes encoded in b
-	b := make([]byte, maxbytes);
+	maxbytes := len(s) // length of b
+	nbytes := 0        // number of bytes encoded in b
+	b := make([]byte, maxbytes)
 	for i := 0; i < len(s); {
-		wid := 1;
-		rune := int(s[i]);
+		wid := 1
+		rune := int(s[i])
 		if rune >= utf8.RuneSelf {
 			rune, wid = utf8.DecodeRune(s[i:])
 		}
-		rune = mapping(rune);
+		rune = mapping(rune)
 		if rune >= 0 {
 			if nbytes+utf8.RuneLen(rune) > maxbytes {
 				// Grow the buffer.
-				maxbytes = maxbytes*2 + utf8.UTFMax;
-				nb := make([]byte, maxbytes);
+				maxbytes = maxbytes*2 + utf8.UTFMax
+				nb := make([]byte, maxbytes)
 				for i, c := range b[0:nbytes] {
 					nb[i] = c
 				}
-				b = nb;
+				b = nb
 			}
-			nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]);
+			nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes])
 		}
-		i += wid;
+		i += wid
 	}
-	return b[0:nbytes];
+	return b[0:nbytes]
 }
 
 // Repeat returns a new byte array consisting of count copies of b.
 func Repeat(b []byte, count int) []byte {
-	nb := make([]byte, len(b)*count);
-	bp := 0;
+	nb := make([]byte, len(b)*count)
+	bp := 0
 	for i := 0; i < count; i++ {
 		for j := 0; j < len(b); j++ {
-			nb[bp] = b[j];
-			bp++;
+			nb[bp] = b[j]
+			bp++
 		}
 	}
-	return nb;
+	return nb
 }
 
 // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their upper case.
-func ToUpper(s []byte) []byte	{ return Map(unicode.ToUpper, s) }
+func ToUpper(s []byte) []byte { return Map(unicode.ToUpper, s) }
 
 // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their lower case.
-func ToLower(s []byte) []byte	{ return Map(unicode.ToLower, s) }
+func ToLower(s []byte) []byte { return Map(unicode.ToLower, s) }
 
 // ToTitle returns a copy of the byte array s with all Unicode letters mapped to their title case.
-func ToTitle(s []byte) []byte	{ return Map(unicode.ToTitle, s) }
+func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) }
 
 // Trim returns a slice of the string s, with all leading and trailing white space
 // removed, as defined by Unicode.
 func TrimSpace(s []byte) []byte {
-	start, end := 0, len(s);
+	start, end := 0, len(s)
 	for start < end {
-		wid := 1;
-		rune := int(s[start]);
+		wid := 1
+		rune := int(s[start])
 		if rune >= utf8.RuneSelf {
 			rune, wid = utf8.DecodeRune(s[start:end])
 		}
 		if !unicode.IsSpace(rune) {
 			break
 		}
-		start += wid;
+		start += wid
 	}
 	for start < end {
-		wid := 1;
-		rune := int(s[end-1]);
+		wid := 1
+		rune := int(s[end-1])
 		if rune >= utf8.RuneSelf {
 			// Back up carefully looking for beginning of rune. Mustn't pass start.
 			for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {
 			}
-			if start > end-wid {	// invalid UTF-8 sequence; stop processing
+			if start > end-wid { // invalid UTF-8 sequence; stop processing
 				return s[start:end]
 			}
-			rune, wid = utf8.DecodeRune(s[end-wid : end]);
+			rune, wid = utf8.DecodeRune(s[end-wid : end])
 		}
 		if !unicode.IsSpace(rune) {
 			break
 		}
-		end -= wid;
+		end -= wid
 	}
-	return s[start:end];
+	return s[start:end]
 }
 
 // How big to make a byte array when growing.
@@ -303,51 +303,51 @@ func resize(n int) int {
 	if n < 16 {
 		n = 16
 	}
-	return n + n/2;
+	return n + n/2
 }
 
 // Add appends the contents of t to the end of s and returns the result.
 // If s has enough capacity, it is extended in place; otherwise a
 // new array is allocated and returned.
 func Add(s, t []byte) []byte {
-	lens := len(s);
-	lent := len(t);
+	lens := len(s)
+	lent := len(t)
 	if lens+lent <= cap(s) {
 		s = s[0 : lens+lent]
 	} else {
-		news := make([]byte, lens+lent, resize(lens+lent));
-		copy(news, s);
-		s = news;
+		news := make([]byte, lens+lent, resize(lens+lent))
+		copy(news, s)
+		s = news
 	}
-	copy(s[lens:lens+lent], t);
-	return s;
+	copy(s[lens:lens+lent], t)
+	return s
 }
 
 // AddByte appends byte b to the end of s and returns the result.
 // If s has enough capacity, it is extended in place; otherwise a
 // new array is allocated and returned.
 func AddByte(s []byte, t byte) []byte {
-	lens := len(s);
+	lens := len(s)
 	if lens+1 <= cap(s) {
 		s = s[0 : lens+1]
 	} else {
-		news := make([]byte, lens+1, resize(lens+1));
-		copy(news, s);
-		s = news;
+		news := make([]byte, lens+1, resize(lens+1))
+		copy(news, s)
+		s = news
 	}
-	s[lens] = t;
-	return s;
+	s[lens] = t
+	return s
 }
 
 // Runes returns a slice of runes (Unicode code points) equivalent to s.
 func Runes(s []byte) []int {
-	t := make([]int, utf8.RuneCount(s));
-	i := 0;
+	t := make([]int, utf8.RuneCount(s))
+	i := 0
 	for len(s) > 0 {
-		r, l := utf8.DecodeRune(s);
-		t[i] = r;
-		i++;
-		s = s[l:];
+		r, l := utf8.DecodeRune(s)
+		t[i] = r
+		i++
+		s = s[l:]
 	}
-	return t;
+	return t
 }
diff --git a/src/pkg/bytes/bytes_test.go b/src/pkg/bytes/bytes_test.go
index 3f77e6e9f..4c6d4166a 100644
--- a/src/pkg/bytes/bytes_test.go
+++ b/src/pkg/bytes/bytes_test.go
@@ -5,10 +5,10 @@
 package bytes_test
 
 import (
-	. "bytes";
-	"strings";
-	"testing";
-	"unicode";
+	. "bytes"
+	"strings"
+	"testing"
+	"unicode"
 )
 
 func eq(a, b []string) bool {
@@ -20,15 +20,15 @@ func eq(a, b []string) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 func arrayOfString(a [][]byte) []string {
-	result := make([]string, len(a));
+	result := make([]string, len(a))
 	for j := 0; j < len(a); j++ {
 		result[j] = string(a[j])
 	}
-	return result;
+	return result
 }
 
 // For ease of reading, the test cases use strings that are converted to byte
@@ -40,9 +40,9 @@ var commas = "1,2,3,4"
 var dots = "1....2....3....4"
 
 type BinOpTest struct {
-	a	string;
-	b	string;
-	i	int;
+	a string
+	b string
+	i int
 }
 
 var comparetests = []BinOpTest{
@@ -60,10 +60,10 @@ var comparetests = []BinOpTest{
 
 func TestCompare(t *testing.T) {
 	for _, tt := range comparetests {
-		a := strings.Bytes(tt.a);
-		b := strings.Bytes(tt.b);
-		cmp := Compare(a, b);
-		eql := Equal(a, b);
+		a := strings.Bytes(tt.a)
+		b := strings.Bytes(tt.b)
+		cmp := Compare(a, b)
+		eql := Equal(a, b)
 		if cmp != tt.i {
 			t.Errorf(`Compare(%q, %q) = %v`, tt.a, tt.b, cmp)
 		}
@@ -94,9 +94,9 @@ var indextests = []BinOpTest{
 
 func TestIndex(t *testing.T) {
 	for _, tt := range indextests {
-		a := strings.Bytes(tt.a);
-		b := strings.Bytes(tt.b);
-		pos := Index(a, b);
+		a := strings.Bytes(tt.a)
+		b := strings.Bytes(tt.b)
+		pos := Index(a, b)
 		if pos != tt.i {
 			t.Errorf(`Index(%q, %q) = %v`, tt.a, tt.b, pos)
 		}
@@ -108,24 +108,24 @@ func TestIndexByte(t *testing.T) {
 		if len(tt.b) != 1 {
 			continue
 		}
-		a := strings.Bytes(tt.a);
-		b := tt.b[0];
-		pos := IndexByte(a, b);
+		a := strings.Bytes(tt.a)
+		b := tt.b[0]
+		pos := IndexByte(a, b)
 		if pos != tt.i {
 			t.Errorf(`IndexByte(%q, '%c') = %v`, tt.a, b, pos)
 		}
-		posp := IndexBytePortable(a, b);
+		posp := IndexBytePortable(a, b)
 		if posp != tt.i {
 			t.Errorf(`indexBytePortable(%q, '%c') = %v`, tt.a, b, posp)
 		}
 	}
 }
 
-func BenchmarkIndexByte4K(b *testing.B)	{ bmIndex(b, IndexByte, 4<<10) }
+func BenchmarkIndexByte4K(b *testing.B) { bmIndex(b, IndexByte, 4<<10) }
 
-func BenchmarkIndexByte4M(b *testing.B)	{ bmIndex(b, IndexByte, 4<<20) }
+func BenchmarkIndexByte4M(b *testing.B) { bmIndex(b, IndexByte, 4<<20) }
 
-func BenchmarkIndexByte64M(b *testing.B)	{ bmIndex(b, IndexByte, 64<<20) }
+func BenchmarkIndexByte64M(b *testing.B) { bmIndex(b, IndexByte, 64<<20) }
 
 func BenchmarkIndexBytePortable4K(b *testing.B) {
 	bmIndex(b, IndexBytePortable, 4<<10)
@@ -145,22 +145,22 @@ func bmIndex(b *testing.B, index func([]byte, byte) int, n int) {
 	if len(bmbuf) < n {
 		bmbuf = make([]byte, n)
 	}
-	b.SetBytes(int64(n));
-	buf := bmbuf[0:n];
-	buf[n-1] = 'x';
+	b.SetBytes(int64(n))
+	buf := bmbuf[0:n]
+	buf[n-1] = 'x'
 	for i := 0; i < b.N; i++ {
-		j := index(buf, 'x');
+		j := index(buf, 'x')
 		if j != n-1 {
 			panic("bad index", j)
 		}
 	}
-	buf[n-1] = '0';
+	buf[n-1] = '0'
 }
 
 type ExplodeTest struct {
-	s	string;
-	n	int;
-	a	[]string;
+	s string
+	n int
+	a []string
 }
 
 var explodetests = []ExplodeTest{
@@ -171,13 +171,13 @@ var explodetests = []ExplodeTest{
 
 func TestExplode(t *testing.T) {
 	for _, tt := range (explodetests) {
-		a := Split(strings.Bytes(tt.s), nil, tt.n);
-		result := arrayOfString(a);
+		a := Split(strings.Bytes(tt.s), nil, tt.n)
+		result := arrayOfString(a)
 		if !eq(result, tt.a) {
-			t.Errorf(`Explode("%s", %d) = %v; want %v`, tt.s, tt.n, result, tt.a);
-			continue;
+			t.Errorf(`Explode("%s", %d) = %v; want %v`, tt.s, tt.n, result, tt.a)
+			continue
 		}
-		s := Join(a, []byte{});
+		s := Join(a, []byte{})
 		if string(s) != tt.s {
 			t.Errorf(`Join(Explode("%s", %d), "") = "%s"`, tt.s, tt.n, s)
 		}
@@ -186,10 +186,10 @@ func TestExplode(t *testing.T) {
 
 
 type SplitTest struct {
-	s	string;
-	sep	string;
-	n	int;
-	a	[]string;
+	s   string
+	sep string
+	n   int
+	a   []string
 }
 
 var splittests = []SplitTest{
@@ -210,13 +210,13 @@ var splittests = []SplitTest{
 
 func TestSplit(t *testing.T) {
 	for _, tt := range splittests {
-		a := Split(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n);
-		result := arrayOfString(a);
+		a := Split(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n)
+		result := arrayOfString(a)
 		if !eq(result, tt.a) {
-			t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a);
-			continue;
+			t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a)
+			continue
 		}
-		s := Join(a, strings.Bytes(tt.sep));
+		s := Join(a, strings.Bytes(tt.sep))
 		if string(s) != tt.s {
 			t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s)
 		}
@@ -241,13 +241,13 @@ var splitaftertests = []SplitTest{
 
 func TestSplitAfter(t *testing.T) {
 	for _, tt := range splitaftertests {
-		a := SplitAfter(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n);
-		result := arrayOfString(a);
+		a := SplitAfter(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n)
+		result := arrayOfString(a)
 		if !eq(result, tt.a) {
-			t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a);
-			continue;
+			t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a)
+			continue
 		}
-		s := Join(a, nil);
+		s := Join(a, nil)
 		if string(s) != tt.s {
 			t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s)
 		}
@@ -257,7 +257,7 @@ func TestSplitAfter(t *testing.T) {
 // Test case for any function which accepts and returns a byte array.
 // For ease of creation, we write the byte arrays as strings.
 type StringTest struct {
-	in, out string;
+	in, out string
 }
 
 var upperTests = []StringTest{
@@ -265,7 +265,7 @@ var upperTests = []StringTest{
 	StringTest{"abc", "ABC"},
 	StringTest{"AbC123", "ABC123"},
 	StringTest{"azAZ09_", "AZAZ09_"},
-	StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"},	// grows one byte per char
+	StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"}, // grows one byte per char
 }
 
 var lowerTests = []StringTest{
@@ -273,7 +273,7 @@ var lowerTests = []StringTest{
 	StringTest{"abc", "abc"},
 	StringTest{"AbC123", "abc123"},
 	StringTest{"azAZ09_", "azaz09_"},
-	StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"},	// shrinks one byte per char
+	StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"}, // shrinks one byte per char
 }
 
 const space = "\t\v\r\f\n\u0085\u00a0\u2000\u3000"
@@ -287,25 +287,25 @@ var trimSpaceTests = []StringTest{
 	StringTest{" \t\r\n x\t\t\r\r\n\n ", "x"},
 	StringTest{" \u2000\t\r\n x\t\t\r\r\ny\n \u3000", "x\t\t\r\r\ny"},
 	StringTest{"1 \t\r\n2", "1 \t\r\n2"},
-	StringTest{" x\x80", "x\x80"},	// invalid UTF-8 on end
-	StringTest{" x\xc0", "x\xc0"},	// invalid UTF-8 on end
+	StringTest{" x\x80", "x\x80"}, // invalid UTF-8 on end
+	StringTest{" x\xc0", "x\xc0"}, // invalid UTF-8 on end
 }
 
 // Bytes returns a new slice containing the bytes in s.
 // Borrowed from strings to avoid dependency.
 func Bytes(s string) []byte {
-	b := make([]byte, len(s));
+	b := make([]byte, len(s))
 	for i := 0; i < len(s); i++ {
 		b[i] = s[i]
 	}
-	return b;
+	return b
 }
 
 // Execute f on each test case.  funcName should be the name of f; it's used
 // in failure reports.
 func runStringTests(t *testing.T, f func([]byte) []byte, funcName string, testCases []StringTest) {
 	for _, tc := range testCases {
-		actual := string(f(Bytes(tc.in)));
+		actual := string(f(Bytes(tc.in)))
 		if actual != tc.out {
 			t.Errorf("%s(%q) = %q; want %q", funcName, tc.in, actual, tc.out)
 		}
@@ -313,55 +313,55 @@ func runStringTests(t *testing.T, f func([]byte) []byte, funcName string, testCa
 }
 
 func tenRunes(rune int) string {
-	r := make([]int, 10);
+	r := make([]int, 10)
 	for i := range r {
 		r[i] = rune
 	}
-	return string(r);
+	return string(r)
 }
 
 // User-defined self-inverse mapping function
 func rot13(rune int) int {
-	step := 13;
+	step := 13
 	if rune >= 'a' && rune <= 'z' {
 		return ((rune - 'a' + step) % 26) + 'a'
 	}
 	if rune >= 'A' && rune <= 'Z' {
 		return ((rune - 'A' + step) % 26) + 'A'
 	}
-	return rune;
+	return rune
 }
 
 func TestMap(t *testing.T) {
 	// Run a couple of awful growth/shrinkage tests
-	a := tenRunes('a');
+	a := tenRunes('a')
 
 	// 1.  Grow.  This triggers two reallocations in Map.
-	maxRune := func(rune int) int { return unicode.MaxRune };
-	m := Map(maxRune, Bytes(a));
-	expect := tenRunes(unicode.MaxRune);
+	maxRune := func(rune int) int { return unicode.MaxRune }
+	m := Map(maxRune, Bytes(a))
+	expect := tenRunes(unicode.MaxRune)
 	if string(m) != expect {
 		t.Errorf("growing: expected %q got %q", expect, m)
 	}
 
 	// 2. Shrink
-	minRune := func(rune int) int { return 'a' };
-	m = Map(minRune, Bytes(tenRunes(unicode.MaxRune)));
-	expect = a;
+	minRune := func(rune int) int { return 'a' }
+	m = Map(minRune, Bytes(tenRunes(unicode.MaxRune)))
+	expect = a
 	if string(m) != expect {
 		t.Errorf("shrinking: expected %q got %q", expect, m)
 	}
 
 	// 3. Rot13
-	m = Map(rot13, Bytes("a to zed"));
-	expect = "n gb mrq";
+	m = Map(rot13, Bytes("a to zed"))
+	expect = "n gb mrq"
 	if string(m) != expect {
 		t.Errorf("rot13: expected %q got %q", expect, m)
 	}
 
 	// 4. Rot13^2
-	m = Map(rot13, Map(rot13, Bytes("a to zed")));
-	expect = "a to zed";
+	m = Map(rot13, Map(rot13, Bytes("a to zed")))
+	expect = "a to zed"
 	if string(m) != expect {
 		t.Errorf("rot13: expected %q got %q", expect, m)
 	}
@@ -371,24 +371,24 @@ func TestMap(t *testing.T) {
 		if unicode.Is(unicode.Latin, rune) {
 			return rune
 		}
-		return -1;
-	};
-	m = Map(dropNotLatin, Bytes("Hello, 세계"));
-	expect = "Hello";
+		return -1
+	}
+	m = Map(dropNotLatin, Bytes("Hello, 세계"))
+	expect = "Hello"
 	if string(m) != expect {
 		t.Errorf("drop: expected %q got %q", expect, m)
 	}
 }
 
-func TestToUpper(t *testing.T)	{ runStringTests(t, ToUpper, "ToUpper", upperTests) }
+func TestToUpper(t *testing.T) { runStringTests(t, ToUpper, "ToUpper", upperTests) }
 
-func TestToLower(t *testing.T)	{ runStringTests(t, ToLower, "ToLower", lowerTests) }
+func TestToLower(t *testing.T) { runStringTests(t, ToLower, "ToLower", lowerTests) }
 
-func TestTrimSpace(t *testing.T)	{ runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) }
+func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) }
 
 type AddTest struct {
-	s, t	string;
-	cap	int;
+	s, t string
+	cap  int
 }
 
 var addtests = []AddTest{
@@ -400,11 +400,11 @@ var addtests = []AddTest{
 
 func TestAdd(t *testing.T) {
 	for _, test := range addtests {
-		b := make([]byte, len(test.s), test.cap);
+		b := make([]byte, len(test.s), test.cap)
 		for i := 0; i < len(test.s); i++ {
 			b[i] = test.s[i]
 		}
-		b = Add(b, strings.Bytes(test.t));
+		b = Add(b, strings.Bytes(test.t))
 		if string(b) != test.s+test.t {
 			t.Errorf("Add(%q,%q) = %q", test.s, test.t, string(b))
 		}
@@ -412,8 +412,8 @@ func TestAdd(t *testing.T) {
 }
 
 func TestAddByte(t *testing.T) {
-	const N = 2e5;
-	b := make([]byte, 0);
+	const N = 2e5
+	b := make([]byte, 0)
 	for i := 0; i < N; i++ {
 		b = AddByte(b, byte(i))
 	}
@@ -428,8 +428,8 @@ func TestAddByte(t *testing.T) {
 }
 
 type RepeatTest struct {
-	in, out	string;
-	count	int;
+	in, out string
+	count   int
 }
 
 var RepeatTests = []RepeatTest{
@@ -444,12 +444,12 @@ var RepeatTests = []RepeatTest{
 
 func TestRepeat(t *testing.T) {
 	for _, tt := range RepeatTests {
-		tin := strings.Bytes(tt.in);
-		tout := strings.Bytes(tt.out);
-		a := Repeat(tin, tt.count);
+		tin := strings.Bytes(tt.in)
+		tout := strings.Bytes(tt.out)
+		a := Repeat(tin, tt.count)
 		if !Equal(a, tout) {
-			t.Errorf("Repeat(%q, %d) = %q; want %q", tin, tt.count, a, tout);
-			continue;
+			t.Errorf("Repeat(%q, %d) = %q; want %q", tin, tt.count, a, tout)
+			continue
 		}
 	}
 }
@@ -463,13 +463,13 @@ func runesEqual(a, b []int) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 type RunesTest struct {
-	in	string;
-	out	[]int;
-	lossy	bool;
+	in    string
+	out   []int
+	lossy bool
 }
 
 var RunesTests = []RunesTest{
@@ -484,15 +484,15 @@ var RunesTests = []RunesTest{
 
 func TestRunes(t *testing.T) {
 	for _, tt := range RunesTests {
-		tin := strings.Bytes(tt.in);
-		a := Runes(tin);
+		tin := strings.Bytes(tt.in)
+		a := Runes(tin)
 		if !runesEqual(a, tt.out) {
-			t.Errorf("Runes(%q) = %v; want %v", tin, a, tt.out);
-			continue;
+			t.Errorf("Runes(%q) = %v; want %v", tin, a, tt.out)
+			continue
 		}
 		if !tt.lossy {
 			// can only test reassembly if we didn't lose information
-			s := string(a);
+			s := string(a)
 			if s != tt.in {
 				t.Errorf("string(Runes(%q)) = %x; want %x", tin, s, tin)
 			}
diff --git a/src/pkg/compress/flate/deflate.go b/src/pkg/compress/flate/deflate.go
index d07e46525..18bb353d2 100644
--- a/src/pkg/compress/flate/deflate.go
+++ b/src/pkg/compress/flate/deflate.go
@@ -5,55 +5,55 @@
 package flate
 
 import (
-	"io";
-	"math";
-	"os";
+	"io"
+	"math"
+	"os"
 )
 
 const (
-	NoCompression		= 0;
-	BestSpeed		= 1;
-	fastCompression		= 3;
-	BestCompression		= 9;
-	DefaultCompression	= -1;
-	logMaxOffsetSize	= 15;	// Standard DEFLATE
-	wideLogMaxOffsetSize	= 22;	// Wide DEFLATE
-	minMatchLength		= 3;	// The smallest match that the deflater looks for
-	maxMatchLength		= 258;	// The longest match for the deflater
-	minOffsetSize		= 1;	// The shortest offset that makes any sence
+	NoCompression        = 0
+	BestSpeed            = 1
+	fastCompression      = 3
+	BestCompression      = 9
+	DefaultCompression   = -1
+	logMaxOffsetSize     = 15  // Standard DEFLATE
+	wideLogMaxOffsetSize = 22  // Wide DEFLATE
+	minMatchLength       = 3   // The smallest match that the deflater looks for
+	maxMatchLength       = 258 // The longest match for the deflater
+	minOffsetSize        = 1   // The shortest offset that makes any sence
 
 	// The maximum number of tokens we put into a single flat block, just too
 	// stop things from getting too large.
-	maxFlateBlockTokens	= 1 << 14;
-	maxStoreBlockSize	= 65535;
-	hashBits		= 15;
-	hashSize		= 1 << hashBits;
-	hashMask		= (1 << hashBits) - 1;
-	hashShift		= (hashBits + minMatchLength - 1) / minMatchLength;
+	maxFlateBlockTokens = 1 << 14
+	maxStoreBlockSize   = 65535
+	hashBits            = 15
+	hashSize            = 1 << hashBits
+	hashMask            = (1 << hashBits) - 1
+	hashShift           = (hashBits + minMatchLength - 1) / minMatchLength
 )
 
 type syncPipeReader struct {
-	*io.PipeReader;
-	closeChan	chan bool;
+	*io.PipeReader
+	closeChan chan bool
 }
 
 func (sr *syncPipeReader) CloseWithError(err os.Error) os.Error {
-	retErr := sr.PipeReader.CloseWithError(err);
-	sr.closeChan <- true;	// finish writer close
-	return retErr;
+	retErr := sr.PipeReader.CloseWithError(err)
+	sr.closeChan <- true // finish writer close
+	return retErr
 }
 
 type syncPipeWriter struct {
-	*io.PipeWriter;
-	closeChan	chan bool;
+	*io.PipeWriter
+	closeChan chan bool
 }
 
 type compressionLevel struct {
-	good, lazy, nice, chain, fastSkipHashing int;
+	good, lazy, nice, chain, fastSkipHashing int
 }
 
 var levels = []compressionLevel{
-	compressionLevel{},	// 0
+	compressionLevel{}, // 0
 	// For levels 1-3 we don't bother trying with lazy matches
 	compressionLevel{3, 0, 8, 4, 4},
 	compressionLevel{3, 0, 16, 8, 5},
@@ -69,67 +69,67 @@ var levels = []compressionLevel{
 }
 
 func (sw *syncPipeWriter) Close() os.Error {
-	err := sw.PipeWriter.Close();
-	<-sw.closeChan;	// wait for reader close
-	return err;
+	err := sw.PipeWriter.Close()
+	<-sw.closeChan // wait for reader close
+	return err
 }
 
 func syncPipe() (*syncPipeReader, *syncPipeWriter) {
-	r, w := io.Pipe();
-	sr := &syncPipeReader{r, make(chan bool, 1)};
-	sw := &syncPipeWriter{w, sr.closeChan};
-	return sr, sw;
+	r, w := io.Pipe()
+	sr := &syncPipeReader{r, make(chan bool, 1)}
+	sw := &syncPipeWriter{w, sr.closeChan}
+	return sr, sw
 }
 
 type deflater struct {
-	level		int;
-	logWindowSize	uint;
-	w		*huffmanBitWriter;
-	r		io.Reader;
+	level         int
+	logWindowSize uint
+	w             *huffmanBitWriter
+	r             io.Reader
 	// (1 << logWindowSize) - 1.
-	windowMask	int;
+	windowMask int
 
 	// hashHead[hashValue] contains the largest inputIndex with the specified hash value
-	hashHead	[]int;
+	hashHead []int
 
 	// If hashHead[hashValue] is within the current window, then
 	// hashPrev[hashHead[hashValue] & windowMask] contains the previous index
 	// with the same hash value.
-	hashPrev	[]int;
+	hashPrev []int
 
 	// If we find a match of length >= niceMatch, then we don't bother searching
 	// any further.
-	niceMatch	int;
+	niceMatch int
 
 	// If we find a match of length >= goodMatch, we only do a half-hearted
 	// effort at doing lazy matching starting at the next character
-	goodMatch	int;
+	goodMatch int
 
 	// The maximum number of chains we look at when finding a match
-	maxChainLength	int;
+	maxChainLength int
 
 	// The sliding window we use for matching
-	window	[]byte;
+	window []byte
 
 	// The index just past the last valid character
-	windowEnd	int;
+	windowEnd int
 
 	// index in "window" at which current block starts
-	blockStart	int;
+	blockStart int
 }
 
 func (d *deflater) flush() os.Error {
-	d.w.flush();
-	return d.w.err;
+	d.w.flush()
+	return d.w.err
 }
 
 func (d *deflater) fillWindow(index int) (int, os.Error) {
-	wSize := d.windowMask + 1;
+	wSize := d.windowMask + 1
 	if index >= wSize+wSize-(minMatchLength+maxMatchLength) {
 		// shift the window by wSize
-		copy(d.window, d.window[wSize:2*wSize]);
-		index -= wSize;
-		d.windowEnd -= wSize;
+		copy(d.window, d.window[wSize:2*wSize])
+		index -= wSize
+		d.windowEnd -= wSize
 		if d.blockStart >= wSize {
 			d.blockStart -= wSize
 		} else {
@@ -142,66 +142,66 @@ func (d *deflater) fillWindow(index int) (int, os.Error) {
 			d.hashPrev[i] = max(h-wSize, -1)
 		}
 	}
-	var count int;
-	var err os.Error;
-	count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1);
-	d.windowEnd += count;
+	var count int
+	var err os.Error
+	count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1)
+	d.windowEnd += count
 	if err == os.EOF {
 		return index, nil
 	}
-	return index, err;
+	return index, err
 }
 
 func (d *deflater) writeBlock(tokens []token, index int, eof bool) os.Error {
 	if index > 0 || eof {
-		var window []byte;
+		var window []byte
 		if d.blockStart <= index {
 			window = d.window[d.blockStart:index]
 		}
-		d.blockStart = index;
-		d.w.writeBlock(tokens, eof, window);
-		return d.w.err;
+		d.blockStart = index
+		d.w.writeBlock(tokens, eof, window)
+		return d.w.err
 	}
-	return nil;
+	return nil
 }
 
 // Try to find a match starting at index whose length is greater than prevSize.
 // We only look at chainCount possibilities before giving up.
 func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead int) (length, offset int, ok bool) {
-	win := d.window[0 : pos+min(maxMatchLength, lookahead)];
+	win := d.window[0 : pos+min(maxMatchLength, lookahead)]
 
 	// We quit when we get a match that's at least nice long
-	nice := min(d.niceMatch, len(win)-pos);
+	nice := min(d.niceMatch, len(win)-pos)
 
 	// If we've got a match that's good enough, only look in 1/4 the chain.
-	tries := d.maxChainLength;
-	length = prevLength;
+	tries := d.maxChainLength
+	length = prevLength
 	if length >= d.goodMatch {
 		tries >>= 2
 	}
 
-	w0 := win[pos];
-	w1 := win[pos+1];
-	wEnd := win[pos+length];
-	minIndex := pos - (d.windowMask + 1);
+	w0 := win[pos]
+	w1 := win[pos+1]
+	wEnd := win[pos+length]
+	minIndex := pos - (d.windowMask + 1)
 
 	for i := prevHead; tries > 0; tries-- {
 		if w0 == win[i] && w1 == win[i+1] && wEnd == win[i+length] {
 			// The hash function ensures that if win[i] and win[i+1] match, win[i+2] matches
 
-			n := 3;
+			n := 3
 			for pos+n < len(win) && win[i+n] == win[pos+n] {
 				n++
 			}
 			if n > length && (n > 3 || pos-i <= 4096) {
-				length = n;
-				offset = pos - i;
-				ok = true;
+				length = n
+				offset = pos - i
+				ok = true
 				if n >= nice {
 					// The match is good enough that we don't try to find a better one.
 					break
 				}
-				wEnd = win[pos+n];
+				wEnd = win[pos+n]
 			}
 		}
 		if i == minIndex {
@@ -212,21 +212,21 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
 			break
 		}
 	}
-	return;
+	return
 }
 
 func (d *deflater) writeStoredBlock(buf []byte) os.Error {
 	if d.w.writeStoredHeader(len(buf), false); d.w.err != nil {
 		return d.w.err
 	}
-	d.w.writeBytes(buf);
-	return d.w.err;
+	d.w.writeBytes(buf)
+	return d.w.err
 }
 
 func (d *deflater) storedDeflate() os.Error {
-	buf := make([]byte, maxStoreBlockSize);
+	buf := make([]byte, maxStoreBlockSize)
 	for {
-		n, err := d.r.Read(buf);
+		n, err := d.r.Read(buf)
 		if n > 0 {
 			if err := d.writeStoredBlock(buf[0:n]); err != nil {
 				return err
@@ -236,83 +236,83 @@ func (d *deflater) storedDeflate() os.Error {
 			if err == os.EOF {
 				break
 			}
-			return err;
+			return err
 		}
 	}
-	return nil;
+	return nil
 }
 
 func (d *deflater) doDeflate() (err os.Error) {
 	// init
-	d.windowMask = 1<<d.logWindowSize - 1;
-	d.hashHead = make([]int, hashSize);
-	d.hashPrev = make([]int, 1<<d.logWindowSize);
-	d.window = make([]byte, 2<<d.logWindowSize);
-	fillInts(d.hashHead, -1);
-	tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1);
-	l := levels[d.level];
-	d.goodMatch = l.good;
-	d.niceMatch = l.nice;
-	d.maxChainLength = l.chain;
-	lazyMatch := l.lazy;
-	length := minMatchLength - 1;
-	offset := 0;
-	byteAvailable := false;
-	isFastDeflate := l.fastSkipHashing != 0;
-	index := 0;
+	d.windowMask = 1<<d.logWindowSize - 1
+	d.hashHead = make([]int, hashSize)
+	d.hashPrev = make([]int, 1<<d.logWindowSize)
+	d.window = make([]byte, 2<<d.logWindowSize)
+	fillInts(d.hashHead, -1)
+	tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1)
+	l := levels[d.level]
+	d.goodMatch = l.good
+	d.niceMatch = l.nice
+	d.maxChainLength = l.chain
+	lazyMatch := l.lazy
+	length := minMatchLength - 1
+	offset := 0
+	byteAvailable := false
+	isFastDeflate := l.fastSkipHashing != 0
+	index := 0
 	// run
 	if index, err = d.fillWindow(index); err != nil {
 		return
 	}
-	maxOffset := d.windowMask + 1;	// (1 << logWindowSize);
+	maxOffset := d.windowMask + 1 // (1 << logWindowSize);
 	// only need to change when you refill the window
-	windowEnd := d.windowEnd;
-	maxInsertIndex := windowEnd - (minMatchLength - 1);
-	ti := 0;
+	windowEnd := d.windowEnd
+	maxInsertIndex := windowEnd - (minMatchLength - 1)
+	ti := 0
 
-	hash := int(0);
+	hash := int(0)
 	if index < maxInsertIndex {
 		hash = int(d.window[index])<<hashShift + int(d.window[index+1])
 	}
-	chainHead := -1;
+	chainHead := -1
 	for {
 		if index > windowEnd {
 			panic("index > windowEnd")
 		}
-		lookahead := windowEnd - index;
+		lookahead := windowEnd - index
 		if lookahead < minMatchLength+maxMatchLength {
 			if index, err = d.fillWindow(index); err != nil {
 				return
 			}
-			windowEnd = d.windowEnd;
+			windowEnd = d.windowEnd
 			if index > windowEnd {
 				panic("index > windowEnd")
 			}
-			maxInsertIndex = windowEnd - (minMatchLength - 1);
-			lookahead = windowEnd - index;
+			maxInsertIndex = windowEnd - (minMatchLength - 1)
+			lookahead = windowEnd - index
 			if lookahead == 0 {
 				break
 			}
 		}
 		if index < maxInsertIndex {
 			// Update the hash
-			hash = (hash<<hashShift + int(d.window[index+2])) & hashMask;
-			chainHead = d.hashHead[hash];
-			d.hashPrev[index&d.windowMask] = chainHead;
-			d.hashHead[hash] = index;
+			hash = (hash<<hashShift + int(d.window[index+2])) & hashMask
+			chainHead = d.hashHead[hash]
+			d.hashPrev[index&d.windowMask] = chainHead
+			d.hashHead[hash] = index
 		}
-		prevLength := length;
-		prevOffset := offset;
-		minIndex := max(index-maxOffset, 0);
-		length = minMatchLength - 1;
-		offset = 0;
+		prevLength := length
+		prevOffset := offset
+		minIndex := max(index-maxOffset, 0)
+		length = minMatchLength - 1
+		offset = 0
 
 		if chainHead >= minIndex &&
 			(isFastDeflate && lookahead > minMatchLength-1 ||
 				!isFastDeflate && lookahead > prevLength && prevLength < lazyMatch) {
 			if newLength, newOffset, ok := d.findMatch(index, chainHead, minMatchLength-1, lookahead); ok {
-				length = newLength;
-				offset = newOffset;
+				length = newLength
+				offset = newOffset
 			}
 		}
 		if isFastDeflate && length >= minMatchLength ||
@@ -324,13 +324,13 @@ func (d *deflater) doDeflate() (err os.Error) {
 			} else {
 				tokens[ti] = matchToken(uint32(prevLength-minMatchLength), uint32(prevOffset-minOffsetSize))
 			}
-			ti++;
+			ti++
 			// Insert in the hash table all strings up to the end of the match.
 			// index and index-1 are already inserted. If there is not enough
 			// lookahead, the last two strings are not inserted into the hash
 			// table.
 			if length <= l.fastSkipHashing {
-				var newIndex int;
+				var newIndex int
 				if isFastDeflate {
 					newIndex = index + length
 				} else {
@@ -338,47 +338,47 @@ func (d *deflater) doDeflate() (err os.Error) {
 				}
 				for index++; index < newIndex; index++ {
 					if index < maxInsertIndex {
-						hash = (hash<<hashShift + int(d.window[index+2])) & hashMask;
+						hash = (hash<<hashShift + int(d.window[index+2])) & hashMask
 						// Get previous value with the same hash.
 						// Our chain should point to the previous value.
-						d.hashPrev[index&d.windowMask] = d.hashHead[hash];
+						d.hashPrev[index&d.windowMask] = d.hashHead[hash]
 						// Set the head of the hash chain to us.
-						d.hashHead[hash] = index;
+						d.hashHead[hash] = index
 					}
 				}
 				if !isFastDeflate {
-					byteAvailable = false;
-					length = minMatchLength - 1;
+					byteAvailable = false
+					length = minMatchLength - 1
 				}
 			} else {
 				// For matches this long, we don't bother inserting each individual
 				// item into the table.
-				index += length;
-				hash = (int(d.window[index])<<hashShift + int(d.window[index+1]));
+				index += length
+				hash = (int(d.window[index])<<hashShift + int(d.window[index+1]))
 			}
 			if ti == maxFlateBlockTokens {
 				// The block includes the current character
 				if err = d.writeBlock(tokens, index, false); err != nil {
 					return
 				}
-				ti = 0;
+				ti = 0
 			}
 		} else {
 			if isFastDeflate || byteAvailable {
-				i := index - 1;
+				i := index - 1
 				if isFastDeflate {
 					i = index
 				}
-				tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF);
-				ti++;
+				tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF)
+				ti++
 				if ti == maxFlateBlockTokens {
 					if err = d.writeBlock(tokens, i+1, false); err != nil {
 						return
 					}
-					ti = 0;
+					ti = 0
 				}
 			}
-			index++;
+			index++
 			if !isFastDeflate {
 				byteAvailable = true
 			}
@@ -387,8 +387,8 @@ func (d *deflater) doDeflate() (err os.Error) {
 	}
 	if byteAvailable {
 		// There is still one pending token that needs to be flushed
-		tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF);
-		ti++;
+		tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF)
+		ti++
 	}
 
 	if ti > 0 {
@@ -396,21 +396,21 @@ func (d *deflater) doDeflate() (err os.Error) {
 			return
 		}
 	}
-	return;
+	return
 }
 
 func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize uint) (err os.Error) {
-	d.r = r;
-	d.w = newHuffmanBitWriter(w);
-	d.level = level;
-	d.logWindowSize = logWindowSize;
+	d.r = r
+	d.w = newHuffmanBitWriter(w)
+	d.level = level
+	d.logWindowSize = logWindowSize
 
 	switch {
 	case level == NoCompression:
 		err = d.storedDeflate()
 	case level == DefaultCompression:
-		d.level = 6;
-		fallthrough;
+		d.level = 6
+		fallthrough
 	case 1 <= level && level <= 9:
 		err = d.doDeflate()
 	default:
@@ -423,17 +423,17 @@ func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize u
 	if d.w.writeStoredHeader(0, true); d.w.err != nil {
 		return d.w.err
 	}
-	return d.flush();
+	return d.flush()
 }
 
 func newDeflater(w io.Writer, level int, logWindowSize uint) io.WriteCloser {
-	var d deflater;
-	pr, pw := syncPipe();
+	var d deflater
+	pr, pw := syncPipe()
 	go func() {
-		err := d.deflater(pr, w, level, logWindowSize);
-		pr.CloseWithError(err);
-	}();
-	return pw;
+		err := d.deflater(pr, w, level, logWindowSize)
+		pr.CloseWithError(err)
+	}()
+	return pw
 }
 
 func NewDeflater(w io.Writer, level int) io.WriteCloser {
diff --git a/src/pkg/compress/flate/deflate_test.go b/src/pkg/compress/flate/deflate_test.go
index 9d5ada994..1ac8059b3 100644
--- a/src/pkg/compress/flate/deflate_test.go
+++ b/src/pkg/compress/flate/deflate_test.go
@@ -5,27 +5,27 @@
 package flate
 
 import (
-	"bytes";
-	"fmt";
-	"io/ioutil";
-	"os";
-	"testing";
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
 )
 
 type deflateTest struct {
-	in	[]byte;
-	level	int;
-	out	[]byte;
+	in    []byte
+	level int
+	out   []byte
 }
 
 type deflateInflateTest struct {
-	in []byte;
+	in []byte
 }
 
 type reverseBitsTest struct {
-	in		uint16;
-	bitCount	uint8;
-	out		uint16;
+	in       uint16
+	bitCount uint8
+	out      uint16
 }
 
 var deflateTests = []*deflateTest{
@@ -70,19 +70,19 @@ var reverseBitsTests = []*reverseBitsTest{
 }
 
 func getLargeDataChunk() []byte {
-	result := make([]byte, 100000);
+	result := make([]byte, 100000)
 	for i := range result {
 		result[i] = byte(int64(i) * int64(i) & 0xFF)
 	}
-	return result;
+	return result
 }
 
 func TestDeflate(t *testing.T) {
 	for _, h := range deflateTests {
-		buffer := bytes.NewBuffer([]byte{});
-		w := NewDeflater(buffer, h.level);
-		w.Write(h.in);
-		w.Close();
+		buffer := bytes.NewBuffer([]byte{})
+		w := NewDeflater(buffer, h.level)
+		w.Write(h.in)
+		w.Close()
 		if bytes.Compare(buffer.Bytes(), h.out) != 0 {
 			t.Errorf("buffer is wrong; level = %v, buffer.Bytes() = %v, expected output = %v",
 				h.level, buffer.Bytes(), h.out)
@@ -91,21 +91,21 @@ func TestDeflate(t *testing.T) {
 }
 
 func testToFromWithLevel(t *testing.T, level int, input []byte, name string) os.Error {
-	buffer := bytes.NewBuffer([]byte{});
-	w := NewDeflater(buffer, level);
-	w.Write(input);
-	w.Close();
-	inflater := NewInflater(buffer);
-	decompressed, err := ioutil.ReadAll(inflater);
+	buffer := bytes.NewBuffer([]byte{})
+	w := NewDeflater(buffer, level)
+	w.Write(input)
+	w.Close()
+	inflater := NewInflater(buffer)
+	decompressed, err := ioutil.ReadAll(inflater)
 	if err != nil {
-		t.Errorf("reading inflater: %s", err);
-		return err;
+		t.Errorf("reading inflater: %s", err)
+		return err
 	}
-	inflater.Close();
+	inflater.Close()
 	if bytes.Compare(input, decompressed) != 0 {
 		t.Errorf("decompress(compress(data)) != data: level=%d input=%s", level, name)
 	}
-	return nil;
+	return nil
 }
 
 func testToFrom(t *testing.T, input []byte, name string) {
@@ -130,8 +130,8 @@ func TestReverseBits(t *testing.T) {
 }
 
 func TestDeflateInflateString(t *testing.T) {
-	gold := bytes.NewBufferString(getEdata()).Bytes();
-	testToFromWithLevel(t, 1, gold, "2.718281828...");
+	gold := bytes.NewBufferString(getEdata()).Bytes()
+	testToFromWithLevel(t, 1, gold, "2.718281828...")
 }
 
 func getEdata() string {
diff --git a/src/pkg/compress/flate/flate_test.go b/src/pkg/compress/flate/flate_test.go
index e2a97b368..d7a9a3d24 100644
--- a/src/pkg/compress/flate/flate_test.go
+++ b/src/pkg/compress/flate/flate_test.go
@@ -9,9 +9,9 @@
 package flate
 
 import (
-	"bytes";
-	"reflect";
-	"testing";
+	"bytes"
+	"reflect"
+	"testing"
 )
 
 // The Huffman code lengths used by the fixed-format Huffman blocks.
@@ -45,9 +45,9 @@ var fixedHuffmanBits = [...]int{
 }
 
 type InitDecoderTest struct {
-	in	[]int;
-	out	huffmanDecoder;
-	ok	bool;
+	in  []int
+	out huffmanDecoder
+	ok  bool
 }
 
 var initDecoderTests = []*InitDecoderTest{
@@ -115,10 +115,10 @@ var initDecoderTests = []*InitDecoderTest{
 
 func TestInitDecoder(t *testing.T) {
 	for i, tt := range initDecoderTests {
-		var h huffmanDecoder;
+		var h huffmanDecoder
 		if h.init(tt.in) != tt.ok {
-			t.Errorf("test %d: init = %v", i, !tt.ok);
-			continue;
+			t.Errorf("test %d: init = %v", i, !tt.ok)
+			continue
 		}
 		if !reflect.DeepEqual(&h, &tt.out) {
 			t.Errorf("test %d:\nhave %v\nwant %v", i, h, tt.out)
@@ -127,9 +127,9 @@ func TestInitDecoder(t *testing.T) {
 }
 
 func TestUncompressedSource(t *testing.T) {
-	decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11}));
-	output := make([]byte, 1);
-	n, error := decoder.Read(output);
+	decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11}))
+	output := make([]byte, 1)
+	n, error := decoder.Read(output)
 	if n != 1 || error != nil {
 		t.Fatalf("decoder.Read() = %d, %v, want 1, nil", n, error)
 	}
diff --git a/src/pkg/compress/flate/huffman_bit_writer.go b/src/pkg/compress/flate/huffman_bit_writer.go
index a1ef3694c..eac196dfc 100644
--- a/src/pkg/compress/flate/huffman_bit_writer.go
+++ b/src/pkg/compress/flate/huffman_bit_writer.go
@@ -5,28 +5,28 @@
 package flate
 
 import (
-	"io";
-	"math";
-	"os";
-	"strconv";
+	"io"
+	"math"
+	"os"
+	"strconv"
 )
 
 const (
 	// The largest offset code.
-	offsetCodeCount	= 30;
+	offsetCodeCount = 30
 
 	// The largest offset code in the extensions.
-	extendedOffsetCodeCount	= 42;
+	extendedOffsetCodeCount = 42
 
 	// The special code used to mark the end of a block.
-	endBlockMarker	= 256;
+	endBlockMarker = 256
 
 	// The first length code.
-	lengthCodesStart	= 257;
+	lengthCodesStart = 257
 
 	// The number of codegen codes.
-	codegenCodeCount	= 19;
-	badCode			= 255;
+	codegenCodeCount = 19
+	badCode          = 255
 )
 
 // The number of extra bits needed by length code X - LENGTH_CODES_START.
@@ -72,28 +72,28 @@ var offsetBase = []uint32{
 var codegenOrder = []uint32{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}
 
 type huffmanBitWriter struct {
-	w	io.Writer;
+	w io.Writer
 	// Data waiting to be written is bytes[0:nbytes]
 	// and then the low nbits of bits.
-	bits		uint32;
-	nbits		uint32;
-	bytes		[64]byte;
-	nbytes		int;
-	literalFreq	[]int32;
-	offsetFreq	[]int32;
-	codegen		[]uint8;
-	codegenFreq	[]int32;
-	literalEncoding	*huffmanEncoder;
-	offsetEncoding	*huffmanEncoder;
-	codegenEncoding	*huffmanEncoder;
-	err		os.Error;
+	bits            uint32
+	nbits           uint32
+	bytes           [64]byte
+	nbytes          int
+	literalFreq     []int32
+	offsetFreq      []int32
+	codegen         []uint8
+	codegenFreq     []int32
+	literalEncoding *huffmanEncoder
+	offsetEncoding  *huffmanEncoder
+	codegenEncoding *huffmanEncoder
+	err             os.Error
 }
 
 type WrongValueError struct {
-	name	string;
-	from	int32;
-	to	int32;
-	value	int32;
+	name  string
+	from  int32
+	to    int32
+	value int32
 }
 
 func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter {
@@ -116,46 +116,46 @@ func (err WrongValueError) String() string {
 
 func (w *huffmanBitWriter) flushBits() {
 	if w.err != nil {
-		w.nbits = 0;
-		return;
-	}
-	bits := w.bits;
-	w.bits >>= 16;
-	w.nbits -= 16;
-	n := w.nbytes;
-	w.bytes[n] = byte(bits);
-	w.bytes[n+1] = byte(bits >> 8);
+		w.nbits = 0
+		return
+	}
+	bits := w.bits
+	w.bits >>= 16
+	w.nbits -= 16
+	n := w.nbytes
+	w.bytes[n] = byte(bits)
+	w.bytes[n+1] = byte(bits >> 8)
 	if n += 2; n >= len(w.bytes) {
-		_, w.err = w.w.Write(&w.bytes);
-		n = 0;
+		_, w.err = w.w.Write(&w.bytes)
+		n = 0
 	}
-	w.nbytes = n;
+	w.nbytes = n
 }
 
 func (w *huffmanBitWriter) flush() {
 	if w.err != nil {
-		w.nbits = 0;
-		return;
+		w.nbits = 0
+		return
 	}
-	n := w.nbytes;
+	n := w.nbytes
 	if w.nbits > 8 {
-		w.bytes[n] = byte(w.bits);
-		w.bits >>= 8;
-		w.nbits -= 8;
-		n++;
+		w.bytes[n] = byte(w.bits)
+		w.bits >>= 8
+		w.nbits -= 8
+		n++
 	}
 	if w.nbits > 0 {
-		w.bytes[n] = byte(w.bits);
-		w.nbits = 0;
-		n++;
+		w.bytes[n] = byte(w.bits)
+		w.nbits = 0
+		n++
 	}
-	w.bits = 0;
-	_, w.err = w.w.Write(w.bytes[0:n]);
-	w.nbytes = 0;
+	w.bits = 0
+	_, w.err = w.w.Write(w.bytes[0:n])
+	w.nbytes = 0
 }
 
 func (w *huffmanBitWriter) writeBits(b, nb int32) {
-	w.bits |= uint32(b) << w.nbits;
+	w.bits |= uint32(b) << w.nbits
 	if w.nbits += uint32(nb); w.nbits >= 16 {
 		w.flushBits()
 	}
@@ -165,24 +165,24 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) {
 	if w.err != nil {
 		return
 	}
-	n := w.nbytes;
+	n := w.nbytes
 	if w.nbits == 8 {
-		w.bytes[n] = byte(w.bits);
-		w.nbits = 0;
-		n++;
+		w.bytes[n] = byte(w.bits)
+		w.nbits = 0
+		n++
 	}
 	if w.nbits != 0 {
-		w.err = InternalError("writeBytes with unfinished bits");
-		return;
+		w.err = InternalError("writeBytes with unfinished bits")
+		return
 	}
 	if n != 0 {
-		_, w.err = w.w.Write(w.bytes[0:n]);
+		_, w.err = w.w.Write(w.bytes[0:n])
 		if w.err != nil {
 			return
 		}
 	}
-	w.nbytes = 0;
-	_, w.err = w.w.Write(bytes);
+	w.nbytes = 0
+	_, w.err = w.w.Write(bytes)
 }
 
 // RFC 1951 3.2.7 specifies a special run-length encoding for specifiying
@@ -197,82 +197,82 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) {
 //  numLiterals      The number of literals in literalEncoding
 //  numOffsets       The number of offsets in offsetEncoding
 func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int) {
-	fillInt32s(w.codegenFreq, 0);
+	fillInt32s(w.codegenFreq, 0)
 	// Note that we are using codegen both as a temporary variable for holding
 	// a copy of the frequencies, and as the place where we put the result.
 	// This is fine because the output is always shorter than the input used
 	// so far.
-	codegen := w.codegen;	// cache
+	codegen := w.codegen // cache
 	// Copy the concatenated code sizes to codegen.  Put a marker at the end.
-	copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits);
-	copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits);
-	codegen[numLiterals+numOffsets] = badCode;
+	copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits)
+	copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits)
+	codegen[numLiterals+numOffsets] = badCode
 
-	size := codegen[0];
-	count := 1;
-	outIndex := 0;
+	size := codegen[0]
+	count := 1
+	outIndex := 0
 	for inIndex := 1; size != badCode; inIndex++ {
 		// INVARIANT: We have seen "count" copies of size that have not yet
 		// had output generated for them.
-		nextSize := codegen[inIndex];
+		nextSize := codegen[inIndex]
 		if nextSize == size {
-			count++;
-			continue;
+			count++
+			continue
 		}
 		// We need to generate codegen indicating "count" of size.
 		if size != 0 {
-			codegen[outIndex] = size;
-			outIndex++;
-			w.codegenFreq[size]++;
-			count--;
+			codegen[outIndex] = size
+			outIndex++
+			w.codegenFreq[size]++
+			count--
 			for count >= 3 {
-				n := min(count, 6);
-				codegen[outIndex] = 16;
-				outIndex++;
-				codegen[outIndex] = uint8(n - 3);
-				outIndex++;
-				w.codegenFreq[16]++;
-				count -= n;
+				n := min(count, 6)
+				codegen[outIndex] = 16
+				outIndex++
+				codegen[outIndex] = uint8(n - 3)
+				outIndex++
+				w.codegenFreq[16]++
+				count -= n
 			}
 		} else {
 			for count >= 11 {
-				n := min(count, 138);
-				codegen[outIndex] = 18;
-				outIndex++;
-				codegen[outIndex] = uint8(n - 11);
-				outIndex++;
-				w.codegenFreq[18]++;
-				count -= n;
+				n := min(count, 138)
+				codegen[outIndex] = 18
+				outIndex++
+				codegen[outIndex] = uint8(n - 11)
+				outIndex++
+				w.codegenFreq[18]++
+				count -= n
 			}
 			if count >= 3 {
 				// count >= 3 && count <= 10
-				codegen[outIndex] = 17;
-				outIndex++;
-				codegen[outIndex] = uint8(count - 3);
-				outIndex++;
-				w.codegenFreq[17]++;
-				count = 0;
+				codegen[outIndex] = 17
+				outIndex++
+				codegen[outIndex] = uint8(count - 3)
+				outIndex++
+				w.codegenFreq[17]++
+				count = 0
 			}
 		}
-		count--;
+		count--
 		for ; count >= 0; count-- {
-			codegen[outIndex] = size;
-			outIndex++;
-			w.codegenFreq[size]++;
+			codegen[outIndex] = size
+			outIndex++
+			w.codegenFreq[size]++
 		}
 		// Set up invariant for next time through the loop.
-		size = nextSize;
-		count = 1;
+		size = nextSize
+		count = 1
 	}
 	// Marker indicating the end of the codegen.
-	codegen[outIndex] = badCode;
+	codegen[outIndex] = badCode
 }
 
 func (w *huffmanBitWriter) writeCode(code *huffmanEncoder, literal uint32) {
 	if w.err != nil {
 		return
 	}
-	w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal]));
+	w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal]))
 }
 
 // Write the header of a dynamic Huffman block to the output stream.
@@ -284,49 +284,49 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
 	if w.err != nil {
 		return
 	}
-	var firstBits int32 = 4;
+	var firstBits int32 = 4
 	if isEof {
 		firstBits = 5
 	}
-	w.writeBits(firstBits, 3);
-	w.writeBits(int32(numLiterals-257), 5);
+	w.writeBits(firstBits, 3)
+	w.writeBits(int32(numLiterals-257), 5)
 	if numOffsets > offsetCodeCount {
 		// Extended version of deflater
-		w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5);
-		w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3);
+		w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5)
+		w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3)
 	} else {
 		w.writeBits(int32(numOffsets-1), 5)
 	}
-	w.writeBits(int32(numCodegens-4), 4);
+	w.writeBits(int32(numCodegens-4), 4)
 
 	for i := 0; i < numCodegens; i++ {
-		value := w.codegenEncoding.codeBits[codegenOrder[i]];
-		w.writeBits(int32(value), 3);
+		value := w.codegenEncoding.codeBits[codegenOrder[i]]
+		w.writeBits(int32(value), 3)
 	}
 
-	i := 0;
+	i := 0
 	for {
-		var codeWord int = int(w.codegen[i]);
-		i++;
+		var codeWord int = int(w.codegen[i])
+		i++
 		if codeWord == badCode {
 			break
 		}
 		// The low byte contains the actual code to generate.
-		w.writeCode(w.codegenEncoding, uint32(codeWord));
+		w.writeCode(w.codegenEncoding, uint32(codeWord))
 
 		switch codeWord {
 		case 16:
-			w.writeBits(int32(w.codegen[i]), 2);
-			i++;
-			break;
+			w.writeBits(int32(w.codegen[i]), 2)
+			i++
+			break
 		case 17:
-			w.writeBits(int32(w.codegen[i]), 3);
-			i++;
-			break;
+			w.writeBits(int32(w.codegen[i]), 3)
+			i++
+			break
 		case 18:
-			w.writeBits(int32(w.codegen[i]), 7);
-			i++;
-			break;
+			w.writeBits(int32(w.codegen[i]), 7)
+			i++
+			break
 		}
 	}
 }
@@ -335,14 +335,14 @@ func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) {
 	if w.err != nil {
 		return
 	}
-	var flag int32;
+	var flag int32
 	if isEof {
 		flag = 1
 	}
-	w.writeBits(flag, 3);
-	w.flush();
-	w.writeBits(int32(length), 16);
-	w.writeBits(int32(^uint16(length)), 16);
+	w.writeBits(flag, 3)
+	w.flush()
+	w.writeBits(int32(length), 16)
+	w.writeBits(int32(^uint16(length)), 16)
 }
 
 func (w *huffmanBitWriter) writeFixedHeader(isEof bool) {
@@ -350,61 +350,61 @@ func (w *huffmanBitWriter) writeFixedHeader(isEof bool) {
 		return
 	}
 	// Indicate that we are a fixed Huffman block
-	var value int32 = 2;
+	var value int32 = 2
 	if isEof {
 		value = 3
 	}
-	w.writeBits(value, 3);
+	w.writeBits(value, 3)
 }
 
 func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
 	if w.err != nil {
 		return
 	}
-	fillInt32s(w.literalFreq, 0);
-	fillInt32s(w.offsetFreq, 0);
+	fillInt32s(w.literalFreq, 0)
+	fillInt32s(w.offsetFreq, 0)
 
-	n := len(tokens);
-	tokens = tokens[0 : n+1];
-	tokens[n] = endBlockMarker;
+	n := len(tokens)
+	tokens = tokens[0 : n+1]
+	tokens[n] = endBlockMarker
 
-	totalLength := -1;	// Subtract 1 for endBlock.
+	totalLength := -1 // Subtract 1 for endBlock.
 	for _, t := range tokens {
 		switch t.typ() {
 		case literalType:
-			w.literalFreq[t.literal()]++;
-			totalLength++;
-			break;
+			w.literalFreq[t.literal()]++
+			totalLength++
+			break
 		case matchType:
-			length := t.length();
-			offset := t.offset();
-			totalLength += int(length + 3);
-			w.literalFreq[lengthCodesStart+lengthCode(length)]++;
-			w.offsetFreq[offsetCode(offset)]++;
-			break;
+			length := t.length()
+			offset := t.offset()
+			totalLength += int(length + 3)
+			w.literalFreq[lengthCodesStart+lengthCode(length)]++
+			w.offsetFreq[offsetCode(offset)]++
+			break
 		}
 	}
-	w.literalEncoding.generate(w.literalFreq, 15);
-	w.offsetEncoding.generate(w.offsetFreq, 15);
+	w.literalEncoding.generate(w.literalFreq, 15)
+	w.offsetEncoding.generate(w.offsetFreq, 15)
 
 	// get the number of literals
-	numLiterals := len(w.literalFreq);
+	numLiterals := len(w.literalFreq)
 	for w.literalFreq[numLiterals-1] == 0 {
 		numLiterals--
 	}
 	// get the number of offsets
-	numOffsets := len(w.offsetFreq);
+	numOffsets := len(w.offsetFreq)
 	for numOffsets > 1 && w.offsetFreq[numOffsets-1] == 0 {
 		numOffsets--
 	}
-	storedBytes := 0;
+	storedBytes := 0
 	if input != nil {
 		storedBytes = len(input)
 	}
-	var extraBits int64;
-	var storedSize int64;
+	var extraBits int64
+	var storedSize int64
 	if storedBytes <= maxStoreBlockSize && input != nil {
-		storedSize = int64((storedBytes + 5) * 8);
+		storedSize = int64((storedBytes + 5) * 8)
 		// We only bother calculating the costs of the extra bits required by
 		// the length of offset fields (which will be the same for both fixed
 		// and dynamic encoding), if we need to compare those two encodings
@@ -423,7 +423,7 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
 
 	// Figure out which generates smaller code, fixed Huffman, dynamic
 	// Huffman, or just storing the data.
-	var fixedSize int64 = math.MaxInt64;
+	var fixedSize int64 = math.MaxInt64
 	if numOffsets <= offsetCodeCount {
 		fixedSize = int64(3) +
 			fixedLiteralEncoding.bitLength(w.literalFreq) +
@@ -432,13 +432,13 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
 	}
 	// Generate codegen and codegenFrequencies, which indicates how to encode
 	// the literalEncoding and the offsetEncoding.
-	w.generateCodegen(numLiterals, numOffsets);
-	w.codegenEncoding.generate(w.codegenFreq, 7);
-	numCodegens := len(w.codegenFreq);
+	w.generateCodegen(numLiterals, numOffsets)
+	w.codegenEncoding.generate(w.codegenFreq, 7)
+	numCodegens := len(w.codegenFreq)
 	for numCodegens > 4 && w.codegenFreq[codegenOrder[numCodegens-1]] == 0 {
 		numCodegens--
 	}
-	extensionSummand := 0;
+	extensionSummand := 0
 	if numOffsets > offsetCodeCount {
 		extensionSummand = 3
 	}
@@ -449,56 +449,56 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
 		int64(extraBits) +
 		int64(w.codegenFreq[16]*2) +
 		int64(w.codegenFreq[17]*3) +
-		int64(w.codegenFreq[18]*7);
+		int64(w.codegenFreq[18]*7)
 	dynamicSize := dynamicHeader +
 		w.literalEncoding.bitLength(w.literalFreq) +
-		w.offsetEncoding.bitLength(w.offsetFreq);
+		w.offsetEncoding.bitLength(w.offsetFreq)
 
 	if storedSize < fixedSize && storedSize < dynamicSize {
-		w.writeStoredHeader(storedBytes, eof);
-		w.writeBytes(input[0:storedBytes]);
-		return;
+		w.writeStoredHeader(storedBytes, eof)
+		w.writeBytes(input[0:storedBytes])
+		return
 	}
-	var literalEncoding *huffmanEncoder;
-	var offsetEncoding *huffmanEncoder;
+	var literalEncoding *huffmanEncoder
+	var offsetEncoding *huffmanEncoder
 
 	if fixedSize <= dynamicSize {
-		w.writeFixedHeader(eof);
-		literalEncoding = fixedLiteralEncoding;
-		offsetEncoding = fixedOffsetEncoding;
+		w.writeFixedHeader(eof)
+		literalEncoding = fixedLiteralEncoding
+		offsetEncoding = fixedOffsetEncoding
 	} else {
 		// Write the header.
-		w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof);
-		literalEncoding = w.literalEncoding;
-		offsetEncoding = w.offsetEncoding;
+		w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof)
+		literalEncoding = w.literalEncoding
+		offsetEncoding = w.offsetEncoding
 	}
 
 	// Write the tokens.
 	for _, t := range tokens {
 		switch t.typ() {
 		case literalType:
-			w.writeCode(literalEncoding, t.literal());
-			break;
+			w.writeCode(literalEncoding, t.literal())
+			break
 		case matchType:
 			// Write the length
-			length := t.length();
-			lengthCode := lengthCode(length);
-			w.writeCode(literalEncoding, lengthCode+lengthCodesStart);
-			extraLengthBits := int32(lengthExtraBits[lengthCode]);
+			length := t.length()
+			lengthCode := lengthCode(length)
+			w.writeCode(literalEncoding, lengthCode+lengthCodesStart)
+			extraLengthBits := int32(lengthExtraBits[lengthCode])
 			if extraLengthBits > 0 {
-				extraLength := int32(length - lengthBase[lengthCode]);
-				w.writeBits(extraLength, extraLengthBits);
+				extraLength := int32(length - lengthBase[lengthCode])
+				w.writeBits(extraLength, extraLengthBits)
 			}
 			// Write the offset
-			offset := t.offset();
-			offsetCode := offsetCode(offset);
-			w.writeCode(offsetEncoding, offsetCode);
-			extraOffsetBits := int32(offsetExtraBits[offsetCode]);
+			offset := t.offset()
+			offsetCode := offsetCode(offset)
+			w.writeCode(offsetEncoding, offsetCode)
+			extraOffsetBits := int32(offsetExtraBits[offsetCode])
 			if extraOffsetBits > 0 {
-				extraOffset := int32(offset - offsetBase[offsetCode]);
-				w.writeBits(extraOffset, extraOffsetBits);
+				extraOffset := int32(offset - offsetBase[offsetCode])
+				w.writeBits(extraOffset, extraOffsetBits)
 			}
-			break;
+			break
 		default:
 			panic("unknown token type: " + string(t))
 		}
diff --git a/src/pkg/compress/flate/huffman_code.go b/src/pkg/compress/flate/huffman_code.go
index f212d059d..94ff2dfb8 100644
--- a/src/pkg/compress/flate/huffman_code.go
+++ b/src/pkg/compress/flate/huffman_code.go
@@ -5,57 +5,57 @@
 package flate
 
 import (
-	"math";
-	"sort";
+	"math"
+	"sort"
 )
 
 type huffmanEncoder struct {
-	codeBits	[]uint8;
-	code		[]uint16;
+	codeBits []uint8
+	code     []uint16
 }
 
 type literalNode struct {
-	literal	uint16;
-	freq	int32;
+	literal uint16
+	freq    int32
 }
 
 type chain struct {
 	// The sum of the leaves in this tree
-	freq	int32;
+	freq int32
 
 	// The number of literals to the left of this item at this level
-	leafCount	int32;
+	leafCount int32
 
 	// The right child of this chain in the previous level.
-	up	*chain;
+	up *chain
 }
 
 type levelInfo struct {
 	// Our level.  for better printing
-	level	int32;
+	level int32
 
 	// The most recent chain generated for this level
-	lastChain	*chain;
+	lastChain *chain
 
 	// The frequency of the next character to add to this level
-	nextCharFreq	int32;
+	nextCharFreq int32
 
 	// The frequency of the next pair (from level below) to add to this level.
 	// Only valid if the "needed" value of the next lower level is 0.
-	nextPairFreq	int32;
+	nextPairFreq int32
 
 	// The number of chains remaining to generate for this level before moving
 	// up to the next level
-	needed	int32;
+	needed int32
 
 	// The levelInfo for level+1
-	up	*levelInfo;
+	up *levelInfo
 
 	// The levelInfo for level-1
-	down	*levelInfo;
+	down *levelInfo
 }
 
-func maxNode() literalNode	{ return literalNode{math.MaxUint16, math.MaxInt32} }
+func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} }
 
 func newHuffmanEncoder(size int) *huffmanEncoder {
 	return &huffmanEncoder{make([]uint8, size), make([]uint16, size)}
@@ -63,96 +63,96 @@ func newHuffmanEncoder(size int) *huffmanEncoder {
 
 // Generates a HuffmanCode corresponding to the fixed literal table
 func generateFixedLiteralEncoding() *huffmanEncoder {
-	h := newHuffmanEncoder(maxLit);
-	codeBits := h.codeBits;
-	code := h.code;
-	var ch uint16;
+	h := newHuffmanEncoder(maxLit)
+	codeBits := h.codeBits
+	code := h.code
+	var ch uint16
 	for ch = 0; ch < maxLit; ch++ {
-		var bits uint16;
-		var size uint8;
+		var bits uint16
+		var size uint8
 		switch {
 		case ch < 144:
 			// size 8, 000110000  .. 10111111
-			bits = ch + 48;
-			size = 8;
-			break;
+			bits = ch + 48
+			size = 8
+			break
 		case ch < 256:
 			// size 9, 110010000 .. 111111111
-			bits = ch + 400 - 144;
-			size = 9;
-			break;
+			bits = ch + 400 - 144
+			size = 9
+			break
 		case ch < 280:
 			// size 7, 0000000 .. 0010111
-			bits = ch - 256;
-			size = 7;
-			break;
+			bits = ch - 256
+			size = 7
+			break
 		default:
 			// size 8, 11000000 .. 11000111
-			bits = ch + 192 - 280;
-			size = 8;
+			bits = ch + 192 - 280
+			size = 8
 		}
-		codeBits[ch] = size;
-		code[ch] = reverseBits(bits, size);
+		codeBits[ch] = size
+		code[ch] = reverseBits(bits, size)
 	}
-	return h;
+	return h
 }
 
 func generateFixedOffsetEncoding() *huffmanEncoder {
-	h := newHuffmanEncoder(30);
-	codeBits := h.codeBits;
-	code := h.code;
+	h := newHuffmanEncoder(30)
+	codeBits := h.codeBits
+	code := h.code
 	for ch := uint16(0); ch < 30; ch++ {
-		codeBits[ch] = 5;
-		code[ch] = reverseBits(ch, 5);
+		codeBits[ch] = 5
+		code[ch] = reverseBits(ch, 5)
 	}
-	return h;
+	return h
 }
 
 var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding()
 var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding()
 
 func (h *huffmanEncoder) bitLength(freq []int32) int64 {
-	var total int64;
+	var total int64
 	for i, f := range freq {
 		if f != 0 {
 			total += int64(f) * int64(h.codeBits[i])
 		}
 	}
-	return total;
+	return total
 }
 
 // Generate elements in the chain using an iterative algorithm.
 func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
-	n := len(list);
-	list = list[0 : n+1];
-	list[n] = maxNode();
+	n := len(list)
+	list = list[0 : n+1]
+	list[n] = maxNode()
 
-	l := top;
+	l := top
 	for {
 		if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
 			// We've run out of both leafs and pairs.
 			// End all calculations for this level.
 			// To m sure we never come back to this level or any lower level,
 			// set nextPairFreq impossibly large.
-			l.lastChain = nil;
-			l.needed = 0;
-			l = l.up;
-			l.nextPairFreq = math.MaxInt32;
-			continue;
+			l.lastChain = nil
+			l.needed = 0
+			l = l.up
+			l.nextPairFreq = math.MaxInt32
+			continue
 		}
 
-		prevFreq := l.lastChain.freq;
+		prevFreq := l.lastChain.freq
 		if l.nextCharFreq < l.nextPairFreq {
 			// The next item on this row is a leaf node.
-			n := l.lastChain.leafCount + 1;
-			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
-			l.nextCharFreq = list[n].freq;
+			n := l.lastChain.leafCount + 1
+			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}
+			l.nextCharFreq = list[n].freq
 		} else {
 			// The next item on this row is a pair from the previous row.
 			// nextPairFreq isn't valid until we generate two
 			// more values in the level below
-			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
-			l.down.needed = 2;
+			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+			l.down.needed = 2
 		}
 
 		if l.needed--; l.needed == 0 {
@@ -160,13 +160,13 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
 			// Continue calculating one level up.  Fill in nextPairFreq
 			// of that level with the sum of the two nodes we've just calculated on
 			// this level.
-			up := l.up;
+			up := l.up
 			if up == nil {
 				// All done!
 				return
 			}
-			up.nextPairFreq = prevFreq + l.lastChain.freq;
-			l = up;
+			up.nextPairFreq = prevFreq + l.lastChain.freq
+			l = up
 		} else {
 			// If we stole from below, move down temporarily to replenish it.
 			for l.down.needed > 0 {
@@ -189,20 +189,20 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
 // return      An integer array in which array[i] indicates the number of literals
 //             that should be encoded in i bits.
 func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
-	n := int32(len(list));
-	list = list[0 : n+1];
-	list[n] = maxNode();
+	n := int32(len(list))
+	list = list[0 : n+1]
+	list[n] = maxNode()
 
 	// The tree can't have greater depth than n - 1, no matter what.  This
 	// saves a little bit of work in some small cases
-	maxBits = minInt32(maxBits, n-1);
+	maxBits = minInt32(maxBits, n-1)
 
 	// Create information about each of the levels.
 	// A bogus "Level 0" whose sole purpose is so that
 	// level1.prev.needed==0.  This makes level1.nextPairFreq
 	// be a legitimate value that never gets chosen.
-	top := &levelInfo{needed: 0};
-	chain2 := &chain{list[1].freq, 2, new(chain)};
+	top := &levelInfo{needed: 0}
+	chain2 := &chain{list[1].freq, 2, new(chain)}
 	for level := int32(1); level <= maxBits; level++ {
 		// For every level, the first two items are the first two characters.
 		// We initialize the levels as if we had already figured this out.
@@ -212,42 +212,42 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 			nextCharFreq: list[2].freq,
 			nextPairFreq: list[0].freq + list[1].freq,
 			down: top,
-		};
-		top.down.up = top;
+		}
+		top.down.up = top
 		if level == 1 {
 			top.nextPairFreq = math.MaxInt32
 		}
 	}
 
 	// We need a total of 2*n - 2 items at top level and have already generated 2.
-	top.needed = 2*n - 4;
+	top.needed = 2*n - 4
 
-	l := top;
+	l := top
 	for {
 		if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
 			// We've run out of both leafs and pairs.
 			// End all calculations for this level.
 			// To m sure we never come back to this level or any lower level,
 			// set nextPairFreq impossibly large.
-			l.lastChain = nil;
-			l.needed = 0;
-			l = l.up;
-			l.nextPairFreq = math.MaxInt32;
-			continue;
+			l.lastChain = nil
+			l.needed = 0
+			l = l.up
+			l.nextPairFreq = math.MaxInt32
+			continue
 		}
 
-		prevFreq := l.lastChain.freq;
+		prevFreq := l.lastChain.freq
 		if l.nextCharFreq < l.nextPairFreq {
 			// The next item on this row is a leaf node.
-			n := l.lastChain.leafCount + 1;
-			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
-			l.nextCharFreq = list[n].freq;
+			n := l.lastChain.leafCount + 1
+			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}
+			l.nextCharFreq = list[n].freq
 		} else {
 			// The next item on this row is a pair from the previous row.
 			// nextPairFreq isn't valid until we generate two
 			// more values in the level below
-			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
-			l.down.needed = 2;
+			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+			l.down.needed = 2
 		}
 
 		if l.needed--; l.needed == 0 {
@@ -255,13 +255,13 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 			// Continue calculating one level up.  Fill in nextPairFreq
 			// of that level with the sum of the two nodes we've just calculated on
 			// this level.
-			up := l.up;
+			up := l.up
 			if up == nil {
 				// All done!
 				break
 			}
-			up.nextPairFreq = prevFreq + l.lastChain.freq;
-			l = up;
+			up.nextPairFreq = prevFreq + l.lastChain.freq
+			l = up
 		} else {
 			// If we stole from below, move down temporarily to replenish it.
 			for l.down.needed > 0 {
@@ -277,23 +277,23 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 		panic("top.lastChain.leafCount != n")
 	}
 
-	bitCount := make([]int32, maxBits+1);
-	bits := 1;
+	bitCount := make([]int32, maxBits+1)
+	bits := 1
 	for chain := top.lastChain; chain.up != nil; chain = chain.up {
 		// chain.leafCount gives the number of literals requiring at least "bits"
 		// bits to encode.
-		bitCount[bits] = chain.leafCount - chain.up.leafCount;
-		bits++;
+		bitCount[bits] = chain.leafCount - chain.up.leafCount
+		bits++
 	}
-	return bitCount;
+	return bitCount
 }
 
 // Look at the leaves and assign them a bit count and an encoding as specified
 // in RFC 1951 3.2.2
 func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalNode) {
-	code := uint16(0);
+	code := uint16(0)
 	for n, bits := range bitCount {
-		code <<= 1;
+		code <<= 1
 		if n == 0 || bits == 0 {
 			continue
 		}
@@ -301,14 +301,14 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 		// are encoded using "bits" bits, and get the values
 		// code, code + 1, ....  The code values are
 		// assigned in literal order (not frequency order).
-		chunk := list[len(list)-int(bits):];
-		sortByLiteral(chunk);
+		chunk := list[len(list)-int(bits):]
+		sortByLiteral(chunk)
 		for _, node := range chunk {
-			h.codeBits[node.literal] = uint8(n);
-			h.code[node.literal] = reverseBits(code, uint8(n));
-			code++;
+			h.codeBits[node.literal] = uint8(n)
+			h.code[node.literal] = reverseBits(code, uint8(n))
+			code++
 		}
-		list = list[0 : len(list)-int(bits)];
+		list = list[0 : len(list)-int(bits)]
 	}
 }
 
@@ -317,58 +317,58 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 // freq  An array of frequencies, in which frequency[i] gives the frequency of literal i.
 // maxBits  The maximum number of bits to use for any literal.
 func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
-	list := make([]literalNode, len(freq)+1);
+	list := make([]literalNode, len(freq)+1)
 	// Number of non-zero literals
-	count := 0;
+	count := 0
 	// Set list to be the set of all non-zero literals and their frequencies
 	for i, f := range freq {
 		if f != 0 {
-			list[count] = literalNode{uint16(i), f};
-			count++;
+			list[count] = literalNode{uint16(i), f}
+			count++
 		} else {
 			h.codeBits[i] = 0
 		}
 	}
 	// If freq[] is shorter than codeBits[], fill rest of codeBits[] with zeros
-	h.codeBits = h.codeBits[0:len(freq)];
-	list = list[0:count];
+	h.codeBits = h.codeBits[0:len(freq)]
+	list = list[0:count]
 	if count <= 2 {
 		// Handle the small cases here, because they are awkward for the general case code.  With
 		// two or fewer literals, everything has bit length 1.
 		for i, node := range list {
 			// "list" is in order of increasing literal value.
-			h.codeBits[node.literal] = 1;
-			h.code[node.literal] = uint16(i);
+			h.codeBits[node.literal] = 1
+			h.code[node.literal] = uint16(i)
 		}
-		return;
+		return
 	}
-	sortByFreq(list);
+	sortByFreq(list)
 
 	// Get the number of literals for each bit count
-	bitCount := h.bitCounts(list, maxBits);
+	bitCount := h.bitCounts(list, maxBits)
 	// And do the assignment
-	h.assignEncodingAndSize(bitCount, list);
+	h.assignEncodingAndSize(bitCount, list)
 }
 
 type literalNodeSorter struct {
-	a	[]literalNode;
-	less	func(i, j int) bool;
+	a    []literalNode
+	less func(i, j int) bool
 }
 
-func (s literalNodeSorter) Len() int	{ return len(s.a) }
+func (s literalNodeSorter) Len() int { return len(s.a) }
 
 func (s literalNodeSorter) Less(i, j int) bool {
 	return s.less(i, j)
 }
 
-func (s literalNodeSorter) Swap(i, j int)	{ s.a[i], s.a[j] = s.a[j], s.a[i] }
+func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
 
 func sortByFreq(a []literalNode) {
-	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }};
-	sort.Sort(s);
+	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }}
+	sort.Sort(s)
 }
 
 func sortByLiteral(a []literalNode) {
-	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }};
-	sort.Sort(s);
+	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }}
+	sort.Sort(s)
 }
diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go
index 213846688..371fe94c5 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/src/pkg/compress/flate/inflate.go
@@ -8,18 +8,18 @@
 package flate
 
 import (
-	"bufio";
-	"io";
-	"os";
-	"strconv";
+	"bufio"
+	"io"
+	"os"
+	"strconv"
 )
 
 const (
-	maxCodeLen	= 16;		// max length of Huffman code
-	maxHist		= 32768;	// max history required
-	maxLit		= 286;
-	maxDist		= 32;
-	numCodes	= 19;	// number of codes in Huffman meta-code
+	maxCodeLen = 16    // max length of Huffman code
+	maxHist    = 32768 // max history required
+	maxLit     = 286
+	maxDist    = 32
+	numCodes   = 19 // number of codes in Huffman meta-code
 )
 
 // A CorruptInputError reports the presence of corrupt input at a given offset.
@@ -32,12 +32,12 @@ func (e CorruptInputError) String() string {
 // An InternalError reports an error in the flate code itself.
 type InternalError string
 
-func (e InternalError) String() string	{ return "flate: internal error: " + string(e) }
+func (e InternalError) String() string { return "flate: internal error: " + string(e) }
 
 // A ReadError reports an error encountered while reading input.
 type ReadError struct {
-	Offset	int64;		// byte offset where error occurred
-	Error	os.Error;	// error returned by underlying Read
+	Offset int64    // byte offset where error occurred
+	Error  os.Error // error returned by underlying Read
 }
 
 func (e *ReadError) String() string {
@@ -46,8 +46,8 @@ func (e *ReadError) String() string {
 
 // A WriteError reports an error encountered while writing output.
 type WriteError struct {
-	Offset	int64;		// byte offset where error occurred
-	Error	os.Error;	// error returned by underlying Read
+	Offset int64    // byte offset where error occurred
+	Error  os.Error // error returned by underlying Read
 }
 
 func (e *WriteError) String() string {
@@ -59,20 +59,20 @@ func (e *WriteError) String() string {
 // Proceedings of the IEEE, 61(7) (July 1973), pp 1046-1047.
 type huffmanDecoder struct {
 	// min, max code length
-	min, max	int;
+	min, max int
 
 	// limit[i] = largest code word of length i
 	// Given code v of length n,
 	// need more bits if v > limit[n].
-	limit	[maxCodeLen + 1]int;
+	limit [maxCodeLen + 1]int
 
 	// base[i] = smallest code word of length i - seq number
-	base	[maxCodeLen + 1]int;
+	base [maxCodeLen + 1]int
 
 	// codes[seq number] = output code.
 	// Given code v of length n, value is
 	// codes[v - base[n]].
-	codes	[]int;
+	codes []int
 }
 
 // Initialize Huffman decoding tables from array of code lengths.
@@ -81,8 +81,8 @@ func (h *huffmanDecoder) init(bits []int) bool {
 
 	// Count number of codes of each length,
 	// compute min and max length.
-	var count [maxCodeLen + 1]int;
-	var min, max int;
+	var count [maxCodeLen + 1]int
+	var min, max int
 	for _, n := range bits {
 		if n == 0 {
 			continue
@@ -93,31 +93,31 @@ func (h *huffmanDecoder) init(bits []int) bool {
 		if n > max {
 			max = n
 		}
-		count[n]++;
+		count[n]++
 	}
 	if max == 0 {
 		return false
 	}
 
-	h.min = min;
-	h.max = max;
+	h.min = min
+	h.max = max
 
 
 	// For each code range, compute
 	// nextcode (first code of that length),
 	// limit (last code of that length), and
 	// base (offset from first code to sequence number).
-	code := 0;
-	seq := 0;
-	var nextcode [maxCodeLen]int;
+	code := 0
+	seq := 0
+	var nextcode [maxCodeLen]int
 	for i := min; i <= max; i++ {
-		n := count[i];
-		nextcode[i] = code;
-		h.base[i] = code - seq;
-		code += n;
-		seq += n;
-		h.limit[i] = code - 1;
-		code <<= 1;
+		n := count[i]
+		nextcode[i] = code
+		h.base[i] = code - seq
+		code += n
+		seq += n
+		h.limit[i] = code - 1
+		code <<= 1
 	}
 
 	// Make array mapping sequence numbers to codes.
@@ -128,12 +128,12 @@ func (h *huffmanDecoder) init(bits []int) bool {
 		if n == 0 {
 			continue
 		}
-		code := nextcode[n];
-		nextcode[n]++;
-		seq := code - h.base[n];
-		h.codes[seq] = i;
+		code := nextcode[n]
+		nextcode[n]++
+		seq := code - h.base[n]
+		h.codes[seq] = i
 	}
-	return true;
+	return true
 }
 
 // Hard-coded Huffman tables for DEFLATE algorithm.
@@ -192,51 +192,51 @@ var fixedHuffmanDecoder = huffmanDecoder{
 // If the passed in io.Reader does not also have ReadByte,
 // the NewInflater will introduce its own buffering.
 type Reader interface {
-	io.Reader;
-	ReadByte() (c byte, err os.Error);
+	io.Reader
+	ReadByte() (c byte, err os.Error)
 }
 
 // Inflate state.
 type inflater struct {
 	// Input/output sources.
-	r	Reader;
-	w	io.Writer;
-	roffset	int64;
-	woffset	int64;
+	r       Reader
+	w       io.Writer
+	roffset int64
+	woffset int64
 
 	// Input bits, in top of b.
-	b	uint32;
-	nb	uint;
+	b  uint32
+	nb uint
 
 	// Huffman decoders for literal/length, distance.
-	h1, h2	huffmanDecoder;
+	h1, h2 huffmanDecoder
 
 	// Length arrays used to define Huffman codes.
-	bits		[maxLit + maxDist]int;
-	codebits	[numCodes]int;
+	bits     [maxLit + maxDist]int
+	codebits [numCodes]int
 
 	// Output history, buffer.
-	hist	[maxHist]byte;
-	hp	int;	// current output position in buffer
-	hfull	bool;	// buffer has filled at least once
+	hist  [maxHist]byte
+	hp    int  // current output position in buffer
+	hfull bool // buffer has filled at least once
 
 	// Temporary buffer (avoids repeated allocation).
-	buf	[4]byte;
+	buf [4]byte
 }
 
 func (f *inflater) inflate() (err os.Error) {
-	final := false;
+	final := false
 	for err == nil && !final {
 		for f.nb < 1+2 {
 			if err = f.moreBits(); err != nil {
 				return
 			}
 		}
-		final = f.b&1 == 1;
-		f.b >>= 1;
-		typ := f.b & 3;
-		f.b >>= 2;
-		f.nb -= 1 + 2;
+		final = f.b&1 == 1
+		f.b >>= 1
+		typ := f.b & 3
+		f.b >>= 2
+		f.nb -= 1 + 2
 		switch typ {
 		case 0:
 			err = f.dataBlock()
@@ -253,7 +253,7 @@ func (f *inflater) inflate() (err os.Error) {
 			err = CorruptInputError(f.roffset)
 		}
 	}
-	return;
+	return
 }
 
 // RFC 1951 section 3.2.7.
@@ -268,13 +268,13 @@ func (f *inflater) readHuffman() os.Error {
 			return err
 		}
 	}
-	nlit := int(f.b&0x1F) + 257;
-	f.b >>= 5;
-	ndist := int(f.b&0x1F) + 1;
-	f.b >>= 5;
-	nclen := int(f.b&0xF) + 4;
-	f.b >>= 4;
-	f.nb -= 5 + 5 + 4;
+	nlit := int(f.b&0x1F) + 257
+	f.b >>= 5
+	ndist := int(f.b&0x1F) + 1
+	f.b >>= 5
+	nclen := int(f.b&0xF) + 4
+	f.b >>= 4
+	f.nb -= 5 + 5 + 4
 
 	// (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
 	for i := 0; i < nclen; i++ {
@@ -283,9 +283,9 @@ func (f *inflater) readHuffman() os.Error {
 				return err
 			}
 		}
-		f.codebits[codeOrder[i]] = int(f.b & 0x7);
-		f.b >>= 3;
-		f.nb -= 3;
+		f.codebits[codeOrder[i]] = int(f.b & 0x7)
+		f.b >>= 3
+		f.nb -= 3
 	}
 	for i := nclen; i < len(codeOrder); i++ {
 		f.codebits[codeOrder[i]] = 0
@@ -297,53 +297,53 @@ func (f *inflater) readHuffman() os.Error {
 	// HLIT + 257 code lengths, HDIST + 1 code lengths,
 	// using the code length Huffman code.
 	for i, n := 0, nlit+ndist; i < n; {
-		x, err := f.huffSym(&f.h1);
+		x, err := f.huffSym(&f.h1)
 		if err != nil {
 			return err
 		}
 		if x < 16 {
 			// Actual length.
-			f.bits[i] = x;
-			i++;
-			continue;
+			f.bits[i] = x
+			i++
+			continue
 		}
 		// Repeat previous length or zero.
-		var rep int;
-		var nb uint;
-		var b int;
+		var rep int
+		var nb uint
+		var b int
 		switch x {
 		default:
 			return InternalError("unexpected length code")
 		case 16:
-			rep = 3;
-			nb = 2;
+			rep = 3
+			nb = 2
 			if i == 0 {
 				return CorruptInputError(f.roffset)
 			}
-			b = f.bits[i-1];
+			b = f.bits[i-1]
 		case 17:
-			rep = 3;
-			nb = 3;
-			b = 0;
+			rep = 3
+			nb = 3
+			b = 0
 		case 18:
-			rep = 11;
-			nb = 7;
-			b = 0;
+			rep = 11
+			nb = 7
+			b = 0
 		}
 		for f.nb < nb {
 			if err := f.moreBits(); err != nil {
 				return err
 			}
 		}
-		rep += int(f.b & uint32(1<<nb-1));
-		f.b >>= nb;
-		f.nb -= nb;
+		rep += int(f.b & uint32(1<<nb-1))
+		f.b >>= nb
+		f.nb -= nb
 		if i+rep > n {
 			return CorruptInputError(f.roffset)
 		}
 		for j := 0; j < rep; j++ {
-			f.bits[i] = b;
-			i++;
+			f.bits[i] = b
+			i++
 		}
 	}
 
@@ -351,7 +351,7 @@ func (f *inflater) readHuffman() os.Error {
 		return CorruptInputError(f.roffset)
 	}
 
-	return nil;
+	return nil
 }
 
 // Decode a single Huffman block from f.
@@ -360,46 +360,46 @@ func (f *inflater) readHuffman() os.Error {
 // fixed distance encoding associated with fixed Huffman blocks.
 func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
 	for {
-		v, err := f.huffSym(hl);
+		v, err := f.huffSym(hl)
 		if err != nil {
 			return err
 		}
-		var n uint;	// number of bits extra
-		var length int;
+		var n uint // number of bits extra
+		var length int
 		switch {
 		case v < 256:
-			f.hist[f.hp] = byte(v);
-			f.hp++;
+			f.hist[f.hp] = byte(v)
+			f.hp++
 			if f.hp == len(f.hist) {
 				if err = f.flush(); err != nil {
 					return err
 				}
 			}
-			continue;
+			continue
 		case v == 256:
 			return nil
 		// otherwise, reference to older data
 		case v < 265:
-			length = v - (257 - 3);
-			n = 0;
+			length = v - (257 - 3)
+			n = 0
 		case v < 269:
-			length = v*2 - (265*2 - 11);
-			n = 1;
+			length = v*2 - (265*2 - 11)
+			n = 1
 		case v < 273:
-			length = v*4 - (269*4 - 19);
-			n = 2;
+			length = v*4 - (269*4 - 19)
+			n = 2
 		case v < 277:
-			length = v*8 - (273*8 - 35);
-			n = 3;
+			length = v*8 - (273*8 - 35)
+			n = 3
 		case v < 281:
-			length = v*16 - (277*16 - 67);
-			n = 4;
+			length = v*16 - (277*16 - 67)
+			n = 4
 		case v < 285:
-			length = v*32 - (281*32 - 131);
-			n = 5;
+			length = v*32 - (281*32 - 131)
+			n = 5
 		default:
-			length = 258;
-			n = 0;
+			length = 258
+			n = 0
 		}
 		if n > 0 {
 			for f.nb < n {
@@ -407,21 +407,21 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
 					return err
 				}
 			}
-			length += int(f.b & uint32(1<<n-1));
-			f.b >>= n;
-			f.nb -= n;
+			length += int(f.b & uint32(1<<n-1))
+			f.b >>= n
+			f.nb -= n
 		}
 
-		var dist int;
+		var dist int
 		if hd == nil {
 			for f.nb < 5 {
 				if err = f.moreBits(); err != nil {
 					return err
 				}
 			}
-			dist = int(reverseByte[(f.b&0x1F)<<3]);
-			f.b >>= 5;
-			f.nb -= 5;
+			dist = int(reverseByte[(f.b&0x1F)<<3])
+			f.b >>= 5
+			f.nb -= 5
 		} else {
 			if dist, err = f.huffSym(hd); err != nil {
 				return err
@@ -434,18 +434,18 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
 		case dist >= 30:
 			return CorruptInputError(f.roffset)
 		default:
-			nb := uint(dist-2) >> 1;
+			nb := uint(dist-2) >> 1
 			// have 1 bit in bottom of dist, need nb more.
-			extra := (dist & 1) << nb;
+			extra := (dist & 1) << nb
 			for f.nb < nb {
 				if err = f.moreBits(); err != nil {
 					return err
 				}
 			}
-			extra |= int(f.b & uint32(1<<nb-1));
-			f.b >>= nb;
-			f.nb -= nb;
-			dist = 1<<(nb+1) + 1 + extra;
+			extra |= int(f.b & uint32(1<<nb-1))
+			f.b >>= nb
+			f.nb -= nb
+			dist = 1<<(nb+1) + 1 + extra
 		}
 
 		// Copy history[-dist:-dist+length] into output.
@@ -458,14 +458,14 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
 			return CorruptInputError(f.roffset)
 		}
 
-		p := f.hp - dist;
+		p := f.hp - dist
 		if p < 0 {
 			p += len(f.hist)
 		}
 		for i := 0; i < length; i++ {
-			f.hist[f.hp] = f.hist[p];
-			f.hp++;
-			p++;
+			f.hist[f.hp] = f.hist[p]
+			f.hp++
+			p++
 			if f.hp == len(f.hist) {
 				if err = f.flush(); err != nil {
 					return err
@@ -476,24 +476,24 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
 			}
 		}
 	}
-	panic("unreached");
+	panic("unreached")
 }
 
 // Copy a single uncompressed data block from input to output.
 func (f *inflater) dataBlock() os.Error {
 	// Uncompressed.
 	// Discard current half-byte.
-	f.nb = 0;
-	f.b = 0;
+	f.nb = 0
+	f.b = 0
 
 	// Length then ones-complement of length.
-	nr, err := io.ReadFull(f.r, f.buf[0:4]);
-	f.roffset += int64(nr);
+	nr, err := io.ReadFull(f.r, f.buf[0:4])
+	f.roffset += int64(nr)
 	if err != nil {
 		return &ReadError{f.roffset, err}
 	}
-	n := int(f.buf[0]) | int(f.buf[1])<<8;
-	nn := int(f.buf[2]) | int(f.buf[3])<<8;
+	n := int(f.buf[0]) | int(f.buf[1])<<8
+	nn := int(f.buf[2]) | int(f.buf[3])<<8
 	if uint16(nn) != uint16(^n) {
 		return CorruptInputError(f.roffset)
 	}
@@ -501,44 +501,44 @@ func (f *inflater) dataBlock() os.Error {
 	// Read len bytes into history,
 	// writing as history fills.
 	for n > 0 {
-		m := len(f.hist) - f.hp;
+		m := len(f.hist) - f.hp
 		if m > n {
 			m = n
 		}
-		m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m]);
-		f.roffset += int64(m);
+		m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m])
+		f.roffset += int64(m)
 		if err != nil {
 			return &ReadError{f.roffset, err}
 		}
-		n -= m;
-		f.hp += m;
+		n -= m
+		f.hp += m
 		if f.hp == len(f.hist) {
 			if err = f.flush(); err != nil {
 				return err
 			}
 		}
 	}
-	return nil;
+	return nil
 }
 
 func (f *inflater) moreBits() os.Error {
-	c, err := f.r.ReadByte();
+	c, err := f.r.ReadByte()
 	if err != nil {
 		if err == os.EOF {
 			err = io.ErrUnexpectedEOF
 		}
-		return err;
+		return err
 	}
-	f.roffset++;
-	f.b |= uint32(c) << f.nb;
-	f.nb += 8;
-	return nil;
+	f.roffset++
+	f.b |= uint32(c) << f.nb
+	f.nb += 8
+	return nil
 }
 
 // Read the next Huffman-encoded symbol from f according to h.
 func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
 	for n := uint(h.min); n <= uint(h.max); n++ {
-		lim := h.limit[n];
+		lim := h.limit[n]
 		if lim == -1 {
 			continue
 		}
@@ -547,16 +547,16 @@ func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
 				return 0, err
 			}
 		}
-		v := int(f.b & uint32(1<<n-1));
-		v <<= 16 - n;
-		v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8;	// reverse bits
+		v := int(f.b & uint32(1<<n-1))
+		v <<= 16 - n
+		v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8 // reverse bits
 		if v <= lim {
-			f.b >>= n;
-			f.nb -= n;
-			return h.codes[v-h.base[n]], nil;
+			f.b >>= n
+			f.nb -= n
+			return h.codes[v-h.base[n]], nil
 		}
 	}
-	return 0, CorruptInputError(f.roffset);
+	return 0, CorruptInputError(f.roffset)
 }
 
 // Flush any buffered output to the underlying writer.
@@ -564,39 +564,39 @@ func (f *inflater) flush() os.Error {
 	if f.hp == 0 {
 		return nil
 	}
-	n, err := f.w.Write(f.hist[0:f.hp]);
+	n, err := f.w.Write(f.hist[0:f.hp])
 	if n != f.hp && err == nil {
 		err = io.ErrShortWrite
 	}
 	if err != nil {
 		return &WriteError{f.woffset, err}
 	}
-	f.woffset += int64(f.hp);
-	f.hp = 0;
-	f.hfull = true;
-	return nil;
+	f.woffset += int64(f.hp)
+	f.hp = 0
+	f.hfull = true
+	return nil
 }
 
 func makeReader(r io.Reader) Reader {
 	if rr, ok := r.(Reader); ok {
 		return rr
 	}
-	return bufio.NewReader(r);
+	return bufio.NewReader(r)
 }
 
 // Inflate reads DEFLATE-compressed data from r and writes
 // the uncompressed data to w.
 func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
-	f.r = makeReader(r);
-	f.w = w;
-	f.woffset = 0;
+	f.r = makeReader(r)
+	f.w = w
+	f.woffset = 0
 	if err := f.inflate(); err != nil {
 		return err
 	}
 	if err := f.flush(); err != nil {
 		return err
 	}
-	return nil;
+	return nil
 }
 
 // NewInflater returns a new ReadCloser that can be used
@@ -604,8 +604,8 @@ func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
 // responsibility to call Close on the ReadCloser when
 // finished reading.
 func NewInflater(r io.Reader) io.ReadCloser {
-	var f inflater;
-	pr, pw := io.Pipe();
-	go func() { pw.CloseWithError(f.inflater(r, pw)) }();
-	return pr;
+	var f inflater
+	pr, pw := io.Pipe()
+	go func() { pw.CloseWithError(f.inflater(r, pw)) }()
+	return pr
 }
diff --git a/src/pkg/compress/flate/token.go b/src/pkg/compress/flate/token.go
index 139e1d0da..38aea5fa6 100644
--- a/src/pkg/compress/flate/token.go
+++ b/src/pkg/compress/flate/token.go
@@ -8,11 +8,11 @@ const (
 	// 2 bits:   type   0 = literal  1=EOF  2=Match   3=Unused
 	// 8 bits:   xlength = length - MIN_MATCH_LENGTH
 	// 22 bits   xoffset = offset - MIN_OFFSET_SIZE, or literal
-	lengthShift	= 22;
-	offsetMask	= 1<<lengthShift - 1;
-	typeMask	= 3 << 30;
-	literalType	= 0 << 30;
-	matchType	= 1 << 30;
+	lengthShift = 22
+	offsetMask  = 1<<lengthShift - 1
+	typeMask    = 3 << 30
+	literalType = 0 << 30
+	matchType   = 1 << 30
 )
 
 // The length code for length X (MIN_MATCH_LENGTH <= X <= MAX_MATCH_LENGTH)
@@ -68,7 +68,7 @@ var offsetCodes = [...]uint32{
 type token uint32
 
 // Convert a literal into a literal token.
-func literalToken(literal uint32) token	{ return token(literalType + literal) }
+func literalToken(literal uint32) token { return token(literalType + literal) }
 
 // Convert a < xlength, xoffset > pair into a match token.
 func matchToken(xlength uint32, xoffset uint32) token {
@@ -76,21 +76,21 @@ func matchToken(xlength uint32, xoffset uint32) token {
 }
 
 // Returns the type of a token
-func (t token) typ() uint32	{ return uint32(t) & typeMask }
+func (t token) typ() uint32 { return uint32(t) & typeMask }
 
 // Returns the literal of a literal token
-func (t token) literal() uint32	{ return uint32(t - literalType) }
+func (t token) literal() uint32 { return uint32(t - literalType) }
 
 // Returns the extra offset of a match token
-func (t token) offset() uint32	{ return uint32(t) & offsetMask }
+func (t token) offset() uint32 { return uint32(t) & offsetMask }
 
-func (t token) length() uint32	{ return uint32((t - matchType) >> lengthShift) }
+func (t token) length() uint32 { return uint32((t - matchType) >> lengthShift) }
 
-func lengthCode(len uint32) uint32	{ return lengthCodes[len] }
+func lengthCode(len uint32) uint32 { return lengthCodes[len] }
 
 // Returns the offset code corresponding to a specific offset
 func offsetCode(off uint32) uint32 {
-	const n = uint32(len(offsetCodes));
+	const n = uint32(len(offsetCodes))
 	switch {
 	case off < n:
 		return offsetCodes[off]
@@ -99,5 +99,5 @@ func offsetCode(off uint32) uint32 {
 	default:
 		return offsetCodes[off>>14] + 28
 	}
-	panic("unreachable");
+	panic("unreachable")
 }
diff --git a/src/pkg/compress/flate/util.go b/src/pkg/compress/flate/util.go
index f4e0b9ba3..aca5c78b2 100644
--- a/src/pkg/compress/flate/util.go
+++ b/src/pkg/compress/flate/util.go
@@ -8,21 +8,21 @@ func min(left int, right int) int {
 	if left < right {
 		return left
 	}
-	return right;
+	return right
 }
 
 func minInt32(left int32, right int32) int32 {
 	if left < right {
 		return left
 	}
-	return right;
+	return right
 }
 
 func max(left int, right int) int {
 	if left > right {
 		return left
 	}
-	return right;
+	return right
 }
 
 func fillInts(a []int, value int) {
@@ -56,17 +56,17 @@ func fillUint8s(a []uint8, value uint8) {
 }
 
 func copyInt8s(dst []int8, src []int8) int {
-	cnt := min(len(dst), len(src));
+	cnt := min(len(dst), len(src))
 	for i := 0; i < cnt; i++ {
 		dst[i] = src[i]
 	}
-	return cnt;
+	return cnt
 }
 
 func copyUint8s(dst []uint8, src []uint8) int {
-	cnt := min(len(dst), len(src));
+	cnt := min(len(dst), len(src))
 	for i := 0; i < cnt; i++ {
 		dst[i] = src[i]
 	}
-	return cnt;
+	return cnt
 }
diff --git a/src/pkg/compress/gzip/gunzip.go b/src/pkg/compress/gzip/gunzip.go
index ef84f16fc..b2a08830c 100644
--- a/src/pkg/compress/gzip/gunzip.go
+++ b/src/pkg/compress/gzip/gunzip.go
@@ -7,30 +7,30 @@
 package gzip
 
 import (
-	"bufio";
-	"compress/flate";
-	"hash";
-	"hash/crc32";
-	"io";
-	"os";
+	"bufio"
+	"compress/flate"
+	"hash"
+	"hash/crc32"
+	"io"
+	"os"
 )
 
 const (
-	gzipID1		= 0x1f;
-	gzipID2		= 0x8b;
-	gzipDeflate	= 8;
-	flagText	= 1 << 0;
-	flagHdrCrc	= 1 << 1;
-	flagExtra	= 1 << 2;
-	flagName	= 1 << 3;
-	flagComment	= 1 << 4;
+	gzipID1     = 0x1f
+	gzipID2     = 0x8b
+	gzipDeflate = 8
+	flagText    = 1 << 0
+	flagHdrCrc  = 1 << 1
+	flagExtra   = 1 << 2
+	flagName    = 1 << 3
+	flagComment = 1 << 4
 )
 
 func makeReader(r io.Reader) flate.Reader {
 	if rr, ok := r.(flate.Reader); ok {
 		return rr
 	}
-	return bufio.NewReader(r);
+	return bufio.NewReader(r)
 }
 
 var HeaderError os.Error = os.ErrorString("invalid gzip header")
@@ -53,34 +53,34 @@ var ChecksumError os.Error = os.ErrorString("gzip checksum error")
 // returned by Read as tentative until they receive the successful
 // (zero length, nil error) Read marking the end of the data.
 type Inflater struct {
-	Comment	string;	// comment
-	Extra	[]byte;	// "extra data"
-	Mtime	uint32;	// modification time (seconds since January 1, 1970)
-	Name	string;	// file name
-	OS	byte;	// operating system type
-
-	r		flate.Reader;
-	inflater	io.ReadCloser;
-	digest		hash.Hash32;
-	size		uint32;
-	flg		byte;
-	buf		[512]byte;
-	err		os.Error;
-	eof		bool;
+	Comment string // comment
+	Extra   []byte // "extra data"
+	Mtime   uint32 // modification time (seconds since January 1, 1970)
+	Name    string // file name
+	OS      byte   // operating system type
+
+	r        flate.Reader
+	inflater io.ReadCloser
+	digest   hash.Hash32
+	size     uint32
+	flg      byte
+	buf      [512]byte
+	err      os.Error
+	eof      bool
 }
 
 // NewInflater creates a new Inflater reading the given reader.
 // The implementation buffers input and may read more data than necessary from r.
 // It is the caller's responsibility to call Close on the Inflater when done.
 func NewInflater(r io.Reader) (*Inflater, os.Error) {
-	z := new(Inflater);
-	z.r = makeReader(r);
-	z.digest = crc32.NewIEEE();
+	z := new(Inflater)
+	z.r = makeReader(r)
+	z.digest = crc32.NewIEEE()
 	if err := z.readHeader(true); err != nil {
-		z.err = err;
-		return nil, err;
+		z.err = err
+		return nil, err
 	}
-	return z, nil;
+	return z, nil
 }
 
 // GZIP (RFC 1952) is little-endian, unlike ZLIB (RFC 1950).
@@ -89,12 +89,12 @@ func get4(p []byte) uint32 {
 }
 
 func (z *Inflater) readString() (string, os.Error) {
-	var err os.Error;
+	var err os.Error
 	for i := 0; ; i++ {
 		if i >= len(z.buf) {
 			return "", HeaderError
 		}
-		z.buf[i], err = z.r.ReadByte();
+		z.buf[i], err = z.r.ReadByte()
 		if err != nil {
 			return "", err
 		}
@@ -102,40 +102,40 @@ func (z *Inflater) readString() (string, os.Error) {
 			return string(z.buf[0:i]), nil
 		}
 	}
-	panic("not reached");
+	panic("not reached")
 }
 
 func (z *Inflater) read2() (uint32, os.Error) {
-	_, err := z.r.Read(z.buf[0:2]);
+	_, err := z.r.Read(z.buf[0:2])
 	if err != nil {
 		return 0, err
 	}
-	return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil;
+	return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil
 }
 
 func (z *Inflater) readHeader(save bool) os.Error {
-	_, err := io.ReadFull(z.r, z.buf[0:10]);
+	_, err := io.ReadFull(z.r, z.buf[0:10])
 	if err != nil {
 		return err
 	}
 	if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate {
 		return HeaderError
 	}
-	z.flg = z.buf[3];
+	z.flg = z.buf[3]
 	if save {
-		z.Mtime = get4(z.buf[4:8]);
+		z.Mtime = get4(z.buf[4:8])
 		// z.buf[8] is xfl, ignored
-		z.OS = z.buf[9];
+		z.OS = z.buf[9]
 	}
-	z.digest.Reset();
-	z.digest.Write(z.buf[0:10]);
+	z.digest.Reset()
+	z.digest.Write(z.buf[0:10])
 
 	if z.flg&flagExtra != 0 {
-		n, err := z.read2();
+		n, err := z.read2()
 		if err != nil {
 			return err
 		}
-		data := make([]byte, n);
+		data := make([]byte, n)
 		if _, err = io.ReadFull(z.r, data); err != nil {
 			return err
 		}
@@ -144,7 +144,7 @@ func (z *Inflater) readHeader(save bool) os.Error {
 		}
 	}
 
-	var s string;
+	var s string
 	if z.flg&flagName != 0 {
 		if s, err = z.readString(); err != nil {
 			return err
@@ -164,19 +164,19 @@ func (z *Inflater) readHeader(save bool) os.Error {
 	}
 
 	if z.flg&flagHdrCrc != 0 {
-		n, err := z.read2();
+		n, err := z.read2()
 		if err != nil {
 			return err
 		}
-		sum := z.digest.Sum32() & 0xFFFF;
+		sum := z.digest.Sum32() & 0xFFFF
 		if n != sum {
 			return HeaderError
 		}
 	}
 
-	z.digest.Reset();
-	z.inflater = flate.NewInflater(z.r);
-	return nil;
+	z.digest.Reset()
+	z.inflater = flate.NewInflater(z.r)
+	return nil
 }
 
 func (z *Inflater) Read(p []byte) (n int, err os.Error) {
@@ -187,37 +187,37 @@ func (z *Inflater) Read(p []byte) (n int, err os.Error) {
 		return 0, nil
 	}
 
-	n, err = z.inflater.Read(p);
-	z.digest.Write(p[0:n]);
-	z.size += uint32(n);
+	n, err = z.inflater.Read(p)
+	z.digest.Write(p[0:n])
+	z.size += uint32(n)
 	if n != 0 || err != os.EOF {
-		z.err = err;
-		return;
+		z.err = err
+		return
 	}
 
 	// Finished file; check checksum + size.
 	if _, err := io.ReadFull(z.r, z.buf[0:8]); err != nil {
-		z.err = err;
-		return 0, err;
+		z.err = err
+		return 0, err
 	}
-	crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8]);
-	sum := z.digest.Sum32();
+	crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8])
+	sum := z.digest.Sum32()
 	if sum != crc32 || isize != z.size {
-		z.err = ChecksumError;
-		return 0, z.err;
+		z.err = ChecksumError
+		return 0, z.err
 	}
 
 	// File is ok; is there another?
 	if err = z.readHeader(false); err != nil {
-		z.err = err;
-		return;
+		z.err = err
+		return
 	}
 
 	// Yes.  Reset and read from it.
-	z.digest.Reset();
-	z.size = 0;
-	return z.Read(p);
+	z.digest.Reset()
+	z.size = 0
+	return z.Read(p)
 }
 
 // Calling Close does not close the wrapped io.Reader originally passed to NewInflater.
-func (z *Inflater) Close() os.Error	{ return z.inflater.Close() }
+func (z *Inflater) Close() os.Error { return z.inflater.Close() }
diff --git a/src/pkg/compress/gzip/gunzip_test.go b/src/pkg/compress/gzip/gunzip_test.go
index 67b3b3ce2..3930985e3 100644
--- a/src/pkg/compress/gzip/gunzip_test.go
+++ b/src/pkg/compress/gzip/gunzip_test.go
@@ -5,22 +5,22 @@
 package gzip
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"testing";
+	"bytes"
+	"io"
+	"os"
+	"testing"
 )
 
 type gzipTest struct {
-	name	string;
-	desc	string;
-	raw	string;
-	gzip	[]byte;
-	err	os.Error;
+	name string
+	desc string
+	raw  string
+	gzip []byte
+	err  os.Error
 }
 
 var gzipTests = []gzipTest{
-	gzipTest{	// has 1 empty fixed-huffman block
+	gzipTest{ // has 1 empty fixed-huffman block
 		"empty.txt",
 		"empty.txt",
 		"",
@@ -32,7 +32,7 @@ var gzipTests = []gzipTest{
 		},
 		nil,
 	},
-	gzipTest{	// has 1 non-empty fixed huffman block
+	gzipTest{ // has 1 non-empty fixed huffman block
 		"hello.txt",
 		"hello.txt",
 		"hello world\n",
@@ -46,7 +46,7 @@ var gzipTests = []gzipTest{
 		},
 		nil,
 	},
-	gzipTest{	// concatenation
+	gzipTest{ // concatenation
 		"hello.txt",
 		"hello.txt x2",
 		"hello world\n" +
@@ -67,7 +67,7 @@ var gzipTests = []gzipTest{
 		},
 		nil,
 	},
-	gzipTest{	// has a fixed huffman block with some length-distance pairs
+	gzipTest{ // has a fixed huffman block with some length-distance pairs
 		"shesells.txt",
 		"shesells.txt",
 		"she sells seashells by the seashore\n",
@@ -83,7 +83,7 @@ var gzipTests = []gzipTest{
 		},
 		nil,
 	},
-	gzipTest{	// has dynamic huffman blocks
+	gzipTest{ // has dynamic huffman blocks
 		"gettysburg",
 		"gettysburg",
 		"  Four score and seven years ago our fathers brought forth on\n" +
@@ -221,7 +221,7 @@ var gzipTests = []gzipTest{
 		},
 		nil,
 	},
-	gzipTest{	// has 1 non-empty fixed huffman block then garbage
+	gzipTest{ // has 1 non-empty fixed huffman block then garbage
 		"hello.txt",
 		"hello.txt + garbage",
 		"hello world\n",
@@ -235,7 +235,7 @@ var gzipTests = []gzipTest{
 		},
 		HeaderError,
 	},
-	gzipTest{	// has 1 non-empty fixed huffman block not enough header
+	gzipTest{ // has 1 non-empty fixed huffman block not enough header
 		"hello.txt",
 		"hello.txt + garbage",
 		"hello world\n",
@@ -249,7 +249,7 @@ var gzipTests = []gzipTest{
 		},
 		io.ErrUnexpectedEOF,
 	},
-	gzipTest{	// has 1 non-empty fixed huffman block but corrupt checksum
+	gzipTest{ // has 1 non-empty fixed huffman block but corrupt checksum
 		"hello.txt",
 		"hello.txt + corrupt checksum",
 		"hello world\n",
@@ -263,7 +263,7 @@ var gzipTests = []gzipTest{
 		},
 		ChecksumError,
 	},
-	gzipTest{	// has 1 non-empty fixed huffman block but corrupt size
+	gzipTest{ // has 1 non-empty fixed huffman block but corrupt size
 		"hello.txt",
 		"hello.txt + corrupt size",
 		"hello world\n",
@@ -280,24 +280,24 @@ var gzipTests = []gzipTest{
 }
 
 func TestInflater(t *testing.T) {
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for _, tt := range gzipTests {
-		in := bytes.NewBuffer(tt.gzip);
-		gzip, err := NewInflater(in);
+		in := bytes.NewBuffer(tt.gzip)
+		gzip, err := NewInflater(in)
 		if err != nil {
-			t.Errorf("%s: NewInflater: %s", tt.name, err);
-			continue;
+			t.Errorf("%s: NewInflater: %s", tt.name, err)
+			continue
 		}
-		defer gzip.Close();
+		defer gzip.Close()
 		if tt.name != gzip.Name {
 			t.Errorf("%s: got name %s", tt.name, gzip.Name)
 		}
-		b.Reset();
-		n, err := io.Copy(b, gzip);
+		b.Reset()
+		n, err := io.Copy(b, gzip)
 		if err != tt.err {
 			t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err)
 		}
-		s := b.String();
+		s := b.String()
 		if s != tt.raw {
 			t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.name, n, s, len(tt.raw), tt.raw)
 		}
diff --git a/src/pkg/compress/zlib/reader.go b/src/pkg/compress/zlib/reader.go
index ffe5cbafc..c3a9d28ca 100644
--- a/src/pkg/compress/zlib/reader.go
+++ b/src/pkg/compress/zlib/reader.go
@@ -7,12 +7,12 @@
 package zlib
 
 import (
-	"bufio";
-	"compress/flate";
-	"hash";
-	"hash/adler32";
-	"io";
-	"os";
+	"bufio"
+	"compress/flate"
+	"hash"
+	"hash/adler32"
+	"io"
+	"os"
 )
 
 const zlibDeflate = 8
@@ -22,28 +22,28 @@ var HeaderError os.Error = os.ErrorString("invalid zlib header")
 var UnsupportedError os.Error = os.ErrorString("unsupported zlib format")
 
 type reader struct {
-	r		flate.Reader;
-	inflater	io.ReadCloser;
-	digest		hash.Hash32;
-	err		os.Error;
-	scratch		[4]byte;
+	r        flate.Reader
+	inflater io.ReadCloser
+	digest   hash.Hash32
+	err      os.Error
+	scratch  [4]byte
 }
 
 // NewInflater creates a new io.ReadCloser that satisfies reads by decompressing data read from r.
 // The implementation buffers input and may read more data than necessary from r.
 // It is the caller's responsibility to call Close on the ReadCloser when done.
 func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
-	z := new(reader);
+	z := new(reader)
 	if fr, ok := r.(flate.Reader); ok {
 		z.r = fr
 	} else {
 		z.r = bufio.NewReader(r)
 	}
-	_, err := io.ReadFull(z.r, z.scratch[0:2]);
+	_, err := io.ReadFull(z.r, z.scratch[0:2])
 	if err != nil {
 		return nil, err
 	}
-	h := uint(z.scratch[0])<<8 | uint(z.scratch[1]);
+	h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
 	if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
 		return nil, HeaderError
 	}
@@ -51,9 +51,9 @@ func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
 		// BUG(nigeltao): The zlib package does not implement the FDICT flag.
 		return nil, UnsupportedError
 	}
-	z.digest = adler32.New();
-	z.inflater = flate.NewInflater(z.r);
-	return z, nil;
+	z.digest = adler32.New()
+	z.inflater = flate.NewInflater(z.r)
+	return z, nil
 }
 
 func (z *reader) Read(p []byte) (n int, err os.Error) {
@@ -64,25 +64,25 @@ func (z *reader) Read(p []byte) (n int, err os.Error) {
 		return 0, nil
 	}
 
-	n, err = z.inflater.Read(p);
-	z.digest.Write(p[0:n]);
+	n, err = z.inflater.Read(p)
+	z.digest.Write(p[0:n])
 	if n != 0 || err != os.EOF {
-		z.err = err;
-		return;
+		z.err = err
+		return
 	}
 
 	// Finished file; check checksum.
 	if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
-		z.err = err;
-		return 0, err;
+		z.err = err
+		return 0, err
 	}
 	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
-	checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]);
+	checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
 	if checksum != z.digest.Sum32() {
-		z.err = ChecksumError;
-		return 0, z.err;
+		z.err = ChecksumError
+		return 0, z.err
 	}
-	return;
+	return
 }
 
 // Calling Close does not close the wrapped io.Reader originally passed to NewInflater.
@@ -90,6 +90,6 @@ func (z *reader) Close() os.Error {
 	if z.err != nil {
 		return z.err
 	}
-	z.err = z.inflater.Close();
-	return z.err;
+	z.err = z.inflater.Close()
+	return z.err
 }
diff --git a/src/pkg/compress/zlib/reader_test.go b/src/pkg/compress/zlib/reader_test.go
index 5e057ee21..3b349f5ee 100644
--- a/src/pkg/compress/zlib/reader_test.go
+++ b/src/pkg/compress/zlib/reader_test.go
@@ -5,17 +5,17 @@
 package zlib
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"testing";
+	"bytes"
+	"io"
+	"os"
+	"testing"
 )
 
 type zlibTest struct {
-	desc		string;
-	raw		string;
-	compressed	[]byte;
-	err		os.Error;
+	desc       string
+	raw        string
+	compressed []byte
+	err        os.Error
 }
 
 // Compare-to-golden test data was generated by the ZLIB example program at
@@ -68,26 +68,26 @@ var zlibTests = []zlibTest{
 }
 
 func TestInflater(t *testing.T) {
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for _, tt := range zlibTests {
-		in := bytes.NewBuffer(tt.compressed);
-		zlib, err := NewInflater(in);
+		in := bytes.NewBuffer(tt.compressed)
+		zlib, err := NewInflater(in)
 		if err != nil {
 			if err != tt.err {
 				t.Errorf("%s: NewInflater: %s", tt.desc, err)
 			}
-			continue;
+			continue
 		}
-		defer zlib.Close();
-		b.Reset();
-		n, err := io.Copy(b, zlib);
+		defer zlib.Close()
+		b.Reset()
+		n, err := io.Copy(b, zlib)
 		if err != nil {
 			if err != tt.err {
 				t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, tt.err)
 			}
-			continue;
+			continue
 		}
-		s := b.String();
+		s := b.String()
 		if s != tt.raw {
 			t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.desc, n, s, len(tt.raw), tt.raw)
 		}
diff --git a/src/pkg/compress/zlib/writer.go b/src/pkg/compress/zlib/writer.go
index 25abcde3b..0441b0463 100644
--- a/src/pkg/compress/zlib/writer.go
+++ b/src/pkg/compress/zlib/writer.go
@@ -5,28 +5,28 @@
 package zlib
 
 import (
-	"compress/flate";
-	"hash";
-	"hash/adler32";
-	"io";
-	"os";
+	"compress/flate"
+	"hash"
+	"hash/adler32"
+	"io"
+	"os"
 )
 
 // These constants are copied from the flate package, so that code that imports
 // "compress/zlib" does not also have to import "compress/flate".
 const (
-	NoCompression		= flate.NoCompression;
-	BestSpeed		= flate.BestSpeed;
-	BestCompression		= flate.BestCompression;
-	DefaultCompression	= flate.DefaultCompression;
+	NoCompression      = flate.NoCompression
+	BestSpeed          = flate.BestSpeed
+	BestCompression    = flate.BestCompression
+	DefaultCompression = flate.DefaultCompression
 )
 
 type writer struct {
-	w		io.Writer;
-	deflater	io.WriteCloser;
-	digest		hash.Hash32;
-	err		os.Error;
-	scratch		[4]byte;
+	w        io.Writer
+	deflater io.WriteCloser
+	digest   hash.Hash32
+	err      os.Error
+	scratch  [4]byte
 }
 
 // NewDeflater calls NewDeflaterLevel with the default compression level.
@@ -39,11 +39,11 @@ func NewDeflater(w io.Writer) (io.WriteCloser, os.Error) {
 // level is the compression level, which can be DefaultCompression, NoCompression,
 // or any integer value between BestSpeed and BestCompression (inclusive).
 func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
-	z := new(writer);
+	z := new(writer)
 	// ZLIB has a two-byte header (as documented in RFC 1950).
 	// The first four bits is the CINFO (compression info), which is 7 for the default deflate window size.
 	// The next four bits is the CM (compression method), which is 8 for deflate.
-	z.scratch[0] = 0x78;
+	z.scratch[0] = 0x78
 	// The next two bits is the FLEVEL (compression level). The four values are:
 	// 0=fastest, 1=fast, 2=default, 3=best.
 	// The next bit, FDICT, is unused, in this implementation.
@@ -60,14 +60,14 @@ func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
 	default:
 		return nil, os.NewError("level out of range")
 	}
-	_, err := w.Write(z.scratch[0:2]);
+	_, err := w.Write(z.scratch[0:2])
 	if err != nil {
 		return nil, err
 	}
-	z.w = w;
-	z.deflater = flate.NewDeflater(w, level);
-	z.digest = adler32.New();
-	return z, nil;
+	z.w = w
+	z.deflater = flate.NewDeflater(w, level)
+	z.digest = adler32.New()
+	return z, nil
 }
 
 func (z *writer) Write(p []byte) (n int, err os.Error) {
@@ -77,13 +77,13 @@ func (z *writer) Write(p []byte) (n int, err os.Error) {
 	if len(p) == 0 {
 		return 0, nil
 	}
-	n, err = z.deflater.Write(p);
+	n, err = z.deflater.Write(p)
 	if err != nil {
-		z.err = err;
-		return;
+		z.err = err
+		return
 	}
-	z.digest.Write(p);
-	return;
+	z.digest.Write(p)
+	return
 }
 
 // Calling Close does not close the wrapped io.Writer originally passed to NewDeflater.
@@ -91,16 +91,16 @@ func (z *writer) Close() os.Error {
 	if z.err != nil {
 		return z.err
 	}
-	z.err = z.deflater.Close();
+	z.err = z.deflater.Close()
 	if z.err != nil {
 		return z.err
 	}
-	checksum := z.digest.Sum32();
+	checksum := z.digest.Sum32()
 	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
-	z.scratch[0] = uint8(checksum >> 24);
-	z.scratch[1] = uint8(checksum >> 16);
-	z.scratch[2] = uint8(checksum >> 8);
-	z.scratch[3] = uint8(checksum >> 0);
-	_, z.err = z.w.Write(z.scratch[0:4]);
-	return z.err;
+	z.scratch[0] = uint8(checksum >> 24)
+	z.scratch[1] = uint8(checksum >> 16)
+	z.scratch[2] = uint8(checksum >> 8)
+	z.scratch[3] = uint8(checksum >> 0)
+	_, z.err = z.w.Write(z.scratch[0:4])
+	return z.err
 }
diff --git a/src/pkg/compress/zlib/writer_test.go b/src/pkg/compress/zlib/writer_test.go
index 963a072e9..97a9ed619 100644
--- a/src/pkg/compress/zlib/writer_test.go
+++ b/src/pkg/compress/zlib/writer_test.go
@@ -5,10 +5,10 @@
 package zlib
 
 import (
-	"io";
-	"io/ioutil";
-	"os";
-	"testing";
+	"io"
+	"io/ioutil"
+	"os"
+	"testing"
 )
 
 var filenames = []string{
@@ -20,85 +20,85 @@ var filenames = []string{
 // yields equivalent bytes to the original file.
 func testFileLevel(t *testing.T, fn string, level int) {
 	// Read the file, as golden output.
-	golden, err := os.Open(fn, os.O_RDONLY, 0444);
+	golden, err := os.Open(fn, os.O_RDONLY, 0444)
 	if err != nil {
-		t.Errorf("%s (level=%d): %v", fn, level, err);
-		return;
+		t.Errorf("%s (level=%d): %v", fn, level, err)
+		return
 	}
-	defer golden.Close();
+	defer golden.Close()
 
 	// Read the file again, and push it through a pipe that compresses at the write end, and decompresses at the read end.
-	raw, err := os.Open(fn, os.O_RDONLY, 0444);
+	raw, err := os.Open(fn, os.O_RDONLY, 0444)
 	if err != nil {
-		t.Errorf("%s (level=%d): %v", fn, level, err);
-		return;
+		t.Errorf("%s (level=%d): %v", fn, level, err)
+		return
 	}
-	piper, pipew := io.Pipe();
-	defer piper.Close();
+	piper, pipew := io.Pipe()
+	defer piper.Close()
 	go func() {
-		defer raw.Close();
-		defer pipew.Close();
-		zlibw, err := NewDeflaterLevel(pipew, level);
+		defer raw.Close()
+		defer pipew.Close()
+		zlibw, err := NewDeflaterLevel(pipew, level)
 		if err != nil {
-			t.Errorf("%s (level=%d): %v", fn, level, err);
-			return;
+			t.Errorf("%s (level=%d): %v", fn, level, err)
+			return
 		}
-		defer zlibw.Close();
-		var b [1024]byte;
+		defer zlibw.Close()
+		var b [1024]byte
 		for {
-			n, err0 := raw.Read(&b);
+			n, err0 := raw.Read(&b)
 			if err0 != nil && err0 != os.EOF {
-				t.Errorf("%s (level=%d): %v", fn, level, err0);
-				return;
+				t.Errorf("%s (level=%d): %v", fn, level, err0)
+				return
 			}
-			_, err1 := zlibw.Write(b[0:n]);
+			_, err1 := zlibw.Write(b[0:n])
 			if err1 == os.EPIPE {
 				// Fail, but do not report the error, as some other (presumably reportable) error broke the pipe.
 				return
 			}
 			if err1 != nil {
-				t.Errorf("%s (level=%d): %v", fn, level, err1);
-				return;
+				t.Errorf("%s (level=%d): %v", fn, level, err1)
+				return
 			}
 			if err0 == os.EOF {
 				break
 			}
 		}
-	}();
-	zlibr, err := NewInflater(piper);
+	}()
+	zlibr, err := NewInflater(piper)
 	if err != nil {
-		t.Errorf("%s (level=%d): %v", fn, level, err);
-		return;
+		t.Errorf("%s (level=%d): %v", fn, level, err)
+		return
 	}
-	defer zlibr.Close();
+	defer zlibr.Close()
 
 	// Compare the two.
-	b0, err0 := ioutil.ReadAll(golden);
-	b1, err1 := ioutil.ReadAll(zlibr);
+	b0, err0 := ioutil.ReadAll(golden)
+	b1, err1 := ioutil.ReadAll(zlibr)
 	if err0 != nil {
-		t.Errorf("%s (level=%d): %v", fn, level, err0);
-		return;
+		t.Errorf("%s (level=%d): %v", fn, level, err0)
+		return
 	}
 	if err1 != nil {
-		t.Errorf("%s (level=%d): %v", fn, level, err1);
-		return;
+		t.Errorf("%s (level=%d): %v", fn, level, err1)
+		return
 	}
 	if len(b0) != len(b1) {
-		t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1));
-		return;
+		t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1))
+		return
 	}
 	for i := 0; i < len(b0); i++ {
 		if b0[i] != b1[i] {
-			t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i]);
-			return;
+			t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i])
+			return
 		}
 	}
 }
 
 func TestWriter(t *testing.T) {
 	for _, fn := range filenames {
-		testFileLevel(t, fn, DefaultCompression);
-		testFileLevel(t, fn, NoCompression);
+		testFileLevel(t, fn, DefaultCompression)
+		testFileLevel(t, fn, NoCompression)
 		for level := BestSpeed; level <= BestCompression; level++ {
 			testFileLevel(t, fn, level)
 		}
diff --git a/src/pkg/container/heap/heap.go b/src/pkg/container/heap/heap.go
index 7a7cb9b80..4435a57c4 100644
--- a/src/pkg/container/heap/heap.go
+++ b/src/pkg/container/heap/heap.go
@@ -16,9 +16,9 @@ import "sort"
 //	!h.Less(j, i) for 0 <= i < h.Len() and j = 2*i+1 or 2*i+2 and j < h.Len()
 //
 type Interface interface {
-	sort.Interface;
-	Push(x interface{});
-	Pop() interface{};
+	sort.Interface
+	Push(x interface{})
+	Pop() interface{}
 }
 
 
@@ -29,7 +29,7 @@ type Interface interface {
 //
 func Init(h Interface) {
 	// heapify
-	n := h.Len();
+	n := h.Len()
 	for i := n/2 - 1; i >= 0; i-- {
 		down(h, i, n)
 	}
@@ -40,8 +40,8 @@ func Init(h Interface) {
 // O(log(n)) where n = h.Len().
 //
 func Push(h Interface, x interface{}) {
-	h.Push(x);
-	up(h, h.Len()-1);
+	h.Push(x)
+	up(h, h.Len()-1)
 }
 
 
@@ -50,10 +50,10 @@ func Push(h Interface, x interface{}) {
 // Same as Remove(h, 0).
 //
 func Pop(h Interface) interface{} {
-	n := h.Len() - 1;
-	h.Swap(0, n);
-	down(h, 0, n);
-	return h.Pop();
+	n := h.Len() - 1
+	h.Swap(0, n)
+	down(h, 0, n)
+	return h.Pop()
 }
 
 
@@ -61,42 +61,42 @@ func Pop(h Interface) interface{} {
 // The complexity is O(log(n)) where n = h.Len().
 //
 func Remove(h Interface, i int) interface{} {
-	n := h.Len() - 1;
+	n := h.Len() - 1
 	if n != i {
-		h.Swap(i, n);
-		down(h, i, n);
-		up(h, i);
+		h.Swap(i, n)
+		down(h, i, n)
+		up(h, i)
 	}
-	return h.Pop();
+	return h.Pop()
 }
 
 
 func up(h Interface, j int) {
 	for {
-		i := (j - 1) / 2;	// parent
+		i := (j - 1) / 2 // parent
 		if i == j || h.Less(i, j) {
 			break
 		}
-		h.Swap(i, j);
-		j = i;
+		h.Swap(i, j)
+		j = i
 	}
 }
 
 
 func down(h Interface, i, n int) {
 	for {
-		j1 := 2*i + 1;
+		j1 := 2*i + 1
 		if j1 >= n {
 			break
 		}
-		j := j1;	// left child
+		j := j1 // left child
 		if j2 := j1 + 1; j2 < n && !h.Less(j1, j2) {
-			j = j2	// = 2*i + 2  // right child
+			j = j2 // = 2*i + 2  // right child
 		}
 		if h.Less(i, j) {
 			break
 		}
-		h.Swap(i, j);
-		i = j;
+		h.Swap(i, j)
+		i = j
 	}
 }
diff --git a/src/pkg/container/heap/heap_test.go b/src/pkg/container/heap/heap_test.go
index dc13201cd..8130555f3 100644
--- a/src/pkg/container/heap/heap_test.go
+++ b/src/pkg/container/heap/heap_test.go
@@ -5,53 +5,53 @@
 package heap
 
 import (
-	"testing";
-	"container/vector";
+	"testing"
+	"container/vector"
 )
 
 
 type myHeap struct {
 	// A vector.Vector implements sort.Interface except for Less,
 	// and it implements Push and Pop as required for heap.Interface.
-	vector.Vector;
+	vector.Vector
 }
 
 
-func (h *myHeap) Less(i, j int) bool	{ return h.At(i).(int) < h.At(j).(int) }
+func (h *myHeap) Less(i, j int) bool { return h.At(i).(int) < h.At(j).(int) }
 
 
 func (h *myHeap) verify(t *testing.T, i int) {
-	n := h.Len();
-	j1 := 2*i + 1;
-	j2 := 2*i + 2;
+	n := h.Len()
+	j1 := 2*i + 1
+	j2 := 2*i + 2
 	if j1 < n {
 		if h.Less(j1, i) {
-			t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j1));
-			return;
+			t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j1))
+			return
 		}
-		h.verify(t, j1);
+		h.verify(t, j1)
 	}
 	if j2 < n {
 		if h.Less(j2, i) {
-			t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j2));
-			return;
+			t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j2))
+			return
 		}
-		h.verify(t, j2);
+		h.verify(t, j2)
 	}
 }
 
 
 func TestInit0(t *testing.T) {
-	h := new(myHeap);
+	h := new(myHeap)
 	for i := 20; i > 0; i-- {
-		h.Push(0)	// all elements are the same
+		h.Push(0) // all elements are the same
 	}
-	Init(h);
-	h.verify(t, 0);
+	Init(h)
+	h.verify(t, 0)
 
 	for i := 1; h.Len() > 0; i++ {
-		x := Pop(h).(int);
-		h.verify(t, 0);
+		x := Pop(h).(int)
+		h.verify(t, 0)
 		if x != 0 {
 			t.Errorf("%d.th pop got %d; want %d", i, x, 0)
 		}
@@ -60,16 +60,16 @@ func TestInit0(t *testing.T) {
 
 
 func TestInit1(t *testing.T) {
-	h := new(myHeap);
+	h := new(myHeap)
 	for i := 20; i > 0; i-- {
-		h.Push(i)	// all elements are different
+		h.Push(i) // all elements are different
 	}
-	Init(h);
-	h.verify(t, 0);
+	Init(h)
+	h.verify(t, 0)
 
 	for i := 1; h.Len() > 0; i++ {
-		x := Pop(h).(int);
-		h.verify(t, 0);
+		x := Pop(h).(int)
+		h.verify(t, 0)
 		if x != i {
 			t.Errorf("%d.th pop got %d; want %d", i, x, i)
 		}
@@ -78,26 +78,26 @@ func TestInit1(t *testing.T) {
 
 
 func Test(t *testing.T) {
-	h := new(myHeap);
-	h.verify(t, 0);
+	h := new(myHeap)
+	h.verify(t, 0)
 
 	for i := 20; i > 10; i-- {
 		h.Push(i)
 	}
-	Init(h);
-	h.verify(t, 0);
+	Init(h)
+	h.verify(t, 0)
 
 	for i := 10; i > 0; i-- {
-		Push(h, i);
-		h.verify(t, 0);
+		Push(h, i)
+		h.verify(t, 0)
 	}
 
 	for i := 1; h.Len() > 0; i++ {
-		x := Pop(h).(int);
+		x := Pop(h).(int)
 		if i < 20 {
 			Push(h, 20+i)
 		}
-		h.verify(t, 0);
+		h.verify(t, 0)
 		if x != i {
 			t.Errorf("%d.th pop got %d; want %d", i, x, i)
 		}
@@ -106,53 +106,53 @@ func Test(t *testing.T) {
 
 
 func TestRemove0(t *testing.T) {
-	h := new(myHeap);
+	h := new(myHeap)
 	for i := 0; i < 10; i++ {
 		h.Push(i)
 	}
-	h.verify(t, 0);
+	h.verify(t, 0)
 
 	for h.Len() > 0 {
-		i := h.Len() - 1;
-		x := Remove(h, i).(int);
+		i := h.Len() - 1
+		x := Remove(h, i).(int)
 		if x != i {
 			t.Errorf("Remove(%d) got %d; want %d", i, x, i)
 		}
-		h.verify(t, 0);
+		h.verify(t, 0)
 	}
 }
 
 
 func TestRemove1(t *testing.T) {
-	h := new(myHeap);
+	h := new(myHeap)
 	for i := 0; i < 10; i++ {
 		h.Push(i)
 	}
-	h.verify(t, 0);
+	h.verify(t, 0)
 
 	for i := 0; h.Len() > 0; i++ {
-		x := Remove(h, 0).(int);
+		x := Remove(h, 0).(int)
 		if x != i {
 			t.Errorf("Remove(0) got %d; want %d", x, i)
 		}
-		h.verify(t, 0);
+		h.verify(t, 0)
 	}
 }
 
 
 func TestRemove2(t *testing.T) {
-	N := 10;
+	N := 10
 
-	h := new(myHeap);
+	h := new(myHeap)
 	for i := 0; i < N; i++ {
 		h.Push(i)
 	}
-	h.verify(t, 0);
+	h.verify(t, 0)
 
-	m := make(map[int]int);
+	m := make(map[int]int)
 	for h.Len() > 0 {
-		m[Remove(h, (h.Len()-1)/2).(int)] = 1;
-		h.verify(t, 0);
+		m[Remove(h, (h.Len()-1)/2).(int)] = 1
+		h.verify(t, 0)
 	}
 
 	if len(m) != N {
diff --git a/src/pkg/container/list/list.go b/src/pkg/container/list/list.go
index b7b392cea..9429c90a7 100644
--- a/src/pkg/container/list/list.go
+++ b/src/pkg/container/list/list.go
@@ -9,45 +9,45 @@ package list
 type Element struct {
 	// Next and previous pointers in the doubly-linked list of elements.
 	// The front of the list has prev = nil, and the back has next = nil.
-	next, prev	*Element;
+	next, prev *Element
 
 	// A unique ID for the list to which this element belongs.
-	id	*byte;
+	id *byte
 
 	// The contents of this list element.
-	Value	interface{};
+	Value interface{}
 }
 
 // Next returns the next list element or nil.
-func (e *Element) Next() *Element	{ return e.next }
+func (e *Element) Next() *Element { return e.next }
 
 // Prev returns the previous list element or nil.
-func (e *Element) Prev() *Element	{ return e.prev }
+func (e *Element) Prev() *Element { return e.prev }
 
 // List represents a doubly linked list.
 type List struct {
-	front, back	*Element;
-	len		int;
-	id		*byte;
+	front, back *Element
+	len         int
+	id          *byte
 }
 
 // Init initializes or clears a List.
 func (l *List) Init() *List {
-	l.front = nil;
-	l.back = nil;
-	l.len = 0;
-	l.id = new(byte);
-	return l;
+	l.front = nil
+	l.back = nil
+	l.len = 0
+	l.id = new(byte)
+	return l
 }
 
 // New returns an initialized list.
-func New() *List	{ return new(List).Init() }
+func New() *List { return new(List).Init() }
 
 // Front returns the first element in the list.
-func (l *List) Front() *Element	{ return l.front }
+func (l *List) Front() *Element { return l.front }
 
 // Back returns the last element in the list.
-func (l *List) Back() *Element	{ return l.back }
+func (l *List) Back() *Element { return l.back }
 
 // Remove removes the element from the list.
 func (l *List) Remove(e *Element) {
@@ -65,9 +65,9 @@ func (l *List) Remove(e *Element) {
 		e.next.prev = e.prev
 	}
 
-	e.prev = nil;
-	e.next = nil;
-	l.len--;
+	e.prev = nil
+	e.next = nil
+	l.len--
 }
 
 func (l *List) insertBefore(e *Element, mark *Element) {
@@ -77,10 +77,10 @@ func (l *List) insertBefore(e *Element, mark *Element) {
 	} else {
 		mark.prev.next = e
 	}
-	e.prev = mark.prev;
-	mark.prev = e;
-	e.next = mark;
-	l.len++;
+	e.prev = mark.prev
+	mark.prev = e
+	e.next = mark
+	l.len++
 }
 
 func (l *List) insertAfter(e *Element, mark *Element) {
@@ -90,32 +90,32 @@ func (l *List) insertAfter(e *Element, mark *Element) {
 	} else {
 		mark.next.prev = e
 	}
-	e.next = mark.next;
-	mark.next = e;
-	e.prev = mark;
-	l.len++;
+	e.next = mark.next
+	mark.next = e
+	e.prev = mark
+	l.len++
 }
 
 func (l *List) insertFront(e *Element) {
 	if l.front == nil {
 		// empty list
-		l.front, l.back = e, e;
-		e.prev, e.next = nil, nil;
-		l.len = 1;
-		return;
+		l.front, l.back = e, e
+		e.prev, e.next = nil, nil
+		l.len = 1
+		return
 	}
-	l.insertBefore(e, l.front);
+	l.insertBefore(e, l.front)
 }
 
 func (l *List) insertBack(e *Element) {
 	if l.back == nil {
 		// empty list
-		l.front, l.back = e, e;
-		e.prev, e.next = nil, nil;
-		l.len = 1;
-		return;
+		l.front, l.back = e, e
+		e.prev, e.next = nil, nil
+		l.len = 1
+		return
 	}
-	l.insertAfter(e, l.back);
+	l.insertAfter(e, l.back)
 }
 
 // PushFront inserts the value at the front of the list and returns a new Element containing the value.
@@ -123,9 +123,9 @@ func (l *List) PushFront(value interface{}) *Element {
 	if l.id == nil {
 		l.Init()
 	}
-	e := &Element{nil, nil, l.id, value};
-	l.insertFront(e);
-	return e;
+	e := &Element{nil, nil, l.id, value}
+	l.insertFront(e)
+	return e
 }
 
 // PushBack inserts the value at the back of the list and returns a new Element containing the value.
@@ -133,9 +133,9 @@ func (l *List) PushBack(value interface{}) *Element {
 	if l.id == nil {
 		l.Init()
 	}
-	e := &Element{nil, nil, l.id, value};
-	l.insertBack(e);
-	return e;
+	e := &Element{nil, nil, l.id, value}
+	l.insertBack(e)
+	return e
 }
 
 // InsertBefore inserts the value immediately before mark and returns a new Element containing the value.
@@ -143,9 +143,9 @@ func (l *List) InsertBefore(value interface{}, mark *Element) *Element {
 	if mark.id != l.id {
 		return nil
 	}
-	e := &Element{nil, nil, l.id, value};
-	l.insertBefore(e, mark);
-	return e;
+	e := &Element{nil, nil, l.id, value}
+	l.insertBefore(e, mark)
+	return e
 }
 
 // InsertAfter inserts the value immediately after mark and returns a new Element containing the value.
@@ -153,9 +153,9 @@ func (l *List) InsertAfter(value interface{}, mark *Element) *Element {
 	if mark.id != l.id {
 		return nil
 	}
-	e := &Element{nil, nil, l.id, value};
-	l.insertAfter(e, mark);
-	return e;
+	e := &Element{nil, nil, l.id, value}
+	l.insertAfter(e, mark)
+	return e
 }
 
 // MoveToFront moves the element to the front of the list.
@@ -163,8 +163,8 @@ func (l *List) MoveToFront(e *Element) {
 	if e.id != l.id || l.front == e {
 		return
 	}
-	l.Remove(e);
-	l.insertFront(e);
+	l.Remove(e)
+	l.insertFront(e)
 }
 
 // MoveToBack moves the element to the back of the list.
@@ -172,22 +172,22 @@ func (l *List) MoveToBack(e *Element) {
 	if e.id != l.id || l.back == e {
 		return
 	}
-	l.Remove(e);
-	l.insertBack(e);
+	l.Remove(e)
+	l.insertBack(e)
 }
 
 // Len returns the number of elements in the list.
-func (l *List) Len() int	{ return l.len }
+func (l *List) Len() int { return l.len }
 
 func (l *List) iterate(c chan<- interface{}) {
 	for e := l.front; e != nil; e = e.next {
 		c <- e.Value
 	}
-	close(c);
+	close(c)
 }
 
 func (l *List) Iter() <-chan interface{} {
-	c := make(chan interface{});
-	go l.iterate(c);
-	return c;
+	c := make(chan interface{})
+	go l.iterate(c)
+	return c
 }
diff --git a/src/pkg/container/list/list_test.go b/src/pkg/container/list/list_test.go
index 52df37f56..846937a38 100644
--- a/src/pkg/container/list/list_test.go
+++ b/src/pkg/container/list/list_test.go
@@ -5,7 +5,7 @@
 package list
 
 import (
-	"testing";
+	"testing"
 )
 
 func checkListPointers(t *testing.T, l *List, es []*Element) {
@@ -13,7 +13,7 @@ func checkListPointers(t *testing.T, l *List, es []*Element) {
 		if l.front != nil || l.back != nil {
 			t.Errorf("l.front/l.back = %v/%v should be nil/nil", l.front, l.back)
 		}
-		return;
+		return
 	}
 
 	if l.front != es[0] {
@@ -24,8 +24,8 @@ func checkListPointers(t *testing.T, l *List, es []*Element) {
 	}
 
 	for i := 0; i < len(es); i++ {
-		e := es[i];
-		var e_prev, e_next *Element = nil, nil;
+		e := es[i]
+		var e_prev, e_next *Element = nil, nil
 		if i > 0 {
 			e_prev = es[i-1]
 		}
@@ -48,74 +48,74 @@ func checkListLen(t *testing.T, l *List, n int) {
 }
 
 func TestList(t *testing.T) {
-	l := New();
-	checkListPointers(t, l, []*Element{});
-	checkListLen(t, l, 0);
+	l := New()
+	checkListPointers(t, l, []*Element{})
+	checkListLen(t, l, 0)
 
 	// Single element list
-	e := l.PushFront("a");
-	checkListLen(t, l, 1);
-	checkListPointers(t, l, []*Element{e});
-	l.MoveToFront(e);
-	checkListPointers(t, l, []*Element{e});
-	l.MoveToBack(e);
-	checkListPointers(t, l, []*Element{e});
-	checkListLen(t, l, 1);
-	l.Remove(e);
-	checkListPointers(t, l, []*Element{});
-	checkListLen(t, l, 0);
+	e := l.PushFront("a")
+	checkListLen(t, l, 1)
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToFront(e)
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToBack(e)
+	checkListPointers(t, l, []*Element{e})
+	checkListLen(t, l, 1)
+	l.Remove(e)
+	checkListPointers(t, l, []*Element{})
+	checkListLen(t, l, 0)
 
 	// Bigger list
-	e2 := l.PushFront(2);
-	e1 := l.PushFront(1);
-	e3 := l.PushBack(3);
-	e4 := l.PushBack("banana");
-	checkListPointers(t, l, []*Element{e1, e2, e3, e4});
-	checkListLen(t, l, 4);
-
-	l.Remove(e2);
-	checkListPointers(t, l, []*Element{e1, e3, e4});
-	checkListLen(t, l, 3);
-
-	l.MoveToFront(e3);	// move from middle
-	checkListPointers(t, l, []*Element{e3, e1, e4});
-
-	l.MoveToFront(e1);
-	l.MoveToBack(e3);	// move from middle
-	checkListPointers(t, l, []*Element{e1, e4, e3});
-
-	l.MoveToFront(e3);	// move from back
-	checkListPointers(t, l, []*Element{e3, e1, e4});
-	l.MoveToFront(e3);	// should be no-op
-	checkListPointers(t, l, []*Element{e3, e1, e4});
-
-	l.MoveToBack(e3);	// move from front
-	checkListPointers(t, l, []*Element{e1, e4, e3});
-	l.MoveToBack(e3);	// should be no-op
-	checkListPointers(t, l, []*Element{e1, e4, e3});
-
-	e2 = l.InsertBefore(2, e1);	// insert before front
-	checkListPointers(t, l, []*Element{e2, e1, e4, e3});
-	l.Remove(e2);
-	e2 = l.InsertBefore(2, e4);	// insert before middle
-	checkListPointers(t, l, []*Element{e1, e2, e4, e3});
-	l.Remove(e2);
-	e2 = l.InsertBefore(2, e3);	// insert before back
-	checkListPointers(t, l, []*Element{e1, e4, e2, e3});
-	l.Remove(e2);
-
-	e2 = l.InsertAfter(2, e1);	// insert after front
-	checkListPointers(t, l, []*Element{e1, e2, e4, e3});
-	l.Remove(e2);
-	e2 = l.InsertAfter(2, e4);	// insert after middle
-	checkListPointers(t, l, []*Element{e1, e4, e2, e3});
-	l.Remove(e2);
-	e2 = l.InsertAfter(2, e3);	// insert after back
-	checkListPointers(t, l, []*Element{e1, e4, e3, e2});
-	l.Remove(e2);
+	e2 := l.PushFront(2)
+	e1 := l.PushFront(1)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack("banana")
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	checkListLen(t, l, 4)
+
+	l.Remove(e2)
+	checkListPointers(t, l, []*Element{e1, e3, e4})
+	checkListLen(t, l, 3)
+
+	l.MoveToFront(e3) // move from middle
+	checkListPointers(t, l, []*Element{e3, e1, e4})
+
+	l.MoveToFront(e1)
+	l.MoveToBack(e3) // move from middle
+	checkListPointers(t, l, []*Element{e1, e4, e3})
+
+	l.MoveToFront(e3) // move from back
+	checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e3, e1, e4})
+
+	l.MoveToBack(e3) // move from front
+	checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToBack(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e1, e4, e3})
+
+	e2 = l.InsertBefore(2, e1) // insert before front
+	checkListPointers(t, l, []*Element{e2, e1, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e4) // insert before middle
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e3) // insert before back
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
+
+	e2 = l.InsertAfter(2, e1) // insert after front
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e4) // insert after middle
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e3) // insert after back
+	checkListPointers(t, l, []*Element{e1, e4, e3, e2})
+	l.Remove(e2)
 
 	// Check standard iteration.
-	sum := 0;
+	sum := 0
 	for e := range l.Iter() {
 		if i, ok := e.(int); ok {
 			sum += i
@@ -126,11 +126,11 @@ func TestList(t *testing.T) {
 	}
 
 	// Clear all elements by iterating
-	var next *Element;
+	var next *Element
 	for e := l.Front(); e != nil; e = next {
-		next = e.Next();
-		l.Remove(e);
+		next = e.Next()
+		l.Remove(e)
 	}
-	checkListPointers(t, l, []*Element{});
-	checkListLen(t, l, 0);
+	checkListPointers(t, l, []*Element{})
+	checkListLen(t, l, 0)
 }
diff --git a/src/pkg/container/ring/ring.go b/src/pkg/container/ring/ring.go
index 5fcdfc366..335afbc3c 100644
--- a/src/pkg/container/ring/ring.go
+++ b/src/pkg/container/ring/ring.go
@@ -12,15 +12,15 @@ package ring
 // ring with a nil Value.
 //
 type Ring struct {
-	next, prev	*Ring;
-	Value		interface{};	// for use by client; untouched by this library
+	next, prev *Ring
+	Value      interface{} // for use by client; untouched by this library
 }
 
 
 func (r *Ring) init() *Ring {
-	r.next = r;
-	r.prev = r;
-	return r;
+	r.next = r
+	r.prev = r
+	return r
 }
 
 
@@ -29,7 +29,7 @@ func (r *Ring) Next() *Ring {
 	if r.next == nil {
 		return r.init()
 	}
-	return r.next;
+	return r.next
 }
 
 
@@ -38,7 +38,7 @@ func (r *Ring) Prev() *Ring {
 	if r.next == nil {
 		return r.init()
 	}
-	return r.prev;
+	return r.prev
 }
 
 
@@ -59,7 +59,7 @@ func (r *Ring) Move(n int) *Ring {
 			r = r.next
 		}
 	}
-	return r;
+	return r
 }
 
 
@@ -68,15 +68,15 @@ func New(n int) *Ring {
 	if n <= 0 {
 		return nil
 	}
-	r := new(Ring);
-	p := r;
+	r := new(Ring)
+	p := r
 	for i := 1; i < n; i++ {
-		p.next = &Ring{prev: p};
-		p = p.next;
+		p.next = &Ring{prev: p}
+		p = p.next
 	}
-	p.next = r;
-	r.prev = p;
-	return r;
+	p.next = r
+	r.prev = p
+	return r
 }
 
 
@@ -97,17 +97,17 @@ func New(n int) *Ring {
 // last element of s after insertion.
 //
 func (r *Ring) Link(s *Ring) *Ring {
-	n := r.Next();
+	n := r.Next()
 	if s != nil {
-		p := s.Prev();
+		p := s.Prev()
 		// Note: Cannot use multiple assignment because
 		// evaluation order of LHS is not specified.
-		r.next = s;
-		s.prev = r;
-		n.prev = p;
-		p.next = n;
+		r.next = s
+		s.prev = r
+		n.prev = p
+		p.next = n
 	}
-	return n;
+	return n
 }
 
 
@@ -119,7 +119,7 @@ func (r *Ring) Unlink(n int) *Ring {
 	if n <= 0 {
 		return nil
 	}
-	return r.Link(r.Move(n + 1));
+	return r.Link(r.Move(n + 1))
 }
 
 
@@ -127,27 +127,27 @@ func (r *Ring) Unlink(n int) *Ring {
 // It executes in time proportional to the number of elements.
 //
 func (r *Ring) Len() int {
-	n := 0;
+	n := 0
 	if r != nil {
-		n = 1;
+		n = 1
 		for p := r.Next(); p != r; p = p.next {
 			n++
 		}
 	}
-	return n;
+	return n
 }
 
 
 func (r *Ring) Iter() <-chan interface{} {
-	c := make(chan interface{});
+	c := make(chan interface{})
 	go func() {
 		if r != nil {
-			c <- r.Value;
+			c <- r.Value
 			for p := r.Next(); p != r; p = p.next {
 				c <- p.Value
 			}
 		}
-		close(c);
-	}();
-	return c;
+		close(c)
+	}()
+	return c
 }
diff --git a/src/pkg/container/ring/ring_test.go b/src/pkg/container/ring/ring_test.go
index b55f438fa..ee3c41128 100644
--- a/src/pkg/container/ring/ring_test.go
+++ b/src/pkg/container/ring/ring_test.go
@@ -5,38 +5,38 @@
 package ring
 
 import (
-	"fmt";
-	"testing";
+	"fmt"
+	"testing"
 )
 
 
 // For debugging - keep around.
 func dump(r *Ring) {
 	if r == nil {
-		fmt.Println("empty");
-		return;
+		fmt.Println("empty")
+		return
 	}
-	i, n := 0, r.Len();
+	i, n := 0, r.Len()
 	for p := r; i < n; p = p.next {
-		fmt.Printf("%4d: %p = {<- %p | %p ->}\n", i, p, p.prev, p.next);
-		i++;
+		fmt.Printf("%4d: %p = {<- %p | %p ->}\n", i, p, p.prev, p.next)
+		i++
 	}
-	fmt.Println();
+	fmt.Println()
 }
 
 
 func verify(t *testing.T, r *Ring, N int, sum int) {
 	// Len
-	n := r.Len();
+	n := r.Len()
 	if n != N {
 		t.Errorf("r.Len() == %d; expected %d", n, N)
 	}
 
 	// iteration
-	n = 0;
-	s := 0;
+	n = 0
+	s := 0
 	for p := range r.Iter() {
-		n++;
+		n++
 		if p != nil {
 			s += p.(int)
 		}
@@ -54,12 +54,12 @@ func verify(t *testing.T, r *Ring, N int, sum int) {
 
 	// connections
 	if r.next != nil {
-		var p *Ring;	// previous element
+		var p *Ring // previous element
 		for q := r; p == nil || q != r; q = q.next {
 			if p != nil && p != q.prev {
 				t.Errorf("prev = %p, expected q.prev = %p\n", p, q.prev)
 			}
-			p = q;
+			p = q
 		}
 		if p != r.prev {
 			t.Errorf("prev = %p, expected r.prev = %p\n", p, r.prev)
@@ -85,8 +85,8 @@ func verify(t *testing.T, r *Ring, N int, sum int) {
 		t.Errorf("r.Move(%d) != r", -N)
 	}
 	for i := 0; i < 10; i++ {
-		ni := N + i;
-		mi := ni % N;
+		ni := N + i
+		mi := ni % N
 		if r.Move(ni) != r.Move(mi) {
 			t.Errorf("r.Move(%d) != r.Move(%d)", ni, mi)
 		}
@@ -99,142 +99,142 @@ func verify(t *testing.T, r *Ring, N int, sum int) {
 
 func TestCornerCases(t *testing.T) {
 	var (
-		r0	*Ring;
-		r1	Ring;
+		r0 *Ring
+		r1 Ring
 	)
 	// Basics
-	verify(t, r0, 0, 0);
-	verify(t, &r1, 1, 0);
+	verify(t, r0, 0, 0)
+	verify(t, &r1, 1, 0)
 	// Insert
-	r1.Link(r0);
-	verify(t, r0, 0, 0);
-	verify(t, &r1, 1, 0);
+	r1.Link(r0)
+	verify(t, r0, 0, 0)
+	verify(t, &r1, 1, 0)
 	// Insert
-	r1.Link(r0);
-	verify(t, r0, 0, 0);
-	verify(t, &r1, 1, 0);
+	r1.Link(r0)
+	verify(t, r0, 0, 0)
+	verify(t, &r1, 1, 0)
 	// Unlink
-	r1.Unlink(0);
-	verify(t, &r1, 1, 0);
+	r1.Unlink(0)
+	verify(t, &r1, 1, 0)
 }
 
 
 func makeN(n int) *Ring {
-	r := New(n);
+	r := New(n)
 	for i := 1; i <= n; i++ {
-		r.Value = i;
-		r = r.Next();
+		r.Value = i
+		r = r.Next()
 	}
-	return r;
+	return r
 }
 
 
 func sum(r *Ring) int {
-	s := 0;
+	s := 0
 	for p := range r.Iter() {
 		s += p.(int)
 	}
-	return s;
+	return s
 }
 
 
-func sumN(n int) int	{ return (n*n + n) / 2 }
+func sumN(n int) int { return (n*n + n) / 2 }
 
 
 func TestNew(t *testing.T) {
 	for i := 0; i < 10; i++ {
-		r := New(i);
-		verify(t, r, i, -1);
+		r := New(i)
+		verify(t, r, i, -1)
 	}
 	for i := 0; i < 10; i++ {
-		r := makeN(i);
-		verify(t, r, i, sumN(i));
+		r := makeN(i)
+		verify(t, r, i, sumN(i))
 	}
 }
 
 
 func TestLink1(t *testing.T) {
-	r1a := makeN(1);
-	var r1b Ring;
-	r2a := r1a.Link(&r1b);
-	verify(t, r2a, 2, 1);
+	r1a := makeN(1)
+	var r1b Ring
+	r2a := r1a.Link(&r1b)
+	verify(t, r2a, 2, 1)
 	if r2a != r1a {
 		t.Errorf("a) 2-element link failed")
 	}
 
-	r2b := r2a.Link(r2a.Next());
-	verify(t, r2b, 2, 1);
+	r2b := r2a.Link(r2a.Next())
+	verify(t, r2b, 2, 1)
 	if r2b != r2a.Next() {
 		t.Errorf("b) 2-element link failed")
 	}
 
-	r1c := r2b.Link(r2b);
-	verify(t, r1c, 1, 1);
-	verify(t, r2b, 1, 0);
+	r1c := r2b.Link(r2b)
+	verify(t, r1c, 1, 1)
+	verify(t, r2b, 1, 0)
 }
 
 
 func TestLink2(t *testing.T) {
-	var r0 *Ring;
-	r1a := &Ring{Value: 42};
-	r1b := &Ring{Value: 77};
-	r10 := makeN(10);
+	var r0 *Ring
+	r1a := &Ring{Value: 42}
+	r1b := &Ring{Value: 77}
+	r10 := makeN(10)
 
-	r1a.Link(r0);
-	verify(t, r1a, 1, 42);
+	r1a.Link(r0)
+	verify(t, r1a, 1, 42)
 
-	r1a.Link(r1b);
-	verify(t, r1a, 2, 42+77);
+	r1a.Link(r1b)
+	verify(t, r1a, 2, 42+77)
 
-	r10.Link(r0);
-	verify(t, r10, 10, sumN(10));
+	r10.Link(r0)
+	verify(t, r10, 10, sumN(10))
 
-	r10.Link(r1a);
-	verify(t, r10, 12, sumN(10)+42+77);
+	r10.Link(r1a)
+	verify(t, r10, 12, sumN(10)+42+77)
 }
 
 
 func TestLink3(t *testing.T) {
-	var r Ring;
-	n := 1;
+	var r Ring
+	n := 1
 	for i := 1; i < 100; i++ {
-		n += i;
-		verify(t, r.Link(New(i)), n, -1);
+		n += i
+		verify(t, r.Link(New(i)), n, -1)
 	}
 }
 
 
 func TestUnlink(t *testing.T) {
-	r10 := makeN(10);
-	s10 := r10.Move(6);
+	r10 := makeN(10)
+	s10 := r10.Move(6)
 
-	sum10 := sumN(10);
+	sum10 := sumN(10)
 
-	verify(t, r10, 10, sum10);
-	verify(t, s10, 10, sum10);
+	verify(t, r10, 10, sum10)
+	verify(t, s10, 10, sum10)
 
-	r0 := r10.Unlink(0);
-	verify(t, r0, 0, 0);
+	r0 := r10.Unlink(0)
+	verify(t, r0, 0, 0)
 
-	r1 := r10.Unlink(1);
-	verify(t, r1, 1, 2);
-	verify(t, r10, 9, sum10-2);
+	r1 := r10.Unlink(1)
+	verify(t, r1, 1, 2)
+	verify(t, r10, 9, sum10-2)
 
-	r9 := r10.Unlink(9);
-	verify(t, r9, 9, sum10-2);
-	verify(t, r10, 9, sum10-2);
+	r9 := r10.Unlink(9)
+	verify(t, r9, 9, sum10-2)
+	verify(t, r10, 9, sum10-2)
 }
 
 
 func TestLinkUnlink(t *testing.T) {
 	for i := 1; i < 4; i++ {
-		ri := New(i);
+		ri := New(i)
 		for j := 0; j < i; j++ {
-			rj := ri.Unlink(j);
-			verify(t, rj, j, -1);
-			verify(t, ri, i-j, -1);
-			ri.Link(rj);
-			verify(t, ri, i, -1);
+			rj := ri.Unlink(j)
+			verify(t, rj, j, -1)
+			verify(t, ri, i-j, -1)
+			ri.Link(rj)
+			verify(t, ri, i, -1)
 		}
 	}
 }
diff --git a/src/pkg/container/vector/intvector.go b/src/pkg/container/vector/intvector.go
index 43f8ff808..1ec4b85a9 100644
--- a/src/pkg/container/vector/intvector.go
+++ b/src/pkg/container/vector/intvector.go
@@ -7,7 +7,7 @@ package vector
 
 // IntVector is a specialization of Vector that hides the wrapping of Elements around ints.
 type IntVector struct {
-	Vector;
+	Vector
 }
 
 
@@ -17,40 +17,40 @@ type IntVector struct {
 // Resize adds 0 elements. The capacity parameter is ignored unless the
 // new length or capacity is longer that the current capacity.
 func (p *IntVector) Resize(length, capacity int) *IntVector {
-	i := p.Len();
-	p.Vector.Resize(length, capacity);
+	i := p.Len()
+	p.Vector.Resize(length, capacity)
 	for a := p.a; i < len(a); i++ {
 		a[i] = 0
 	}
-	return p;
+	return p
 }
 
 
 // At returns the i'th element of the vector.
-func (p *IntVector) At(i int) int	{ return p.Vector.At(i).(int) }
+func (p *IntVector) At(i int) int { return p.Vector.At(i).(int) }
 
 
 // Set sets the i'th element of the vector to value x.
-func (p *IntVector) Set(i int, x int)	{ p.a[i] = x }
+func (p *IntVector) Set(i int, x int) { p.a[i] = x }
 
 
 // Last returns the element in the vector of highest index.
-func (p *IntVector) Last() int	{ return p.Vector.Last().(int) }
+func (p *IntVector) Last() int { return p.Vector.Last().(int) }
 
 
 // Data returns all the elements as a slice.
 func (p *IntVector) Data() []int {
-	arr := make([]int, p.Len());
+	arr := make([]int, p.Len())
 	for i, v := range p.a {
 		arr[i] = v.(int)
 	}
-	return arr;
+	return arr
 }
 
 
 // Insert inserts into the vector an element of value x before
 // the current element at index i.
-func (p *IntVector) Insert(i int, x int)	{ p.Vector.Insert(i, x) }
+func (p *IntVector) Insert(i int, x int) { p.Vector.Insert(i, x) }
 
 
 // InsertVector inserts into the vector the contents of the Vector
@@ -68,11 +68,11 @@ func (p *IntVector) Slice(i, j int) *IntVector {
 
 
 // Push appends x to the end of the vector.
-func (p *IntVector) Push(x int)	{ p.Vector.Push(x) }
+func (p *IntVector) Push(x int) { p.Vector.Push(x) }
 
 
 // Pop deletes and returns the last element of the vector.
-func (p *IntVector) Pop() int	{ return p.Vector.Pop().(int) }
+func (p *IntVector) Pop() int { return p.Vector.Pop().(int) }
 
 
 // AppendVector appends the entire IntVector x to the end of this vector.
@@ -83,7 +83,7 @@ func (p *IntVector) AppendVector(x *IntVector) {
 
 // sort.Interface support
 // Less returns a boolean denoting whether the i'th element is less than the j'th element.
-func (p *IntVector) Less(i, j int) bool	{ return p.At(i) < p.At(j) }
+func (p *IntVector) Less(i, j int) bool { return p.At(i) < p.At(j) }
 
 
 // Iterate over all elements; driver for range
@@ -91,13 +91,13 @@ func (p *IntVector) iterate(c chan<- int) {
 	for _, v := range p.a {
 		c <- v.(int)
 	}
-	close(c);
+	close(c)
 }
 
 
 // Channel iterator for range.
 func (p *IntVector) Iter() <-chan int {
-	c := make(chan int);
-	go p.iterate(c);
-	return c;
+	c := make(chan int)
+	go p.iterate(c)
+	return c
 }
diff --git a/src/pkg/container/vector/stringvector.go b/src/pkg/container/vector/stringvector.go
index 93a4197a5..821a7a101 100644
--- a/src/pkg/container/vector/stringvector.go
+++ b/src/pkg/container/vector/stringvector.go
@@ -6,7 +6,7 @@ package vector
 
 // StringVector is a specialization of Vector that hides the wrapping of Elements around strings.
 type StringVector struct {
-	Vector;
+	Vector
 }
 
 
@@ -16,34 +16,34 @@ type StringVector struct {
 // Resize adds "" elements. The capacity parameter is ignored unless the
 // new length or capacity is longer that the current capacity.
 func (p *StringVector) Resize(length, capacity int) *StringVector {
-	i := p.Len();
-	p.Vector.Resize(length, capacity);
+	i := p.Len()
+	p.Vector.Resize(length, capacity)
 	for a := p.a; i < len(a); i++ {
 		a[i] = ""
 	}
-	return p;
+	return p
 }
 
 
 // At returns the i'th element of the vector.
-func (p *StringVector) At(i int) string	{ return p.Vector.At(i).(string) }
+func (p *StringVector) At(i int) string { return p.Vector.At(i).(string) }
 
 
 // Set sets the i'th element of the vector to value x.
-func (p *StringVector) Set(i int, x string)	{ p.a[i] = x }
+func (p *StringVector) Set(i int, x string) { p.a[i] = x }
 
 
 // Last returns the element in the vector of highest index.
-func (p *StringVector) Last() string	{ return p.Vector.Last().(string) }
+func (p *StringVector) Last() string { return p.Vector.Last().(string) }
 
 
 // Data returns all the elements as a slice.
 func (p *StringVector) Data() []string {
-	arr := make([]string, p.Len());
+	arr := make([]string, p.Len())
 	for i, v := range p.a {
 		arr[i] = v.(string)
 	}
-	return arr;
+	return arr
 }
 
 
@@ -69,11 +69,11 @@ func (p *StringVector) Slice(i, j int) *StringVector {
 
 
 // Push appends x to the end of the vector.
-func (p *StringVector) Push(x string)	{ p.Vector.Push(x) }
+func (p *StringVector) Push(x string) { p.Vector.Push(x) }
 
 
 // Pop deletes and returns the last element of the vector.
-func (p *StringVector) Pop() string	{ return p.Vector.Pop().(string) }
+func (p *StringVector) Pop() string { return p.Vector.Pop().(string) }
 
 
 // AppendVector appends the entire StringVector x to the end of this vector.
@@ -84,7 +84,7 @@ func (p *StringVector) AppendVector(x *StringVector) {
 
 // sort.Interface support
 // Less returns a boolean denoting whether the i'th element is less than the j'th element.
-func (p *StringVector) Less(i, j int) bool	{ return p.At(i) < p.At(j) }
+func (p *StringVector) Less(i, j int) bool { return p.At(i) < p.At(j) }
 
 
 // Iterate over all elements; driver for range
@@ -92,13 +92,13 @@ func (p *StringVector) iterate(c chan<- string) {
 	for _, v := range p.a {
 		c <- v.(string)
 	}
-	close(c);
+	close(c)
 }
 
 
 // Channel iterator for range.
 func (p *StringVector) Iter() <-chan string {
-	c := make(chan string);
-	go p.iterate(c);
-	return c;
+	c := make(chan string)
+	go p.iterate(c)
+	return c
 }
diff --git a/src/pkg/container/vector/vector.go b/src/pkg/container/vector/vector.go
index 0408490be..ed1845b27 100644
--- a/src/pkg/container/vector/vector.go
+++ b/src/pkg/container/vector/vector.go
@@ -9,8 +9,8 @@ package vector
 // Vector is the container itself.
 // The zero value for Vector is an empty vector ready to use.
 type Vector struct {
-	a		[]interface{};
-	bootstrap	[8]interface{};
+	a         []interface{}
+	bootstrap [8]interface{}
 }
 
 
@@ -21,31 +21,31 @@ func (p *Vector) realloc(length, capacity int) (b []interface{}) {
 	} else {
 		b = make([]interface{}, length, capacity)
 	}
-	copy(b, p.a);
-	p.a = b;
-	return;
+	copy(b, p.a)
+	p.a = b
+	return
 }
 
 
 // Insert n elements at position i.
 func (p *Vector) expand(i, n int) {
-	a := p.a;
+	a := p.a
 
 	// make sure we have enough space
-	len0 := len(a);
-	len1 := len0 + n;
+	len0 := len(a)
+	len1 := len0 + n
 	if len1 <= cap(a) {
 		// enough space - just expand
 		a = a[0:len1]
 	} else {
 		// not enough space - double capacity
-		capb := cap(a) * 2;
+		capb := cap(a) * 2
 		if capb < len1 {
 			// still not enough - use required length
 			capb = len1
 		}
 		// capb >= len1
-		a = p.realloc(len1, capb);
+		a = p.realloc(len1, capb)
 	}
 
 	// make a hole
@@ -53,7 +53,7 @@ func (p *Vector) expand(i, n int) {
 		a[j+n] = a[j]
 	}
 
-	p.a = a;
+	p.a = a
 }
 
 
@@ -64,7 +64,7 @@ func (p *Vector) expand(i, n int) {
 // new length or capacity is longer that the current capacity. The resized
 // vector's capacity may be larger than the requested capacity.
 func (p *Vector) Resize(length, capacity int) *Vector {
-	a := p.a;
+	a := p.a
 
 	if length > cap(a) || capacity > cap(a) {
 		// not enough space or larger capacity requested explicitly
@@ -76,91 +76,91 @@ func (p *Vector) Resize(length, capacity int) *Vector {
 		}
 	}
 
-	p.a = a[0:length];
-	return p;
+	p.a = a[0:length]
+	return p
 }
 
 
 // Len returns the number of elements in the vector.
-func (p *Vector) Len() int	{ return len(p.a) }
+func (p *Vector) Len() int { return len(p.a) }
 
 
 // Cap returns the capacity of the vector; that is, the
 // maximum length the vector can grow without resizing.
-func (p *Vector) Cap() int	{ return cap(p.a) }
+func (p *Vector) Cap() int { return cap(p.a) }
 
 
 // At returns the i'th element of the vector.
-func (p *Vector) At(i int) interface{}	{ return p.a[i] }
+func (p *Vector) At(i int) interface{} { return p.a[i] }
 
 
 // Set sets the i'th element of the vector to value x.
-func (p *Vector) Set(i int, x interface{})	{ p.a[i] = x }
+func (p *Vector) Set(i int, x interface{}) { p.a[i] = x }
 
 
 // Last returns the element in the vector of highest index.
-func (p *Vector) Last() interface{}	{ return p.a[len(p.a)-1] }
+func (p *Vector) Last() interface{} { return p.a[len(p.a)-1] }
 
 
 // Data returns all the elements as a slice.
 func (p *Vector) Data() []interface{} {
-	arr := make([]interface{}, p.Len());
+	arr := make([]interface{}, p.Len())
 	for i, v := range p.a {
 		arr[i] = v
 	}
-	return arr;
+	return arr
 }
 
 
 // Insert inserts into the vector an element of value x before
 // the current element at index i.
 func (p *Vector) Insert(i int, x interface{}) {
-	p.expand(i, 1);
-	p.a[i] = x;
+	p.expand(i, 1)
+	p.a[i] = x
 }
 
 
 // Delete deletes the i'th element of the vector.  The gap is closed so the old
 // element at index i+1 has index i afterwards.
 func (p *Vector) Delete(i int) {
-	a := p.a;
-	n := len(a);
+	a := p.a
+	n := len(a)
 
-	copy(a[i:n-1], a[i+1:n]);
-	a[n-1] = nil;	// support GC, nil out entry
-	p.a = a[0 : n-1];
+	copy(a[i:n-1], a[i+1:n])
+	a[n-1] = nil // support GC, nil out entry
+	p.a = a[0 : n-1]
 }
 
 
 // InsertVector inserts into the vector the contents of the Vector
 // x such that the 0th element of x appears at index i after insertion.
 func (p *Vector) InsertVector(i int, x *Vector) {
-	p.expand(i, len(x.a));
-	copy(p.a[i:i+len(x.a)], x.a);
+	p.expand(i, len(x.a))
+	copy(p.a[i:i+len(x.a)], x.a)
 }
 
 
 // Cut deletes elements i through j-1, inclusive.
 func (p *Vector) Cut(i, j int) {
-	a := p.a;
-	n := len(a);
-	m := n - (j - i);
+	a := p.a
+	n := len(a)
+	m := n - (j - i)
 
-	copy(a[i:m], a[j:n]);
+	copy(a[i:m], a[j:n])
 	for k := m; k < n; k++ {
-		a[k] = nil	// support GC, nil out entries
+		a[k] = nil // support GC, nil out entries
 	}
 
-	p.a = a[0:m];
+	p.a = a[0:m]
 }
 
 
 // Slice returns a new Vector by slicing the old one to extract slice [i:j].
 // The elements are copied. The original vector is unchanged.
 func (p *Vector) Slice(i, j int) *Vector {
-	s := new(Vector).Resize(j-i, 0);	// will fail in Init() if j < i
-	copy(s.a, p.a[i:j]);
-	return s;
+	s := new(Vector).Resize(j-i, 0) // will fail in Init() if j < i
+	copy(s.a, p.a[i:j])
+	return s
 }
 
 
@@ -168,7 +168,7 @@ func (p *Vector) Slice(i, j int) *Vector {
 // The function should not change the indexing of the vector underfoot.
 func (p *Vector) Do(f func(elem interface{})) {
 	for i := 0; i < len(p.a); i++ {
-		f(p.a[i])	// not too safe if f changes the Vector
+		f(p.a[i]) // not too safe if f changes the Vector
 	}
 }
 
@@ -176,39 +176,39 @@ func (p *Vector) Do(f func(elem interface{})) {
 // Convenience wrappers
 
 // Push appends x to the end of the vector.
-func (p *Vector) Push(x interface{})	{ p.Insert(len(p.a), x) }
+func (p *Vector) Push(x interface{}) { p.Insert(len(p.a), x) }
 
 
 // Pop deletes the last element of the vector.
 func (p *Vector) Pop() interface{} {
-	i := len(p.a) - 1;
-	x := p.a[i];
-	p.a[i] = nil;	// support GC, nil out entry
-	p.a = p.a[0:i];
-	return x;
+	i := len(p.a) - 1
+	x := p.a[i]
+	p.a[i] = nil // support GC, nil out entry
+	p.a = p.a[0:i]
+	return x
 }
 
 
 // AppendVector appends the entire Vector x to the end of this vector.
-func (p *Vector) AppendVector(x *Vector)	{ p.InsertVector(len(p.a), x) }
+func (p *Vector) AppendVector(x *Vector) { p.InsertVector(len(p.a), x) }
 
 
 // Partial sort.Interface support
 
 // LessInterface provides partial support of the sort.Interface.
 type LessInterface interface {
-	Less(y interface{}) bool;
+	Less(y interface{}) bool
 }
 
 
 // Less returns a boolean denoting whether the i'th element is less than the j'th element.
-func (p *Vector) Less(i, j int) bool	{ return p.a[i].(LessInterface).Less(p.a[j]) }
+func (p *Vector) Less(i, j int) bool { return p.a[i].(LessInterface).Less(p.a[j]) }
 
 
 // Swap exchanges the elements at indexes i and j.
 func (p *Vector) Swap(i, j int) {
-	a := p.a;
-	a[i], a[j] = a[j], a[i];
+	a := p.a
+	a[i], a[j] = a[j], a[i]
 }
 
 
@@ -217,13 +217,13 @@ func (p *Vector) iterate(c chan<- interface{}) {
 	for _, v := range p.a {
 		c <- v
 	}
-	close(c);
+	close(c)
 }
 
 
 // Channel iterator for range.
 func (p *Vector) Iter() <-chan interface{} {
-	c := make(chan interface{});
-	go p.iterate(c);
-	return c;
+	c := make(chan interface{})
+	go p.iterate(c)
+	return c
 }
diff --git a/src/pkg/container/vector/vector_test.go b/src/pkg/container/vector/vector_test.go
index f187f7218..755ba7cad 100644
--- a/src/pkg/container/vector/vector_test.go
+++ b/src/pkg/container/vector/vector_test.go
@@ -10,7 +10,7 @@ import "fmt"
 
 
 func TestZeroLen(t *testing.T) {
-	a := new(Vector);
+	a := new(Vector)
 	if a.Len() != 0 {
 		t.Errorf("B) expected 0, got %d", a.Len())
 	}
@@ -18,8 +18,8 @@ func TestZeroLen(t *testing.T) {
 
 
 type VectorInterface interface {
-	Len() int;
-	Cap() int;
+	Len() int
+	Cap() int
 }
 
 
@@ -34,27 +34,27 @@ func checkSize(t *testing.T, v VectorInterface, len, cap int) {
 
 
 func TestResize(t *testing.T) {
-	var a Vector;
-	checkSize(t, &a, 0, 0);
-	checkSize(t, a.Resize(0, 5), 0, 5);
-	checkSize(t, a.Resize(1, 0), 1, 5);
-	checkSize(t, a.Resize(10, 0), 10, 10);
-	checkSize(t, a.Resize(5, 0), 5, 10);
-	checkSize(t, a.Resize(3, 8), 3, 10);
-	checkSize(t, a.Resize(0, 100), 0, 100);
-	checkSize(t, a.Resize(11, 100), 11, 100);
+	var a Vector
+	checkSize(t, &a, 0, 0)
+	checkSize(t, a.Resize(0, 5), 0, 5)
+	checkSize(t, a.Resize(1, 0), 1, 5)
+	checkSize(t, a.Resize(10, 0), 10, 10)
+	checkSize(t, a.Resize(5, 0), 5, 10)
+	checkSize(t, a.Resize(3, 8), 3, 10)
+	checkSize(t, a.Resize(0, 100), 0, 100)
+	checkSize(t, a.Resize(11, 100), 11, 100)
 }
 
 
 func TestIntResize(t *testing.T) {
-	var a IntVector;
-	checkSize(t, &a, 0, 0);
-	a.Push(1);
-	a.Push(2);
-	a.Push(3);
-	a.Push(4);
-	checkSize(t, &a, 4, 4);
-	checkSize(t, a.Resize(10, 0), 10, 10);
+	var a IntVector
+	checkSize(t, &a, 0, 0)
+	a.Push(1)
+	a.Push(2)
+	a.Push(3)
+	a.Push(4)
+	checkSize(t, &a, 4, 4)
+	checkSize(t, a.Resize(10, 0), 10, 10)
 	for i := 4; i < a.Len(); i++ {
 		if a.At(i) != 0 {
 			t.Errorf("expected a.At(%d) == 0; found %d", i, a.At(i))
@@ -64,14 +64,14 @@ func TestIntResize(t *testing.T) {
 
 
 func TestStringResize(t *testing.T) {
-	var a StringVector;
-	checkSize(t, &a, 0, 0);
-	a.Push("1");
-	a.Push("2");
-	a.Push("3");
-	a.Push("4");
-	checkSize(t, &a, 4, 4);
-	checkSize(t, a.Resize(10, 0), 10, 10);
+	var a StringVector
+	checkSize(t, &a, 0, 0)
+	a.Push("1")
+	a.Push("2")
+	a.Push("3")
+	a.Push("4")
+	checkSize(t, &a, 4, 4)
+	checkSize(t, a.Resize(10, 0), 10, 10)
 	for i := 4; i < a.Len(); i++ {
 		if a.At(i) != "" {
 			t.Errorf("expected a.At(%d) == "+"; found %s", i, a.At(i))
@@ -95,25 +95,25 @@ func checkNil(t *testing.T, a *Vector, i int) {
 
 
 func TestTrailingElements(t *testing.T) {
-	var a Vector;
+	var a Vector
 	for i := 0; i < 10; i++ {
 		a.Push(i)
 	}
-	checkNil(t, &a, 10);
-	checkSize(t, &a, 10, 16);
-	checkSize(t, a.Resize(5, 0), 5, 16);
-	checkSize(t, a.Resize(10, 0), 10, 16);
-	checkNil(t, &a, 5);
+	checkNil(t, &a, 10)
+	checkSize(t, &a, 10, 16)
+	checkSize(t, a.Resize(5, 0), 5, 16)
+	checkSize(t, a.Resize(10, 0), 10, 16)
+	checkNil(t, &a, 5)
 }
 
 
-func val(i int) int	{ return i*991 - 1234 }
+func val(i int) int { return i*991 - 1234 }
 
 
 func TestAccess(t *testing.T) {
-	const n = 100;
-	var a Vector;
-	a.Resize(n, 0);
+	const n = 100
+	var a Vector
+	a.Resize(n, 0)
 	for i := 0; i < n; i++ {
 		a.Set(i, val(i))
 	}
@@ -126,14 +126,14 @@ func TestAccess(t *testing.T) {
 
 
 func TestInsertDeleteClear(t *testing.T) {
-	const n = 100;
-	var a Vector;
+	const n = 100
+	var a Vector
 
 	for i := 0; i < n; i++ {
 		if a.Len() != i {
 			t.Errorf("A) wrong len %d (expected %d)", a.Len(), i)
 		}
-		a.Insert(0, val(i));
+		a.Insert(0, val(i))
 		if a.Last().(int) != val(0) {
 			t.Error("B")
 		}
@@ -145,7 +145,7 @@ func TestInsertDeleteClear(t *testing.T) {
 		if a.At(0).(int) != val(i) {
 			t.Error("D")
 		}
-		a.Delete(0);
+		a.Delete(0)
 		if a.Len() != i {
 			t.Errorf("E) wrong len %d (expected %d)", a.Len(), i)
 		}
@@ -155,7 +155,7 @@ func TestInsertDeleteClear(t *testing.T) {
 		t.Errorf("F) wrong len %d (expected 0)", a.Len())
 	}
 	for i := 0; i < n; i++ {
-		a.Push(val(i));
+		a.Push(val(i))
 		if a.Len() != i+1 {
 			t.Errorf("G) wrong len %d (expected %d)", a.Len(), i+1)
 		}
@@ -163,17 +163,17 @@ func TestInsertDeleteClear(t *testing.T) {
 			t.Error("H")
 		}
 	}
-	a.Resize(0, 0);
+	a.Resize(0, 0)
 	if a.Len() != 0 {
 		t.Errorf("I wrong len %d (expected 0)", a.Len())
 	}
 
-	const m = 5;
+	const m = 5
 	for j := 0; j < m; j++ {
-		a.Push(j);
+		a.Push(j)
 		for i := 0; i < n; i++ {
-			x := val(i);
-			a.Push(x);
+			x := val(i)
+			a.Push(x)
 			if a.Pop().(int) != x {
 				t.Error("J")
 			}
@@ -195,7 +195,7 @@ func verify_slice(t *testing.T, x *Vector, elt, i, j int) {
 		}
 	}
 
-	s := x.Slice(i, j);
+	s := x.Slice(i, j)
 	for k, n := 0, j-i; k < n; k++ {
 		if s.At(k).(int) != elt {
 			t.Errorf("N) wrong [%d] element %d (expected %d)", k, x.At(k).(int), elt)
@@ -205,54 +205,54 @@ func verify_slice(t *testing.T, x *Vector, elt, i, j int) {
 
 
 func verify_pattern(t *testing.T, x *Vector, a, b, c int) {
-	n := a + b + c;
+	n := a + b + c
 	if x.Len() != n {
 		t.Errorf("O) wrong len %d (expected %d)", x.Len(), n)
 	}
-	verify_slice(t, x, 0, 0, a);
-	verify_slice(t, x, 1, a, a+b);
-	verify_slice(t, x, 0, a+b, n);
+	verify_slice(t, x, 0, 0, a)
+	verify_slice(t, x, 1, a, a+b)
+	verify_slice(t, x, 0, a+b, n)
 }
 
 
 func make_vector(elt, len int) *Vector {
-	x := new(Vector).Resize(len, 0);
+	x := new(Vector).Resize(len, 0)
 	for i := 0; i < len; i++ {
 		x.Set(i, elt)
 	}
-	return x;
+	return x
 }
 
 
 func TestInsertVector(t *testing.T) {
 	// 1
-	a := make_vector(0, 0);
-	b := make_vector(1, 10);
-	a.InsertVector(0, b);
-	verify_pattern(t, a, 0, 10, 0);
+	a := make_vector(0, 0)
+	b := make_vector(1, 10)
+	a.InsertVector(0, b)
+	verify_pattern(t, a, 0, 10, 0)
 	// 2
-	a = make_vector(0, 10);
-	b = make_vector(1, 0);
-	a.InsertVector(5, b);
-	verify_pattern(t, a, 5, 0, 5);
+	a = make_vector(0, 10)
+	b = make_vector(1, 0)
+	a.InsertVector(5, b)
+	verify_pattern(t, a, 5, 0, 5)
 	// 3
-	a = make_vector(0, 10);
-	b = make_vector(1, 3);
-	a.InsertVector(3, b);
-	verify_pattern(t, a, 3, 3, 7);
+	a = make_vector(0, 10)
+	b = make_vector(1, 3)
+	a.InsertVector(3, b)
+	verify_pattern(t, a, 3, 3, 7)
 	// 4
-	a = make_vector(0, 10);
-	b = make_vector(1, 1000);
-	a.InsertVector(8, b);
-	verify_pattern(t, a, 8, 1000, 2);
+	a = make_vector(0, 10)
+	b = make_vector(1, 1000)
+	a.InsertVector(8, b)
+	verify_pattern(t, a, 8, 1000, 2)
 }
 
 
 // This also tests IntVector and StringVector
 func TestSorting(t *testing.T) {
-	const n = 100;
+	const n = 100
 
-	a := new(IntVector).Resize(n, 0);
+	a := new(IntVector).Resize(n, 0)
 	for i := n - 1; i >= 0; i-- {
 		a.Set(i, n-1-i)
 	}
@@ -260,7 +260,7 @@ func TestSorting(t *testing.T) {
 		t.Error("int vector not sorted")
 	}
 
-	b := new(StringVector).Resize(n, 0);
+	b := new(StringVector).Resize(n, 0)
 	for i := n - 1; i >= 0; i-- {
 		b.Set(i, fmt.Sprint(n-1-i))
 	}
@@ -271,20 +271,20 @@ func TestSorting(t *testing.T) {
 
 
 func TestDo(t *testing.T) {
-	const n = 25;
-	const salt = 17;
-	a := new(IntVector).Resize(n, 0);
+	const n = 25
+	const salt = 17
+	a := new(IntVector).Resize(n, 0)
 	for i := 0; i < n; i++ {
 		a.Set(i, salt*i)
 	}
-	count := 0;
+	count := 0
 	a.Do(func(e interface{}) {
-		i := e.(int);
+		i := e.(int)
 		if i != count*salt {
 			t.Error("value at", count, "should be", count*salt, "not", i)
 		}
-		count++;
-	});
+		count++
+	})
 	if count != n {
 		t.Error("should visit", n, "values; did visit", count)
 	}
@@ -292,17 +292,17 @@ func TestDo(t *testing.T) {
 
 
 func TestIter(t *testing.T) {
-	const Len = 100;
-	x := new(Vector).Resize(Len, 0);
+	const Len = 100
+	x := new(Vector).Resize(Len, 0)
 	for i := 0; i < Len; i++ {
 		x.Set(i, i*i)
 	}
-	i := 0;
+	i := 0
 	for v := range x.Iter() {
 		if v.(int) != i*i {
 			t.Error("Iter expected", i*i, "got", v.(int))
 		}
-		i++;
+		i++
 	}
 	if i != Len {
 		t.Error("Iter stopped at", i, "not", Len)
diff --git a/src/pkg/crypto/aes/aes_test.go b/src/pkg/crypto/aes/aes_test.go
index 39933a824..1629a33ed 100644
--- a/src/pkg/crypto/aes/aes_test.go
+++ b/src/pkg/crypto/aes/aes_test.go
@@ -5,7 +5,7 @@
 package aes
 
 import (
-	"testing";
+	"testing"
 )
 
 // See const.go for overview of math here.
@@ -13,12 +13,12 @@ import (
 // Test that powx is initialized correctly.
 // (Can adapt this code to generate it too.)
 func TestPowx(t *testing.T) {
-	p := 1;
+	p := 1
 	for i := 0; i < len(powx); i++ {
 		if powx[i] != byte(p) {
 			t.Errorf("powx[%d] = %#x, want %#x", i, powx[i], p)
 		}
-		p <<= 1;
+		p <<= 1
 		if p&0x100 != 0 {
 			p ^= poly
 		}
@@ -27,25 +27,25 @@ func TestPowx(t *testing.T) {
 
 // Multiply b and c as GF(2) polynomials modulo poly
 func mul(b, c uint32) uint32 {
-	i := b;
-	j := c;
-	s := uint32(0);
+	i := b
+	j := c
+	s := uint32(0)
 	for k := uint32(1); k < 0x100 && j != 0; k <<= 1 {
 		// Invariant: k == 1<<n, i == b * xⁿ
 
 		if j&k != 0 {
 			// s += i in GF(2); xor in binary
-			s ^= i;
-			j ^= k;	// turn off bit to end loop early
+			s ^= i
+			j ^= k // turn off bit to end loop early
 		}
 
 		// i *= x in GF(2) modulo the polynomial
-		i <<= 1;
+		i <<= 1
 		if i&0x100 != 0 {
 			i ^= poly
 		}
 	}
-	return s;
+	return s
 }
 
 // Test all mul inputs against bit-by-bit n² algorithm.
@@ -53,7 +53,7 @@ func TestMul(t *testing.T) {
 	for i := uint32(0); i < 256; i++ {
 		for j := uint32(0); j < 256; j++ {
 			// Multiply i, j bit by bit.
-			s := uint8(0);
+			s := uint8(0)
 			for k := uint(0); k < 8; k++ {
 				for l := uint(0); l < 8; l++ {
 					if i&(1<<k) != 0 && j&(1<<l) != 0 {
@@ -87,15 +87,15 @@ func TestSboxes(t *testing.T) {
 // (Can adapt this code to generate them too.)
 func TestTe(t *testing.T) {
 	for i := 0; i < 256; i++ {
-		s := uint32(sbox0[i]);
-		s2 := mul(s, 2);
-		s3 := mul(s, 3);
-		w := s2<<24 | s<<16 | s<<8 | s3;
+		s := uint32(sbox0[i])
+		s2 := mul(s, 2)
+		s3 := mul(s, 3)
+		w := s2<<24 | s<<16 | s<<8 | s3
 		for j := 0; j < 4; j++ {
 			if x := te[j][i]; x != w {
 				t.Fatalf("te[%d][%d] = %#x, want %#x", j, i, x, w)
 			}
-			w = w<<24 | w>>8;
+			w = w<<24 | w>>8
 		}
 	}
 }
@@ -104,17 +104,17 @@ func TestTe(t *testing.T) {
 // (Can adapt this code to generate them too.)
 func TestTd(t *testing.T) {
 	for i := 0; i < 256; i++ {
-		s := uint32(sbox1[i]);
-		s9 := mul(s, 0x9);
-		sb := mul(s, 0xb);
-		sd := mul(s, 0xd);
-		se := mul(s, 0xe);
-		w := se<<24 | s9<<16 | sd<<8 | sb;
+		s := uint32(sbox1[i])
+		s9 := mul(s, 0x9)
+		sb := mul(s, 0xb)
+		sd := mul(s, 0xd)
+		se := mul(s, 0xe)
+		w := se<<24 | s9<<16 | sd<<8 | sb
 		for j := 0; j < 4; j++ {
 			if x := td[j][i]; x != w {
 				t.Fatalf("td[%d][%d] = %#x, want %#x", j, i, x, w)
 			}
-			w = w<<24 | w>>8;
+			w = w<<24 | w>>8
 		}
 	}
 }
@@ -124,9 +124,9 @@ func TestTd(t *testing.T) {
 
 // Appendix A of FIPS 197: Key expansion examples
 type KeyTest struct {
-	key	[]byte;
-	enc	[]uint32;
-	dec	[]uint32;	// decryption expansion; not in FIPS 197, computed from C implementation.
+	key []byte
+	enc []uint32
+	dec []uint32 // decryption expansion; not in FIPS 197, computed from C implementation.
 }
 
 var keyTests = []KeyTest{
@@ -214,23 +214,23 @@ var keyTests = []KeyTest{
 func TestExpandKey(t *testing.T) {
 L:
 	for i, tt := range keyTests {
-		enc := make([]uint32, len(tt.enc));
-		var dec []uint32;
+		enc := make([]uint32, len(tt.enc))
+		var dec []uint32
 		if tt.dec != nil {
 			dec = make([]uint32, len(tt.dec))
 		}
-		expandKey(tt.key, enc, dec);
+		expandKey(tt.key, enc, dec)
 		for j, v := range enc {
 			if v != tt.enc[j] {
-				t.Errorf("key %d: enc[%d] = %#x, want %#x", i, j, v, tt.enc[j]);
-				continue L;
+				t.Errorf("key %d: enc[%d] = %#x, want %#x", i, j, v, tt.enc[j])
+				continue L
 			}
 		}
 		if dec != nil {
 			for j, v := range dec {
 				if v != tt.dec[j] {
-					t.Errorf("key %d: dec[%d] = %#x, want %#x", i, j, v, tt.dec[j]);
-					continue L;
+					t.Errorf("key %d: dec[%d] = %#x, want %#x", i, j, v, tt.dec[j])
+					continue L
 				}
 			}
 		}
@@ -239,9 +239,9 @@ L:
 
 // Appendix B, C of FIPS 197: Cipher examples, Example vectors.
 type CryptTest struct {
-	key	[]byte;
-	in	[]byte;
-	out	[]byte;
+	key []byte
+	in  []byte
+	out []byte
 }
 
 var encryptTests = []CryptTest{
@@ -278,16 +278,16 @@ var encryptTests = []CryptTest{
 // Test encryptBlock against FIPS 197 examples.
 func TestEncryptBlock(t *testing.T) {
 	for i, tt := range encryptTests {
-		n := len(tt.key) + 28;
-		enc := make([]uint32, n);
-		dec := make([]uint32, n);
-		expandKey(tt.key, enc, dec);
-		out := make([]byte, len(tt.in));
-		encryptBlock(enc, tt.in, out);
+		n := len(tt.key) + 28
+		enc := make([]uint32, n)
+		dec := make([]uint32, n)
+		expandKey(tt.key, enc, dec)
+		out := make([]byte, len(tt.in))
+		encryptBlock(enc, tt.in, out)
 		for j, v := range out {
 			if v != tt.out[j] {
-				t.Errorf("encryptBlock %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]);
-				break;
+				t.Errorf("encryptBlock %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j])
+				break
 			}
 		}
 	}
@@ -296,16 +296,16 @@ func TestEncryptBlock(t *testing.T) {
 // Test decryptBlock against FIPS 197 examples.
 func TestDecryptBlock(t *testing.T) {
 	for i, tt := range encryptTests {
-		n := len(tt.key) + 28;
-		enc := make([]uint32, n);
-		dec := make([]uint32, n);
-		expandKey(tt.key, enc, dec);
-		plain := make([]byte, len(tt.in));
-		decryptBlock(dec, tt.out, plain);
+		n := len(tt.key) + 28
+		enc := make([]uint32, n)
+		dec := make([]uint32, n)
+		expandKey(tt.key, enc, dec)
+		plain := make([]byte, len(tt.in))
+		decryptBlock(dec, tt.out, plain)
 		for j, v := range plain {
 			if v != tt.in[j] {
-				t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]);
-				break;
+				t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j])
+				break
 			}
 		}
 	}
@@ -314,17 +314,17 @@ func TestDecryptBlock(t *testing.T) {
 // Test Cipher Encrypt method against FIPS 197 examples.
 func TestCipherEncrypt(t *testing.T) {
 	for i, tt := range encryptTests {
-		c, err := NewCipher(tt.key);
+		c, err := NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err);
-			continue;
+			t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err)
+			continue
 		}
-		out := make([]byte, len(tt.in));
-		c.Encrypt(tt.in, out);
+		out := make([]byte, len(tt.in))
+		c.Encrypt(tt.in, out)
 		for j, v := range out {
 			if v != tt.out[j] {
-				t.Errorf("Cipher.Encrypt %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]);
-				break;
+				t.Errorf("Cipher.Encrypt %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j])
+				break
 			}
 		}
 	}
@@ -333,17 +333,17 @@ func TestCipherEncrypt(t *testing.T) {
 // Test Cipher Decrypt against FIPS 197 examples.
 func TestCipherDecrypt(t *testing.T) {
 	for i, tt := range encryptTests {
-		c, err := NewCipher(tt.key);
+		c, err := NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err);
-			continue;
+			t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err)
+			continue
 		}
-		plain := make([]byte, len(tt.in));
-		c.Decrypt(tt.out, plain);
+		plain := make([]byte, len(tt.in))
+		c.Decrypt(tt.out, plain)
 		for j, v := range plain {
 			if v != tt.in[j] {
-				t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]);
-				break;
+				t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j])
+				break
 			}
 		}
 	}
diff --git a/src/pkg/crypto/aes/block.go b/src/pkg/crypto/aes/block.go
index dbd448f8b..a502554bd 100644
--- a/src/pkg/crypto/aes/block.go
+++ b/src/pkg/crypto/aes/block.go
@@ -38,92 +38,92 @@ package aes
 
 // Encrypt one block from src into dst, using the expanded key xk.
 func encryptBlock(xk []uint32, src, dst []byte) {
-	var s0, s1, s2, s3, t0, t1, t2, t3 uint32;
+	var s0, s1, s2, s3, t0, t1, t2, t3 uint32
 
-	s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]);
-	s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]);
-	s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]);
-	s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]);
+	s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+	s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7])
+	s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11])
+	s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15])
 
 	// First round just XORs input with key.
-	s0 ^= xk[0];
-	s1 ^= xk[1];
-	s2 ^= xk[2];
-	s3 ^= xk[3];
+	s0 ^= xk[0]
+	s1 ^= xk[1]
+	s2 ^= xk[2]
+	s3 ^= xk[3]
 
 	// Middle rounds shuffle using tables.
 	// Number of rounds is set by length of expanded key.
-	nr := len(xk)/4 - 2;	// - 2: one above, one more below
-	k := 4;
+	nr := len(xk)/4 - 2 // - 2: one above, one more below
+	k := 4
 	for r := 0; r < nr; r++ {
-		t0 = xk[k+0] ^ te[0][s0>>24] ^ te[1][s1>>16&0xff] ^ te[2][s2>>8&0xff] ^ te[3][s3&0xff];
-		t1 = xk[k+1] ^ te[0][s1>>24] ^ te[1][s2>>16&0xff] ^ te[2][s3>>8&0xff] ^ te[3][s0&0xff];
-		t2 = xk[k+2] ^ te[0][s2>>24] ^ te[1][s3>>16&0xff] ^ te[2][s0>>8&0xff] ^ te[3][s1&0xff];
-		t3 = xk[k+3] ^ te[0][s3>>24] ^ te[1][s0>>16&0xff] ^ te[2][s1>>8&0xff] ^ te[3][s2&0xff];
-		k += 4;
-		s0, s1, s2, s3 = t0, t1, t2, t3;
+		t0 = xk[k+0] ^ te[0][s0>>24] ^ te[1][s1>>16&0xff] ^ te[2][s2>>8&0xff] ^ te[3][s3&0xff]
+		t1 = xk[k+1] ^ te[0][s1>>24] ^ te[1][s2>>16&0xff] ^ te[2][s3>>8&0xff] ^ te[3][s0&0xff]
+		t2 = xk[k+2] ^ te[0][s2>>24] ^ te[1][s3>>16&0xff] ^ te[2][s0>>8&0xff] ^ te[3][s1&0xff]
+		t3 = xk[k+3] ^ te[0][s3>>24] ^ te[1][s0>>16&0xff] ^ te[2][s1>>8&0xff] ^ te[3][s2&0xff]
+		k += 4
+		s0, s1, s2, s3 = t0, t1, t2, t3
 	}
 
 	// Last round uses s-box directly and XORs to produce output.
-	s0 = uint32(sbox0[t0>>24])<<24 | uint32(sbox0[t1>>16&0xff])<<16 | uint32(sbox0[t2>>8&0xff])<<8 | uint32(sbox0[t3&0xff]);
-	s1 = uint32(sbox0[t1>>24])<<24 | uint32(sbox0[t2>>16&0xff])<<16 | uint32(sbox0[t3>>8&0xff])<<8 | uint32(sbox0[t0&0xff]);
-	s2 = uint32(sbox0[t2>>24])<<24 | uint32(sbox0[t3>>16&0xff])<<16 | uint32(sbox0[t0>>8&0xff])<<8 | uint32(sbox0[t1&0xff]);
-	s3 = uint32(sbox0[t3>>24])<<24 | uint32(sbox0[t0>>16&0xff])<<16 | uint32(sbox0[t1>>8&0xff])<<8 | uint32(sbox0[t2&0xff]);
-
-	s0 ^= xk[k+0];
-	s1 ^= xk[k+1];
-	s2 ^= xk[k+2];
-	s3 ^= xk[k+3];
-
-	dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0);
-	dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1);
-	dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2);
-	dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3);
+	s0 = uint32(sbox0[t0>>24])<<24 | uint32(sbox0[t1>>16&0xff])<<16 | uint32(sbox0[t2>>8&0xff])<<8 | uint32(sbox0[t3&0xff])
+	s1 = uint32(sbox0[t1>>24])<<24 | uint32(sbox0[t2>>16&0xff])<<16 | uint32(sbox0[t3>>8&0xff])<<8 | uint32(sbox0[t0&0xff])
+	s2 = uint32(sbox0[t2>>24])<<24 | uint32(sbox0[t3>>16&0xff])<<16 | uint32(sbox0[t0>>8&0xff])<<8 | uint32(sbox0[t1&0xff])
+	s3 = uint32(sbox0[t3>>24])<<24 | uint32(sbox0[t0>>16&0xff])<<16 | uint32(sbox0[t1>>8&0xff])<<8 | uint32(sbox0[t2&0xff])
+
+	s0 ^= xk[k+0]
+	s1 ^= xk[k+1]
+	s2 ^= xk[k+2]
+	s3 ^= xk[k+3]
+
+	dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0)
+	dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1)
+	dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2)
+	dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3)
 }
 
 // Decrypt one block from src into dst, using the expanded key xk.
 func decryptBlock(xk []uint32, src, dst []byte) {
-	var s0, s1, s2, s3, t0, t1, t2, t3 uint32;
+	var s0, s1, s2, s3, t0, t1, t2, t3 uint32
 
-	s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]);
-	s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]);
-	s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]);
-	s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]);
+	s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+	s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7])
+	s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11])
+	s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15])
 
 	// First round just XORs input with key.
-	s0 ^= xk[0];
-	s1 ^= xk[1];
-	s2 ^= xk[2];
-	s3 ^= xk[3];
+	s0 ^= xk[0]
+	s1 ^= xk[1]
+	s2 ^= xk[2]
+	s3 ^= xk[3]
 
 	// Middle rounds shuffle using tables.
 	// Number of rounds is set by length of expanded key.
-	nr := len(xk)/4 - 2;	// - 2: one above, one more below
-	k := 4;
+	nr := len(xk)/4 - 2 // - 2: one above, one more below
+	k := 4
 	for r := 0; r < nr; r++ {
-		t0 = xk[k+0] ^ td[0][s0>>24] ^ td[1][s3>>16&0xff] ^ td[2][s2>>8&0xff] ^ td[3][s1&0xff];
-		t1 = xk[k+1] ^ td[0][s1>>24] ^ td[1][s0>>16&0xff] ^ td[2][s3>>8&0xff] ^ td[3][s2&0xff];
-		t2 = xk[k+2] ^ td[0][s2>>24] ^ td[1][s1>>16&0xff] ^ td[2][s0>>8&0xff] ^ td[3][s3&0xff];
-		t3 = xk[k+3] ^ td[0][s3>>24] ^ td[1][s2>>16&0xff] ^ td[2][s1>>8&0xff] ^ td[3][s0&0xff];
-		k += 4;
-		s0, s1, s2, s3 = t0, t1, t2, t3;
+		t0 = xk[k+0] ^ td[0][s0>>24] ^ td[1][s3>>16&0xff] ^ td[2][s2>>8&0xff] ^ td[3][s1&0xff]
+		t1 = xk[k+1] ^ td[0][s1>>24] ^ td[1][s0>>16&0xff] ^ td[2][s3>>8&0xff] ^ td[3][s2&0xff]
+		t2 = xk[k+2] ^ td[0][s2>>24] ^ td[1][s1>>16&0xff] ^ td[2][s0>>8&0xff] ^ td[3][s3&0xff]
+		t3 = xk[k+3] ^ td[0][s3>>24] ^ td[1][s2>>16&0xff] ^ td[2][s1>>8&0xff] ^ td[3][s0&0xff]
+		k += 4
+		s0, s1, s2, s3 = t0, t1, t2, t3
 	}
 
 	// Last round uses s-box directly and XORs to produce output.
-	s0 = uint32(sbox1[t0>>24])<<24 | uint32(sbox1[t3>>16&0xff])<<16 | uint32(sbox1[t2>>8&0xff])<<8 | uint32(sbox1[t1&0xff]);
-	s1 = uint32(sbox1[t1>>24])<<24 | uint32(sbox1[t0>>16&0xff])<<16 | uint32(sbox1[t3>>8&0xff])<<8 | uint32(sbox1[t2&0xff]);
-	s2 = uint32(sbox1[t2>>24])<<24 | uint32(sbox1[t1>>16&0xff])<<16 | uint32(sbox1[t0>>8&0xff])<<8 | uint32(sbox1[t3&0xff]);
-	s3 = uint32(sbox1[t3>>24])<<24 | uint32(sbox1[t2>>16&0xff])<<16 | uint32(sbox1[t1>>8&0xff])<<8 | uint32(sbox1[t0&0xff]);
-
-	s0 ^= xk[k+0];
-	s1 ^= xk[k+1];
-	s2 ^= xk[k+2];
-	s3 ^= xk[k+3];
-
-	dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0);
-	dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1);
-	dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2);
-	dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3);
+	s0 = uint32(sbox1[t0>>24])<<24 | uint32(sbox1[t3>>16&0xff])<<16 | uint32(sbox1[t2>>8&0xff])<<8 | uint32(sbox1[t1&0xff])
+	s1 = uint32(sbox1[t1>>24])<<24 | uint32(sbox1[t0>>16&0xff])<<16 | uint32(sbox1[t3>>8&0xff])<<8 | uint32(sbox1[t2&0xff])
+	s2 = uint32(sbox1[t2>>24])<<24 | uint32(sbox1[t1>>16&0xff])<<16 | uint32(sbox1[t0>>8&0xff])<<8 | uint32(sbox1[t3&0xff])
+	s3 = uint32(sbox1[t3>>24])<<24 | uint32(sbox1[t2>>16&0xff])<<16 | uint32(sbox1[t1>>8&0xff])<<8 | uint32(sbox1[t0&0xff])
+
+	s0 ^= xk[k+0]
+	s1 ^= xk[k+1]
+	s2 ^= xk[k+2]
+	s3 ^= xk[k+3]
+
+	dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0)
+	dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1)
+	dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2)
+	dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3)
 }
 
 // Apply sbox0 to each byte in w.
@@ -135,25 +135,25 @@ func subw(w uint32) uint32 {
 }
 
 // Rotate
-func rotw(w uint32) uint32	{ return w<<8 | w>>24 }
+func rotw(w uint32) uint32 { return w<<8 | w>>24 }
 
 // Key expansion algorithm.  See FIPS-197, Figure 11.
 // Their rcon[i] is our powx[i-1] << 24.
 func expandKey(key []byte, enc, dec []uint32) {
 	// Encryption key setup.
-	var i int;
-	nk := len(key) / 4;
+	var i int
+	nk := len(key) / 4
 	for i = 0; i < nk; i++ {
 		enc[i] = uint32(key[4*i])<<24 | uint32(key[4*i+1])<<16 | uint32(key[4*i+2])<<8 | uint32(key[4*i+3])
 	}
 	for ; i < len(enc); i++ {
-		t := enc[i-1];
+		t := enc[i-1]
 		if i%nk == 0 {
 			t = subw(rotw(t)) ^ (uint32(powx[i/nk-1]) << 24)
 		} else if nk > 6 && i%nk == 4 {
 			t = subw(t)
 		}
-		enc[i] = enc[i-nk] ^ t;
+		enc[i] = enc[i-nk] ^ t
 	}
 
 	// Derive decryption key from encryption key.
@@ -162,15 +162,15 @@ func expandKey(key []byte, enc, dec []uint32) {
 	if dec == nil {
 		return
 	}
-	n := len(enc);
+	n := len(enc)
 	for i := 0; i < n; i += 4 {
-		ei := n - i - 4;
+		ei := n - i - 4
 		for j := 0; j < 4; j++ {
-			x := enc[ei+j];
+			x := enc[ei+j]
 			if i > 0 && i+4 < n {
 				x = td[0][sbox0[x>>24]] ^ td[1][sbox0[x>>16&0xff]] ^ td[2][sbox0[x>>8&0xff]] ^ td[3][sbox0[x&0xff]]
 			}
-			dec[i+j] = x;
+			dec[i+j] = x
 		}
 	}
 }
diff --git a/src/pkg/crypto/aes/cipher.go b/src/pkg/crypto/aes/cipher.go
index 651c2651e..a7caf5576 100644
--- a/src/pkg/crypto/aes/cipher.go
+++ b/src/pkg/crypto/aes/cipher.go
@@ -5,8 +5,8 @@
 package aes
 
 import (
-	"os";
-	"strconv";
+	"os"
+	"strconv"
 )
 
 // The AES block size in bytes.
@@ -14,8 +14,8 @@ const BlockSize = 16
 
 // A Cipher is an instance of AES encryption using a particular key.
 type Cipher struct {
-	enc	[]uint32;
-	dec	[]uint32;
+	enc []uint32
+	dec []uint32
 }
 
 type KeySizeError int
@@ -29,7 +29,7 @@ func (k KeySizeError) String() string {
 // either 16, 24, or 32 bytes to select
 // AES-128, AES-192, or AES-256.
 func NewCipher(key []byte) (*Cipher, os.Error) {
-	k := len(key);
+	k := len(key)
 	switch k {
 	default:
 		return nil, KeySizeError(k)
@@ -37,27 +37,27 @@ func NewCipher(key []byte) (*Cipher, os.Error) {
 		break
 	}
 
-	n := k + 28;
-	c := &Cipher{make([]uint32, n), make([]uint32, n)};
-	expandKey(key, c.enc, c.dec);
-	return c, nil;
+	n := k + 28
+	c := &Cipher{make([]uint32, n), make([]uint32, n)}
+	expandKey(key, c.enc, c.dec)
+	return c, nil
 }
 
 // BlockSize returns the AES block size, 16 bytes.
 // It is necessary to satisfy the Key interface in the
 // package "crypto/modes".
-func (c *Cipher) BlockSize() int	{ return BlockSize }
+func (c *Cipher) BlockSize() int { return BlockSize }
 
 // Encrypt encrypts the 16-byte buffer src using the key k
 // and stores the result in dst.
 // Note that for amounts of data larger than a block,
 // it is not safe to just call Encrypt on successive blocks;
 // instead, use an encryption mode like AESCBC (see modes.go).
-func (c *Cipher) Encrypt(src, dst []byte)	{ encryptBlock(c.enc, src, dst) }
+func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c.enc, src, dst) }
 
 // Decrypt decrypts the 16-byte buffer src using the key k
 // and stores the result in dst.
-func (c *Cipher) Decrypt(src, dst []byte)	{ decryptBlock(c.dec, src, dst) }
+func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c.dec, src, dst) }
 
 // Reset zeros the key data, so that it will no longer
 // appear in the process's memory.
diff --git a/src/pkg/crypto/aes/const.go b/src/pkg/crypto/aes/const.go
index 862be087b..8ddcaff26 100644
--- a/src/pkg/crypto/aes/const.go
+++ b/src/pkg/crypto/aes/const.go
@@ -15,7 +15,7 @@ package aes
 // Addition of these binary polynomials corresponds to binary xor.
 // Reducing mod poly corresponds to binary xor with poly every
 // time a 0x100 bit appears.
-const poly = 1<<8 | 1<<4 | 1<<3 | 1<<1 | 1<<0	// x⁸ + x⁴ + x² + x + 1
+const poly = 1<<8 | 1<<4 | 1<<3 | 1<<1 | 1<<0 // x⁸ + x⁴ + x² + x + 1
 
 // Powers of x mod poly in GF(2).
 var powx = [16]byte{
diff --git a/src/pkg/crypto/block/cbc.go b/src/pkg/crypto/block/cbc.go
index ac41ab1fb..10235f541 100644
--- a/src/pkg/crypto/block/cbc.go
+++ b/src/pkg/crypto/block/cbc.go
@@ -12,44 +12,44 @@
 package block
 
 import (
-	"io";
+	"io"
 )
 
 type cbcCipher struct {
-	c		Cipher;
-	blockSize	int;
-	iv		[]byte;
-	tmp		[]byte;
+	c         Cipher
+	blockSize int
+	iv        []byte
+	tmp       []byte
 }
 
 func newCBC(c Cipher, iv []byte) *cbcCipher {
-	n := c.BlockSize();
-	x := new(cbcCipher);
-	x.c = c;
-	x.blockSize = n;
-	x.iv = copy(iv);
-	x.tmp = make([]byte, n);
-	return x;
+	n := c.BlockSize()
+	x := new(cbcCipher)
+	x.c = c
+	x.blockSize = n
+	x.iv = copy(iv)
+	x.tmp = make([]byte, n)
+	return x
 }
 
-func (x *cbcCipher) BlockSize() int	{ return x.blockSize }
+func (x *cbcCipher) BlockSize() int { return x.blockSize }
 
 func (x *cbcCipher) Encrypt(src, dst []byte) {
 	for i := 0; i < x.blockSize; i++ {
 		x.iv[i] ^= src[i]
 	}
-	x.c.Encrypt(x.iv, x.iv);
+	x.c.Encrypt(x.iv, x.iv)
 	for i := 0; i < x.blockSize; i++ {
 		dst[i] = x.iv[i]
 	}
 }
 
 func (x *cbcCipher) Decrypt(src, dst []byte) {
-	x.c.Decrypt(src, x.tmp);
+	x.c.Decrypt(src, x.tmp)
 	for i := 0; i < x.blockSize; i++ {
-		x.tmp[i] ^= x.iv[i];
-		x.iv[i] = src[i];
-		dst[i] = x.tmp[i];
+		x.tmp[i] ^= x.iv[i]
+		x.iv[i] = src[i]
+		dst[i] = x.tmp[i]
 	}
 }
 
diff --git a/src/pkg/crypto/block/cbc_aes_test.go b/src/pkg/crypto/block/cbc_aes_test.go
index 02c58fabd..5531f3ab9 100644
--- a/src/pkg/crypto/block/cbc_aes_test.go
+++ b/src/pkg/crypto/block/cbc_aes_test.go
@@ -11,18 +11,18 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"io"
+	"testing"
 )
 
 type cbcTest struct {
-	name	string;
-	key	[]byte;
-	iv	[]byte;
-	in	[]byte;
-	out	[]byte;
+	name string
+	key  []byte
+	iv   []byte
+	in   []byte
+	out  []byte
 }
 
 var cbcAESTests = []cbcTest{
@@ -67,28 +67,28 @@ var cbcAESTests = []cbcTest{
 
 func TestCBC_AES(t *testing.T) {
 	for _, tt := range cbcAESTests {
-		test := tt.name;
+		test := tt.name
 
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err);
-			continue;
+			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
+			continue
 		}
 
-		var crypt bytes.Buffer;
-		w := NewCBCEncrypter(c, tt.iv, &crypt);
-		var r io.Reader = bytes.NewBuffer(tt.in);
-		n, err := io.Copy(w, r);
+		var crypt bytes.Buffer
+		w := NewCBCEncrypter(c, tt.iv, &crypt)
+		var r io.Reader = bytes.NewBuffer(tt.in)
+		n, err := io.Copy(w, r)
 		if n != int64(len(tt.in)) || err != nil {
 			t.Errorf("%s: CBCEncrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in))
 		} else if d := crypt.Bytes(); !same(tt.out, d) {
 			t.Errorf("%s: CBCEncrypter\nhave %x\nwant %x", test, d, tt.out)
 		}
 
-		var plain bytes.Buffer;
-		r = NewCBCDecrypter(c, tt.iv, bytes.NewBuffer(tt.out));
-		w = &plain;
-		n, err = io.Copy(w, r);
+		var plain bytes.Buffer
+		r = NewCBCDecrypter(c, tt.iv, bytes.NewBuffer(tt.out))
+		w = &plain
+		n, err = io.Copy(w, r)
 		if n != int64(len(tt.out)) || err != nil {
 			t.Errorf("%s: CBCDecrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out))
 		} else if d := plain.Bytes(); !same(tt.in, d) {
diff --git a/src/pkg/crypto/block/cfb.go b/src/pkg/crypto/block/cfb.go
index d3c8852d7..82b289ac4 100644
--- a/src/pkg/crypto/block/cfb.go
+++ b/src/pkg/crypto/block/cfb.go
@@ -13,36 +13,36 @@
 package block
 
 import (
-	"io";
+	"io"
 )
 
 type cfbCipher struct {
-	c		Cipher;
-	blockSize	int;	// our block size (s/8)
-	cipherSize	int;	// underlying cipher block size
-	iv		[]byte;
-	tmp		[]byte;
+	c          Cipher
+	blockSize  int // our block size (s/8)
+	cipherSize int // underlying cipher block size
+	iv         []byte
+	tmp        []byte
 }
 
 func newCFB(c Cipher, s int, iv []byte) *cfbCipher {
 	if s == 0 || s%8 != 0 {
 		panicln("crypto/block: invalid CFB mode", s)
 	}
-	b := c.BlockSize();
-	x := new(cfbCipher);
-	x.c = c;
-	x.blockSize = s / 8;
-	x.cipherSize = b;
-	x.iv = copy(iv);
-	x.tmp = make([]byte, b);
-	return x;
+	b := c.BlockSize()
+	x := new(cfbCipher)
+	x.c = c
+	x.blockSize = s / 8
+	x.cipherSize = b
+	x.iv = copy(iv)
+	x.tmp = make([]byte, b)
+	return x
 }
 
-func (x *cfbCipher) BlockSize() int	{ return x.blockSize }
+func (x *cfbCipher) BlockSize() int { return x.blockSize }
 
 func (x *cfbCipher) Encrypt(src, dst []byte) {
 	// Encrypt old IV and xor prefix with src to make dst.
-	x.c.Encrypt(x.iv, x.tmp);
+	x.c.Encrypt(x.iv, x.tmp)
 	for i := 0; i < x.blockSize; i++ {
 		dst[i] = src[i] ^ x.tmp[i]
 	}
@@ -51,7 +51,7 @@ func (x *cfbCipher) Encrypt(src, dst []byte) {
 	for i := 0; i < x.cipherSize-x.blockSize; i++ {
 		x.iv[i] = x.iv[i+x.blockSize]
 	}
-	off := x.cipherSize - x.blockSize;
+	off := x.cipherSize - x.blockSize
 	for i := off; i < x.cipherSize; i++ {
 		x.iv[i] = dst[i-off]
 	}
@@ -59,7 +59,7 @@ func (x *cfbCipher) Encrypt(src, dst []byte) {
 
 func (x *cfbCipher) Decrypt(src, dst []byte) {
 	// Encrypt [sic] old IV and xor prefix with src to make dst.
-	x.c.Encrypt(x.iv, x.tmp);
+	x.c.Encrypt(x.iv, x.tmp)
 	for i := 0; i < x.blockSize; i++ {
 		dst[i] = src[i] ^ x.tmp[i]
 	}
@@ -68,7 +68,7 @@ func (x *cfbCipher) Decrypt(src, dst []byte) {
 	for i := 0; i < x.cipherSize-x.blockSize; i++ {
 		x.iv[i] = x.iv[i+x.blockSize]
 	}
-	off := x.cipherSize - x.blockSize;
+	off := x.cipherSize - x.blockSize
 	for i := off; i < x.cipherSize; i++ {
 		// Reconstruct src = dst ^ x.tmp
 		// in case we overwrote src (src == dst).
diff --git a/src/pkg/crypto/block/cfb_aes_test.go b/src/pkg/crypto/block/cfb_aes_test.go
index f1913691b..8a245a2cb 100644
--- a/src/pkg/crypto/block/cfb_aes_test.go
+++ b/src/pkg/crypto/block/cfb_aes_test.go
@@ -11,19 +11,19 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"io"
+	"testing"
 )
 
 type cfbTest struct {
-	name	string;
-	s	int;
-	key	[]byte;
-	iv	[]byte;
-	in	[]byte;
-	out	[]byte;
+	name string
+	s    int
+	key  []byte
+	iv   []byte
+	in   []byte
+	out  []byte
 }
 
 var cfbAESTests = []cfbTest{
@@ -271,33 +271,33 @@ var cfbAESTests = []cfbTest{
 
 func TestCFB_AES(t *testing.T) {
 	for _, tt := range cfbAESTests {
-		test := tt.name;
+		test := tt.name
 
 		if tt.s == 1 {
 			// 1-bit CFB not implemented
 			continue
 		}
 
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err);
-			continue;
+			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
+			continue
 		}
 
-		var crypt bytes.Buffer;
-		w := NewCFBEncrypter(c, tt.s, tt.iv, &crypt);
-		var r io.Reader = bytes.NewBuffer(tt.in);
-		n, err := io.Copy(w, r);
+		var crypt bytes.Buffer
+		w := NewCFBEncrypter(c, tt.s, tt.iv, &crypt)
+		var r io.Reader = bytes.NewBuffer(tt.in)
+		n, err := io.Copy(w, r)
 		if n != int64(len(tt.in)) || err != nil {
 			t.Errorf("%s: CFBEncrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in))
 		} else if d := crypt.Bytes(); !same(tt.out, d) {
 			t.Errorf("%s: CFBEncrypter\nhave %x\nwant %x", test, d, tt.out)
 		}
 
-		var plain bytes.Buffer;
-		r = NewCFBDecrypter(c, tt.s, tt.iv, bytes.NewBuffer(tt.out));
-		w = &plain;
-		n, err = io.Copy(w, r);
+		var plain bytes.Buffer
+		r = NewCFBDecrypter(c, tt.s, tt.iv, bytes.NewBuffer(tt.out))
+		w = &plain
+		n, err = io.Copy(w, r)
 		if n != int64(len(tt.out)) || err != nil {
 			t.Errorf("%s: CFBDecrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out))
 		} else if d := plain.Bytes(); !same(tt.in, d) {
diff --git a/src/pkg/crypto/block/cipher.go b/src/pkg/crypto/block/cipher.go
index 2ca15c129..1b786cca4 100644
--- a/src/pkg/crypto/block/cipher.go
+++ b/src/pkg/crypto/block/cipher.go
@@ -14,27 +14,27 @@ package block
 // extend that capability to streams of blocks.
 type Cipher interface {
 	// BlockSize returns the cipher's block size.
-	BlockSize() int;
+	BlockSize() int
 
 	// Encrypt encrypts the first block in src into dst.
 	// Src and dst may point at the same memory.
-	Encrypt(src, dst []byte);
+	Encrypt(src, dst []byte)
 
 	// Decrypt decrypts the first block in src into dst.
 	// Src and dst may point at the same memory.
-	Decrypt(src, dst []byte);
+	Decrypt(src, dst []byte)
 }
 
 // Utility routines
 
 func shift1(src, dst []byte) byte {
-	var b byte;
+	var b byte
 	for i := len(src) - 1; i >= 0; i-- {
-		bb := src[i] >> 7;
-		dst[i] = src[i]<<1 | b;
-		b = bb;
+		bb := src[i] >> 7
+		dst[i] = src[i]<<1 | b
+		b = bb
 	}
-	return b;
+	return b
 }
 
 func same(p, q []byte) bool {
@@ -46,13 +46,13 @@ func same(p, q []byte) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 func copy(p []byte) []byte {
-	q := make([]byte, len(p));
+	q := make([]byte, len(p))
 	for i, b := range p {
 		q[i] = b
 	}
-	return q;
+	return q
 }
diff --git a/src/pkg/crypto/block/cmac.go b/src/pkg/crypto/block/cmac.go
index 5b00b3727..a2f80fe4b 100644
--- a/src/pkg/crypto/block/cmac.go
+++ b/src/pkg/crypto/block/cmac.go
@@ -8,20 +8,20 @@
 package block
 
 import (
-	"hash";
-	"os";
+	"hash"
+	"os"
 )
 
 const (
 	// minimal irreducible polynomial of degree b
-	r64	= 0x1b;
-	r128	= 0x87;
+	r64  = 0x1b
+	r128 = 0x87
 )
 
 type cmac struct {
-	k1, k2, ci, digest	[]byte;
-	p			int;	// position in ci
-	c			Cipher;
+	k1, k2, ci, digest []byte
+	p                  int // position in ci
+	c                  Cipher
 }
 
 // TODO(rsc): Should this return an error instead of panic?
@@ -29,8 +29,8 @@ type cmac struct {
 // NewCMAC returns a new instance of a CMAC message authentication code
 // digest using the given Cipher.
 func NewCMAC(c Cipher) hash.Hash {
-	var r byte;
-	n := c.BlockSize();
+	var r byte
+	n := c.BlockSize()
 	switch n {
 	case 64 / 8:
 		r = r64
@@ -40,15 +40,15 @@ func NewCMAC(c Cipher) hash.Hash {
 		panic("crypto/block: NewCMAC: invalid cipher block size", n)
 	}
 
-	d := new(cmac);
-	d.c = c;
-	d.k1 = make([]byte, n);
-	d.k2 = make([]byte, n);
-	d.ci = make([]byte, n);
-	d.digest = make([]byte, n);
+	d := new(cmac)
+	d.c = c
+	d.k1 = make([]byte, n)
+	d.k2 = make([]byte, n)
+	d.ci = make([]byte, n)
+	d.digest = make([]byte, n)
 
 	// Subkey generation, p. 7
-	c.Encrypt(d.k1, d.k1);
+	c.Encrypt(d.k1, d.k1)
 	if shift1(d.k1, d.k1) != 0 {
 		d.k1[n-1] ^= r
 	}
@@ -56,7 +56,7 @@ func NewCMAC(c Cipher) hash.Hash {
 		d.k2[n-1] ^= r
 	}
 
-	return d;
+	return d
 }
 
 // Reset clears the digest state, starting a new digest.
@@ -64,7 +64,7 @@ func (d *cmac) Reset() {
 	for i := range d.ci {
 		d.ci[i] = 0
 	}
-	d.p = 0;
+	d.p = 0
 }
 
 // Write adds the given data to the digest state.
@@ -73,13 +73,13 @@ func (d *cmac) Write(p []byte) (n int, err os.Error) {
 	for _, c := range p {
 		// If ci is full, encrypt and start over.
 		if d.p >= len(d.ci) {
-			d.c.Encrypt(d.ci, d.ci);
-			d.p = 0;
+			d.c.Encrypt(d.ci, d.ci)
+			d.p = 0
 		}
-		d.ci[d.p] ^= c;
-		d.p++;
+		d.ci[d.p] ^= c
+		d.p++
 	}
-	return len(p), nil;
+	return len(p), nil
 }
 
 // Sum returns the CMAC digest, one cipher block in length,
@@ -88,7 +88,7 @@ func (d *cmac) Sum() []byte {
 	// Finish last block, mix in key, encrypt.
 	// Don't edit ci, in case caller wants
 	// to keep digesting after call to Sum.
-	k := d.k1;
+	k := d.k1
 	if d.p < len(d.digest) {
 		k = d.k2
 	}
@@ -98,8 +98,8 @@ func (d *cmac) Sum() []byte {
 	if d.p < len(d.digest) {
 		d.digest[d.p] ^= 0x80
 	}
-	d.c.Encrypt(d.digest, d.digest);
-	return d.digest;
+	d.c.Encrypt(d.digest, d.digest)
+	return d.digest
 }
 
-func (d *cmac) Size() int	{ return len(d.digest) }
+func (d *cmac) Size() int { return len(d.digest) }
diff --git a/src/pkg/crypto/block/cmac_aes_test.go b/src/pkg/crypto/block/cmac_aes_test.go
index 8e727ed9c..a9cbc71a6 100644
--- a/src/pkg/crypto/block/cmac_aes_test.go
+++ b/src/pkg/crypto/block/cmac_aes_test.go
@@ -7,14 +7,14 @@
 package block
 
 import (
-	"crypto/aes";
-	"testing";
+	"crypto/aes"
+	"testing"
 )
 
 type cmacAESTest struct {
-	key	[]byte;
-	in	[]byte;
-	digest	[]byte;
+	key    []byte
+	in     []byte
+	digest []byte
 }
 
 var cmacAESTests = []cmacAESTest{
@@ -109,22 +109,22 @@ var cmacAESTests = []cmacAESTest{
 
 func TestCMAC_AES(t *testing.T) {
 	for i, tt := range cmacAESTests {
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("test %d: NewCipher: %s", i, err);
-			continue;
+			t.Errorf("test %d: NewCipher: %s", i, err)
+			continue
 		}
-		d := NewCMAC(c);
-		n, err := d.Write(tt.in);
+		d := NewCMAC(c)
+		n, err := d.Write(tt.in)
 		if err != nil || n != len(tt.in) {
-			t.Errorf("test %d: Write %d: %d, %s", i, len(tt.in), n, err);
-			continue;
+			t.Errorf("test %d: Write %d: %d, %s", i, len(tt.in), n, err)
+			continue
 		}
-		sum := d.Sum();
+		sum := d.Sum()
 		if !same(sum, tt.digest) {
-			x := d.(*cmac);
-			t.Errorf("test %d: digest mismatch\n\twant %x\n\thave %x\n\tk1 %x\n\tk2 %x", i, tt.digest, sum, x.k1, x.k2);
-			continue;
+			x := d.(*cmac)
+			t.Errorf("test %d: digest mismatch\n\twant %x\n\thave %x\n\tk1 %x\n\tk2 %x", i, tt.digest, sum, x.k1, x.k2)
+			continue
 		}
 	}
 }
diff --git a/src/pkg/crypto/block/ctr.go b/src/pkg/crypto/block/ctr.go
index bfb0fc23e..085ae05b1 100644
--- a/src/pkg/crypto/block/ctr.go
+++ b/src/pkg/crypto/block/ctr.go
@@ -13,36 +13,36 @@
 package block
 
 import (
-	"io";
+	"io"
 )
 
 type ctrStream struct {
-	c	Cipher;
-	ctr	[]byte;
-	out	[]byte;
+	c   Cipher
+	ctr []byte
+	out []byte
 }
 
 func newCTRStream(c Cipher, ctr []byte) *ctrStream {
-	x := new(ctrStream);
-	x.c = c;
-	x.ctr = copy(ctr);
-	x.out = make([]byte, len(ctr));
-	return x;
+	x := new(ctrStream)
+	x.c = c
+	x.ctr = copy(ctr)
+	x.out = make([]byte, len(ctr))
+	return x
 }
 
 func (x *ctrStream) Next() []byte {
 	// Next block is encryption of counter.
-	x.c.Encrypt(x.ctr, x.out);
+	x.c.Encrypt(x.ctr, x.out)
 
 	// Increment counter
 	for i := len(x.ctr) - 1; i >= 0; i-- {
-		x.ctr[i]++;
+		x.ctr[i]++
 		if x.ctr[i] != 0 {
 			break
 		}
 	}
 
-	return x.out;
+	return x.out
 }
 
 // NewCTRReader returns a reader that reads data from r, decrypts (or encrypts)
diff --git a/src/pkg/crypto/block/ctr_aes_test.go b/src/pkg/crypto/block/ctr_aes_test.go
index 456c07131..adb996c1d 100644
--- a/src/pkg/crypto/block/ctr_aes_test.go
+++ b/src/pkg/crypto/block/ctr_aes_test.go
@@ -11,18 +11,18 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"io"
+	"testing"
 )
 
 type ctrTest struct {
-	name	string;
-	key	[]byte;
-	iv	[]byte;
-	in	[]byte;
-	out	[]byte;
+	name string
+	key  []byte
+	iv   []byte
+	in   []byte
+	out  []byte
 }
 
 var commonCounter = []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}
@@ -69,20 +69,20 @@ var ctrAESTests = []ctrTest{
 
 func TestCTR_AES(t *testing.T) {
 	for _, tt := range ctrAESTests {
-		test := tt.name;
+		test := tt.name
 
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err);
-			continue;
+			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
+			continue
 		}
 
 		for j := 0; j <= 5; j += 5 {
-			var crypt bytes.Buffer;
-			in := tt.in[0 : len(tt.in)-j];
-			w := NewCTRWriter(c, tt.iv, &crypt);
-			var r io.Reader = bytes.NewBuffer(in);
-			n, err := io.Copy(w, r);
+			var crypt bytes.Buffer
+			in := tt.in[0 : len(tt.in)-j]
+			w := NewCTRWriter(c, tt.iv, &crypt)
+			var r io.Reader = bytes.NewBuffer(in)
+			n, err := io.Copy(w, r)
 			if n != int64(len(in)) || err != nil {
 				t.Errorf("%s/%d: CTRWriter io.Copy = %d, %v want %d, nil", test, len(in), n, err, len(in))
 			} else if d, out := crypt.Bytes(), tt.out[0:len(in)]; !same(out, d) {
@@ -91,11 +91,11 @@ func TestCTR_AES(t *testing.T) {
 		}
 
 		for j := 0; j <= 7; j += 7 {
-			var plain bytes.Buffer;
-			out := tt.out[0 : len(tt.out)-j];
-			r := NewCTRReader(c, tt.iv, bytes.NewBuffer(out));
-			w := &plain;
-			n, err := io.Copy(w, r);
+			var plain bytes.Buffer
+			out := tt.out[0 : len(tt.out)-j]
+			r := NewCTRReader(c, tt.iv, bytes.NewBuffer(out))
+			w := &plain
+			n, err := io.Copy(w, r)
 			if n != int64(len(out)) || err != nil {
 				t.Errorf("%s/%d: CTRReader io.Copy = %d, %v want %d, nil", test, len(out), n, err, len(out))
 			} else if d, in := plain.Bytes(), tt.in[0:len(out)]; !same(in, d) {
diff --git a/src/pkg/crypto/block/eax.go b/src/pkg/crypto/block/eax.go
index 07919e4ae..fcd5fe20f 100644
--- a/src/pkg/crypto/block/eax.go
+++ b/src/pkg/crypto/block/eax.go
@@ -15,18 +15,18 @@
 package block
 
 import (
-	"fmt";
-	"hash";
-	"io";
-	"os";
+	"fmt"
+	"hash"
+	"io"
+	"os"
 )
 
 // An EAXTagError is returned when the message has failed to authenticate,
 // because the tag at the end of the message stream (Read) does not match
 // the tag computed from the message itself (Computed).
 type EAXTagError struct {
-	Read		[]byte;
-	Computed	[]byte;
+	Read     []byte
+	Computed []byte
 }
 
 func (e *EAXTagError) String() string {
@@ -34,39 +34,39 @@ func (e *EAXTagError) String() string {
 }
 
 func setupEAX(c Cipher, iv, hdr []byte, tagBytes int) (ctrIV, tag []byte, cmac hash.Hash) {
-	n := len(iv);
+	n := len(iv)
 	if n != c.BlockSize() {
 		panicln("crypto/block: EAX: iv length", n, "!=", c.BlockSize())
 	}
-	buf := make([]byte, n);	// zeroed
+	buf := make([]byte, n) // zeroed
 
 	// tag = CMAC(0 + iv) ^ CMAC(1 + hdr) ^ CMAC(2 + data)
-	cmac = NewCMAC(c);
-	cmac.Write(buf);	// 0
-	cmac.Write(iv);
-	sum := cmac.Sum();
-	ctrIV = copy(sum);
-	tag = copy(sum[0:tagBytes]);
-
-	cmac.Reset();
-	buf[n-1] = 1;
-	cmac.Write(buf);	// 1
-	cmac.Write(hdr);
-	sum = cmac.Sum();
+	cmac = NewCMAC(c)
+	cmac.Write(buf) // 0
+	cmac.Write(iv)
+	sum := cmac.Sum()
+	ctrIV = copy(sum)
+	tag = copy(sum[0:tagBytes])
+
+	cmac.Reset()
+	buf[n-1] = 1
+	cmac.Write(buf) // 1
+	cmac.Write(hdr)
+	sum = cmac.Sum()
 	for i := 0; i < tagBytes; i++ {
 		tag[i] ^= sum[i]
 	}
 
-	cmac.Reset();
-	buf[n-1] = 2;	// 2
-	cmac.Write(buf);
+	cmac.Reset()
+	buf[n-1] = 2 // 2
+	cmac.Write(buf)
 
-	return;
+	return
 }
 
 func finishEAX(tag []byte, cmac hash.Hash) {
 	// Finish CMAC #2 and xor into tag.
-	sum := cmac.Sum();
+	sum := cmac.Sum()
 	for i := range tag {
 		tag[i] ^= sum[i]
 	}
@@ -75,21 +75,21 @@ func finishEAX(tag []byte, cmac hash.Hash) {
 // Writer adapter.  Tees writes into both w and cmac.
 // Knows that cmac never returns write errors.
 type cmacWriter struct {
-	w	io.Writer;
-	cmac	hash.Hash;
+	w    io.Writer
+	cmac hash.Hash
 }
 
 func (cw *cmacWriter) Write(p []byte) (n int, err os.Error) {
-	n, err = cw.w.Write(p);
-	cw.cmac.Write(p[0:n]);
-	return;
+	n, err = cw.w.Write(p)
+	cw.cmac.Write(p[0:n])
+	return
 }
 
 // An eaxEncrypter implements the EAX encryption mode.
 type eaxEncrypter struct {
-	ctr	io.Writer;	// CTR encrypter
-	cw	cmacWriter;	// CTR's output stream
-	tag	[]byte;
+	ctr io.Writer  // CTR encrypter
+	cw  cmacWriter // CTR's output stream
+	tag []byte
 }
 
 // NewEAXEncrypter creates and returns a new EAX encrypter
@@ -98,15 +98,15 @@ type eaxEncrypter struct {
 // the data it receives and writes that data to w.
 // The encrypter's Close method writes a final authenticating tag to w.
 func NewEAXEncrypter(c Cipher, iv []byte, hdr []byte, tagBytes int, w io.Writer) io.WriteCloser {
-	x := new(eaxEncrypter);
+	x := new(eaxEncrypter)
 
 	// Create new CTR instance writing to both
 	// w for encrypted output and cmac for digesting.
-	x.cw.w = w;
-	var ctrIV []byte;
-	ctrIV, x.tag, x.cw.cmac = setupEAX(c, iv, hdr, tagBytes);
-	x.ctr = NewCTRWriter(c, ctrIV, &x.cw);
-	return x;
+	x.cw.w = w
+	var ctrIV []byte
+	ctrIV, x.tag, x.cw.cmac = setupEAX(c, iv, hdr, tagBytes)
+	x.ctr = NewCTRWriter(c, ctrIV, &x.cw)
+	return x
 }
 
 func (x *eaxEncrypter) Write(p []byte) (n int, err os.Error) {
@@ -114,16 +114,16 @@ func (x *eaxEncrypter) Write(p []byte) (n int, err os.Error) {
 }
 
 func (x *eaxEncrypter) Close() os.Error {
-	x.ctr = nil;	// crash if Write is called again
+	x.ctr = nil // crash if Write is called again
 
 	// Write tag.
-	finishEAX(x.tag, x.cw.cmac);
-	n, err := x.cw.w.Write(x.tag);
+	finishEAX(x.tag, x.cw.cmac)
+	n, err := x.cw.w.Write(x.tag)
 	if n != len(x.tag) && err == nil {
 		err = io.ErrShortWrite
 	}
 
-	return err;
+	return err
 }
 
 // Reader adapter.  Returns data read from r but hangs
@@ -133,10 +133,10 @@ func (x *eaxEncrypter) Close() os.Error {
 // and the "tee into digest" functionality could be separated,
 // but the latter half is trivial.
 type cmacReader struct {
-	r	io.Reader;
-	cmac	hash.Hash;
-	tag	[]byte;
-	tmp	[]byte;
+	r    io.Reader
+	cmac hash.Hash
+	tag  []byte
+	tmp  []byte
 }
 
 func (cr *cmacReader) Read(p []byte) (n int, err os.Error) {
@@ -147,21 +147,21 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) {
 
 	// First, read a tag-sized chunk.
 	// It's probably not the tag (unless there's no data).
-	tag := cr.tag;
+	tag := cr.tag
 	if len(tag) < cap(tag) {
-		nt := len(tag);
-		nn, err1 := io.ReadFull(cr.r, tag[nt:cap(tag)]);
-		tag = tag[0 : nt+nn];
-		cr.tag = tag;
+		nt := len(tag)
+		nn, err1 := io.ReadFull(cr.r, tag[nt:cap(tag)])
+		tag = tag[0 : nt+nn]
+		cr.tag = tag
 		if err1 != nil {
 			return 0, err1
 		}
 	}
 
-	tagBytes := len(tag);
+	tagBytes := len(tag)
 	if len(p) > 4*tagBytes {
 		// If p is big, try to read directly into p to avoid a copy.
-		n, err = cr.r.Read(p[tagBytes:]);
+		n, err = cr.r.Read(p[tagBytes:])
 		if n == 0 {
 			goto out
 		}
@@ -173,19 +173,19 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) {
 		for i := 0; i < tagBytes; i++ {
 			tag[i] = p[n+i]
 		}
-		goto out;
+		goto out
 	}
 
 	// Otherwise, read into p and then slide data
-	n, err = cr.r.Read(p);
+	n, err = cr.r.Read(p)
 	if n == 0 {
 		goto out
 	}
 
 	// copy tag+p into p+tmp and then swap tmp, tag
-	tmp := cr.tmp;
+	tmp := cr.tmp
 	for i := n + tagBytes - 1; i >= 0; i-- {
-		var c byte;
+		var c byte
 		if i < tagBytes {
 			c = tag[i]
 		} else {
@@ -197,17 +197,17 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) {
 			tmp[i] = c
 		}
 	}
-	cr.tmp, cr.tag = tag, tmp;
+	cr.tmp, cr.tag = tag, tmp
 
 out:
-	cr.cmac.Write(p[0:n]);
-	return;
+	cr.cmac.Write(p[0:n])
+	return
 }
 
 type eaxDecrypter struct {
-	ctr	io.Reader;
-	cr	cmacReader;
-	tag	[]byte;
+	ctr io.Reader
+	cr  cmacReader
+	tag []byte
 }
 
 // NewEAXDecrypter creates and returns a new EAX decrypter
@@ -220,34 +220,34 @@ type eaxDecrypter struct {
 // assumed to be valid, authenticated data until Read returns
 // 0, nil to signal the end of the data.
 func NewEAXDecrypter(c Cipher, iv []byte, hdr []byte, tagBytes int, r io.Reader) io.Reader {
-	x := new(eaxDecrypter);
+	x := new(eaxDecrypter)
 
-	x.cr.r = r;
-	x.cr.tag = make([]byte, 0, tagBytes);
-	x.cr.tmp = make([]byte, 0, tagBytes);
-	var ctrIV []byte;
-	ctrIV, x.tag, x.cr.cmac = setupEAX(c, iv, hdr, tagBytes);
-	x.ctr = NewCTRReader(c, ctrIV, &x.cr);
-	return x;
+	x.cr.r = r
+	x.cr.tag = make([]byte, 0, tagBytes)
+	x.cr.tmp = make([]byte, 0, tagBytes)
+	var ctrIV []byte
+	ctrIV, x.tag, x.cr.cmac = setupEAX(c, iv, hdr, tagBytes)
+	x.ctr = NewCTRReader(c, ctrIV, &x.cr)
+	return x
 }
 
 func (x *eaxDecrypter) checkTag() os.Error {
-	x.ctr = nil;	// crash if Read is called again
+	x.ctr = nil // crash if Read is called again
 
-	finishEAX(x.tag, x.cr.cmac);
+	finishEAX(x.tag, x.cr.cmac)
 	if !same(x.tag, x.cr.tag) {
-		e := new(EAXTagError);
-		e.Computed = copy(x.tag);
-		e.Read = copy(x.cr.tag);
-		return e;
+		e := new(EAXTagError)
+		e.Computed = copy(x.tag)
+		e.Read = copy(x.cr.tag)
+		return e
 	}
-	return nil;
+	return nil
 }
 
 func (x *eaxDecrypter) Read(p []byte) (n int, err os.Error) {
-	n, err = x.ctr.Read(p);
+	n, err = x.ctr.Read(p)
 	if n == 0 && err == nil {
 		err = x.checkTag()
 	}
-	return n, err;
+	return n, err
 }
diff --git a/src/pkg/crypto/block/eax_aes_test.go b/src/pkg/crypto/block/eax_aes_test.go
index 43f126d21..a1a099429 100644
--- a/src/pkg/crypto/block/eax_aes_test.go
+++ b/src/pkg/crypto/block/eax_aes_test.go
@@ -5,21 +5,21 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"fmt";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"fmt"
+	"io"
+	"testing"
 )
 
 // Test vectors from http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf
 
 type eaxAESTest struct {
-	msg	[]byte;
-	key	[]byte;
-	nonce	[]byte;
-	header	[]byte;
-	cipher	[]byte;
+	msg    []byte
+	key    []byte
+	nonce  []byte
+	header []byte
+	cipher []byte
 }
 
 var eaxAESTests = []eaxAESTest{
@@ -96,20 +96,20 @@ var eaxAESTests = []eaxAESTest{
 }
 
 func TestEAXEncrypt_AES(t *testing.T) {
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for i, tt := range eaxAESTests {
-		test := fmt.Sprintf("test %d", i);
-		c, err := aes.NewCipher(tt.key);
+		test := fmt.Sprintf("test %d", i)
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
 			t.Fatalf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
 		}
-		b.Reset();
-		enc := NewEAXEncrypter(c, tt.nonce, tt.header, 16, b);
-		n, err := io.Copy(enc, bytes.NewBuffer(tt.msg));
+		b.Reset()
+		enc := NewEAXEncrypter(c, tt.nonce, tt.header, 16, b)
+		n, err := io.Copy(enc, bytes.NewBuffer(tt.msg))
 		if n != int64(len(tt.msg)) || err != nil {
 			t.Fatalf("%s: io.Copy into encrypter: %d, %s", test, n, err)
 		}
-		err = enc.Close();
+		err = enc.Close()
 		if err != nil {
 			t.Fatalf("%s: enc.Close: %s", test, err)
 		}
@@ -120,16 +120,16 @@ func TestEAXEncrypt_AES(t *testing.T) {
 }
 
 func TestEAXDecrypt_AES(t *testing.T) {
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for i, tt := range eaxAESTests {
-		test := fmt.Sprintf("test %d", i);
-		c, err := aes.NewCipher(tt.key);
+		test := fmt.Sprintf("test %d", i)
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
 			t.Fatalf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
 		}
-		b.Reset();
-		dec := NewEAXDecrypter(c, tt.nonce, tt.header, 16, bytes.NewBuffer(tt.cipher));
-		n, err := io.Copy(b, dec);
+		b.Reset()
+		dec := NewEAXDecrypter(c, tt.nonce, tt.header, 16, bytes.NewBuffer(tt.cipher))
+		n, err := io.Copy(b, dec)
 		if n != int64(len(tt.msg)) || err != nil {
 			t.Fatalf("%s: io.Copy into decrypter: %d, %s", test, n, err)
 		}
diff --git a/src/pkg/crypto/block/ecb.go b/src/pkg/crypto/block/ecb.go
index c7491eb9c..73d1d63f7 100644
--- a/src/pkg/crypto/block/ecb.go
+++ b/src/pkg/crypto/block/ecb.go
@@ -14,32 +14,32 @@
 package block
 
 import (
-	"io";
-	"os";
-	"strconv";
+	"io"
+	"os"
+	"strconv"
 )
 
 type ecbDecrypter struct {
-	c		Cipher;
-	r		io.Reader;
-	blockSize	int;	// block size
+	c         Cipher
+	r         io.Reader
+	blockSize int // block size
 
 	// Buffered data.
 	// The buffer buf is used as storage for both
 	// plain or crypt; at least one of those is nil at any given time.
-	buf	[]byte;
-	plain	[]byte;	// plain text waiting to be read
-	crypt	[]byte;	// ciphertext waiting to be decrypted
+	buf   []byte
+	plain []byte // plain text waiting to be read
+	crypt []byte // ciphertext waiting to be decrypted
 }
 
 // Read into x.crypt until it has a full block or EOF or an error happens.
 func (x *ecbDecrypter) fillCrypt() os.Error {
-	var err os.Error;
+	var err os.Error
 	for len(x.crypt) < x.blockSize {
-		off := len(x.crypt);
-		var m int;
-		m, err = x.r.Read(x.crypt[off:x.blockSize]);
-		x.crypt = x.crypt[0 : off+m];
+		off := len(x.crypt)
+		var m int
+		m, err = x.r.Read(x.crypt[off:x.blockSize])
+		x.crypt = x.crypt[0 : off+m]
 		if m == 0 {
 			break
 		}
@@ -53,12 +53,12 @@ func (x *ecbDecrypter) fillCrypt() os.Error {
 			break
 		}
 	}
-	return err;
+	return err
 }
 
 // Read from plain text buffer into p.
 func (x *ecbDecrypter) readPlain(p []byte) int {
-	n := len(x.plain);
+	n := len(x.plain)
 	if n > len(p) {
 		n = len(p)
 	}
@@ -70,7 +70,7 @@ func (x *ecbDecrypter) readPlain(p []byte) int {
 	} else {
 		x.plain = nil
 	}
-	return n;
+	return n
 }
 
 type ecbFragmentError int
@@ -95,46 +95,46 @@ func (x *ecbDecrypter) Read(p []byte) (n int, err os.Error) {
 	// If there is a leftover cipher text buffer,
 	// try to accumulate a full block.
 	if x.crypt != nil {
-		err = x.fillCrypt();
+		err = x.fillCrypt()
 		if err != nil || len(x.crypt) == 0 {
 			return
 		}
-		x.c.Decrypt(x.crypt, x.crypt);
-		x.plain = x.crypt;
-		x.crypt = nil;
+		x.c.Decrypt(x.crypt, x.crypt)
+		x.plain = x.crypt
+		x.crypt = nil
 	}
 
 	// If there is a leftover plain text buffer, read from it.
 	if x.plain != nil {
-		n = x.readPlain(p);
-		return;
+		n = x.readPlain(p)
+		return
 	}
 
 	// Read and decrypt directly in caller's buffer.
-	n, err = io.ReadAtLeast(x.r, p, x.blockSize);
+	n, err = io.ReadAtLeast(x.r, p, x.blockSize)
 	if err == os.EOF && n > 0 {
 		// EOF is only okay on block boundary
-		err = os.ErrorString("block fragment at EOF during decryption");
-		return;
+		err = os.ErrorString("block fragment at EOF during decryption")
+		return
 	}
-	var i int;
+	var i int
 	for i = 0; i+x.blockSize <= n; i += x.blockSize {
-		a := p[i : i+x.blockSize];
-		x.c.Decrypt(a, a);
+		a := p[i : i+x.blockSize]
+		x.c.Decrypt(a, a)
 	}
 
 	// There might be an encrypted fringe remaining.
 	// Save it for next time.
 	if i < n {
-		p = p[i:n];
+		p = p[i:n]
 		for j, v := range p {
 			x.buf[j] = v
 		}
-		x.crypt = x.buf[0:len(p)];
-		n = i;
+		x.crypt = x.buf[0:len(p)]
+		n = i
 	}
 
-	return;
+	return
 }
 
 // NewECBDecrypter returns a reader that reads data from r and decrypts it using c.
@@ -143,26 +143,26 @@ func (x *ecbDecrypter) Read(p []byte) (n int, err os.Error) {
 // The returned Reader does not buffer or read ahead except
 // as required by the cipher's block size.
 func NewECBDecrypter(c Cipher, r io.Reader) io.Reader {
-	x := new(ecbDecrypter);
-	x.c = c;
-	x.r = r;
-	x.blockSize = c.BlockSize();
-	x.buf = make([]byte, x.blockSize);
-	return x;
+	x := new(ecbDecrypter)
+	x.c = c
+	x.r = r
+	x.blockSize = c.BlockSize()
+	x.buf = make([]byte, x.blockSize)
+	return x
 }
 
 type ecbEncrypter struct {
-	c		Cipher;
-	w		io.Writer;
-	blockSize	int;
+	c         Cipher
+	w         io.Writer
+	blockSize int
 
 	// Buffered data.
 	// The buffer buf is used as storage for both
 	// plain or crypt.  If both are non-nil, plain
 	// follows crypt in buf.
-	buf	[]byte;
-	plain	[]byte;	// plain text waiting to be encrypted
-	crypt	[]byte;	// encrypted text waiting to be written
+	buf   []byte
+	plain []byte // plain text waiting to be encrypted
+	crypt []byte // encrypted text waiting to be written
 }
 
 // Flush the x.crypt buffer to x.w.
@@ -170,9 +170,9 @@ func (x *ecbEncrypter) flushCrypt() os.Error {
 	if len(x.crypt) == 0 {
 		return nil
 	}
-	n, err := x.w.Write(x.crypt);
+	n, err := x.w.Write(x.crypt)
 	if n < len(x.crypt) {
-		x.crypt = x.crypt[n:];
+		x.crypt = x.crypt[n:]
 		if err == nil {
 			err = io.ErrShortWrite
 		}
@@ -180,8 +180,8 @@ func (x *ecbEncrypter) flushCrypt() os.Error {
 	if err != nil {
 		return err
 	}
-	x.crypt = nil;
-	return nil;
+	x.crypt = nil
+	return nil
 }
 
 // Slide x.plain down to the beginning of x.buf.
@@ -196,35 +196,35 @@ func (x *ecbEncrypter) slidePlain() {
 		for i := 0; i < len(x.plain); i++ {
 			x.buf[i] = x.plain[i]
 		}
-		x.plain = x.buf[0:len(x.plain)];
+		x.plain = x.buf[0:len(x.plain)]
 	}
 }
 
 // Fill x.plain from the data in p.
 // Return the number of bytes copied.
 func (x *ecbEncrypter) fillPlain(p []byte) int {
-	off := len(x.plain);
-	n := len(p);
+	off := len(x.plain)
+	n := len(p)
 	if max := cap(x.plain) - off; n > max {
 		n = max
 	}
-	x.plain = x.plain[0 : off+n];
+	x.plain = x.plain[0 : off+n]
 	for i := 0; i < n; i++ {
 		x.plain[off+i] = p[i]
 	}
-	return n;
+	return n
 }
 
 // Encrypt x.plain; record encrypted range as x.crypt.
 func (x *ecbEncrypter) encrypt() {
-	var i int;
-	n := len(x.plain);
+	var i int
+	n := len(x.plain)
 	for i = 0; i+x.blockSize <= n; i += x.blockSize {
-		a := x.plain[i : i+x.blockSize];
-		x.c.Encrypt(a, a);
+		a := x.plain[i : i+x.blockSize]
+		x.c.Encrypt(a, a)
 	}
-	x.crypt = x.plain[0:i];
-	x.plain = x.plain[i:n];
+	x.crypt = x.plain[0:i]
+	x.plain = x.plain[i:n]
 }
 
 func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) {
@@ -238,25 +238,25 @@ func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) {
 
 		// Now that encrypted data is gone (flush ran),
 		// perhaps we need to slide the plaintext down.
-		x.slidePlain();
+		x.slidePlain()
 
 		// Fill plaintext buffer from p.
-		m := x.fillPlain(p);
+		m := x.fillPlain(p)
 		if m == 0 {
 			break
 		}
-		n += m;
-		p = p[m:];
+		n += m
+		p = p[m:]
 
 		// Encrypt, adjusting crypt and plain.
-		x.encrypt();
+		x.encrypt()
 
 		// Write x.crypt.
 		if err = x.flushCrypt(); err != nil {
 			break
 		}
 	}
-	return;
+	return
 }
 
 // NewECBEncrypter returns a writer that encrypts data using c and writes it to w.
@@ -265,12 +265,12 @@ func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) {
 // The returned Writer does no buffering except as required
 // by the cipher's block size, so there is no need for a Flush method.
 func NewECBEncrypter(c Cipher, w io.Writer) io.Writer {
-	x := new(ecbEncrypter);
-	x.c = c;
-	x.w = w;
-	x.blockSize = c.BlockSize();
+	x := new(ecbEncrypter)
+	x.c = c
+	x.w = w
+	x.blockSize = c.BlockSize()
 
 	// Create a buffer that is an integral number of blocks.
-	x.buf = make([]byte, 8192/x.blockSize*x.blockSize);
-	return x;
+	x.buf = make([]byte, 8192/x.blockSize*x.blockSize)
+	return x
 }
diff --git a/src/pkg/crypto/block/ecb_aes_test.go b/src/pkg/crypto/block/ecb_aes_test.go
index 315ec213d..db0e085fa 100644
--- a/src/pkg/crypto/block/ecb_aes_test.go
+++ b/src/pkg/crypto/block/ecb_aes_test.go
@@ -11,17 +11,17 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"io"
+	"testing"
 )
 
 type ecbTest struct {
-	name	string;
-	key	[]byte;
-	in	[]byte;
-	out	[]byte;
+	name string
+	key  []byte
+	in   []byte
+	out  []byte
 }
 
 var commonInput = []byte{
@@ -92,28 +92,28 @@ var ecbAESTests = []ecbTest{
 
 func TestECB_AES(t *testing.T) {
 	for _, tt := range ecbAESTests {
-		test := tt.name;
+		test := tt.name
 
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err);
-			continue;
+			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
+			continue
 		}
 
-		var crypt bytes.Buffer;
-		w := NewECBEncrypter(c, &crypt);
-		var r io.Reader = bytes.NewBuffer(tt.in);
-		n, err := io.Copy(w, r);
+		var crypt bytes.Buffer
+		w := NewECBEncrypter(c, &crypt)
+		var r io.Reader = bytes.NewBuffer(tt.in)
+		n, err := io.Copy(w, r)
 		if n != int64(len(tt.in)) || err != nil {
 			t.Errorf("%s: ECBReader io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in))
 		} else if d := crypt.Bytes(); !same(tt.out, d) {
 			t.Errorf("%s: ECBReader\nhave %x\nwant %x", test, d, tt.out)
 		}
 
-		var plain bytes.Buffer;
-		r = NewECBDecrypter(c, bytes.NewBuffer(tt.out));
-		w = &plain;
-		n, err = io.Copy(w, r);
+		var plain bytes.Buffer
+		r = NewECBDecrypter(c, bytes.NewBuffer(tt.out))
+		w = &plain
+		n, err = io.Copy(w, r)
 		if n != int64(len(tt.out)) || err != nil {
 			t.Errorf("%s: ECBWriter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out))
 		} else if d := plain.Bytes(); !same(tt.in, d) {
diff --git a/src/pkg/crypto/block/ecb_test.go b/src/pkg/crypto/block/ecb_test.go
index d07afbe94..0d7c4035f 100644
--- a/src/pkg/crypto/block/ecb_test.go
+++ b/src/pkg/crypto/block/ecb_test.go
@@ -5,22 +5,22 @@
 package block
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"fmt"
+	"io"
+	"testing"
+	"testing/iotest"
 )
 
 // Simple Cipher for testing: adds an incrementing amount
 // to each byte in each
 type IncCipher struct {
-	blockSize	int;
-	delta		byte;
-	encrypting	bool;
+	blockSize  int
+	delta      byte
+	encrypting bool
 }
 
-func (c *IncCipher) BlockSize() int	{ return c.blockSize }
+func (c *IncCipher) BlockSize() int { return c.blockSize }
 
 func (c *IncCipher) Encrypt(src, dst []byte) {
 	if !c.encrypting {
@@ -29,7 +29,7 @@ func (c *IncCipher) Encrypt(src, dst []byte) {
 	if len(src) != c.blockSize || len(dst) != c.blockSize {
 		panicln("encrypt: wrong block size", c.blockSize, len(src), len(dst))
 	}
-	c.delta++;
+	c.delta++
 	for i, b := range src {
 		dst[i] = b + c.delta
 	}
@@ -42,62 +42,62 @@ func (c *IncCipher) Decrypt(src, dst []byte) {
 	if len(src) != c.blockSize || len(dst) != c.blockSize {
 		panicln("decrypt: wrong block size", c.blockSize, len(src), len(dst))
 	}
-	c.delta--;
+	c.delta--
 	for i, b := range src {
 		dst[i] = b + c.delta
 	}
 }
 
 func TestECBEncrypter(t *testing.T) {
-	var plain, crypt [256]byte;
+	var plain, crypt [256]byte
 	for i := 0; i < len(plain); i++ {
 		plain[i] = byte(i)
 	}
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for block := 1; block <= 64; block *= 2 {
 		// compute encrypted version
-		delta := byte(0);
+		delta := byte(0)
 		for i := 0; i < len(crypt); i++ {
 			if i%block == 0 {
 				delta++
 			}
-			crypt[i] = plain[i] + delta;
+			crypt[i] = plain[i] + delta
 		}
 
 		for frag := 0; frag < 2; frag++ {
-			c := &IncCipher{block, 0, true};
-			b.Reset();
-			r := bytes.NewBuffer(&plain);
-			w := NewECBEncrypter(c, b);
+			c := &IncCipher{block, 0, true}
+			b.Reset()
+			r := bytes.NewBuffer(&plain)
+			w := NewECBEncrypter(c, b)
 
 			// copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ...
 			// if frag != 0, move the 1 to the end to cause fragmentation.
 			if frag == 0 {
-				_, err := io.Copyn(w, r, 1);
+				_, err := io.Copyn(w, r, 1)
 				if err != nil {
-					t.Errorf("block=%d frag=0: first Copyn: %s", block, err);
-					continue;
+					t.Errorf("block=%d frag=0: first Copyn: %s", block, err)
+					continue
 				}
 			}
 			for n := 1; n <= len(plain)/2; n *= 2 {
-				_, err := io.Copyn(w, r, int64(n));
+				_, err := io.Copyn(w, r, int64(n))
 				if err != nil {
 					t.Errorf("block=%d frag=%d: Copyn %d: %s", block, frag, n, err)
 				}
 			}
 			if frag != 0 {
-				_, err := io.Copyn(w, r, 1);
+				_, err := io.Copyn(w, r, 1)
 				if err != nil {
-					t.Errorf("block=%d frag=1: last Copyn: %s", block, err);
-					continue;
+					t.Errorf("block=%d frag=1: last Copyn: %s", block, err)
+					continue
 				}
 			}
 
 			// check output
-			data := b.Bytes();
+			data := b.Bytes()
 			if len(data) != len(crypt) {
-				t.Errorf("block=%d frag=%d: want %d bytes, got %d", block, frag, len(crypt), len(data));
-				continue;
+				t.Errorf("block=%d frag=%d: want %d bytes, got %d", block, frag, len(crypt), len(data))
+				continue
 			}
 
 			if string(data) != string(&crypt) {
@@ -112,57 +112,57 @@ func testECBDecrypter(t *testing.T, maxio int) {
 		func(r io.Reader) io.Reader { return r },
 		iotest.OneByteReader,
 		iotest.HalfReader,
-	};
-	var plain, crypt [256]byte;
+	}
+	var plain, crypt [256]byte
 	for i := 0; i < len(plain); i++ {
 		plain[i] = byte(255 - i)
 	}
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for block := 1; block <= 64 && block <= maxio; block *= 2 {
 		// compute encrypted version
-		delta := byte(0);
+		delta := byte(0)
 		for i := 0; i < len(crypt); i++ {
 			if i%block == 0 {
 				delta++
 			}
-			crypt[i] = plain[i] + delta;
+			crypt[i] = plain[i] + delta
 		}
 
 		for mode := 0; mode < len(readers); mode++ {
 			for frag := 0; frag < 2; frag++ {
-				test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio);
-				c := &IncCipher{block, 0, false};
-				b.Reset();
-				r := NewECBDecrypter(c, readers[mode](bytes.NewBuffer(crypt[0:maxio])));
+				test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio)
+				c := &IncCipher{block, 0, false}
+				b.Reset()
+				r := NewECBDecrypter(c, readers[mode](bytes.NewBuffer(crypt[0:maxio])))
 
 				// read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ...
 				// if frag == 1, move the 1 to the end to cause fragmentation.
 				if frag == 0 {
-					_, err := io.Copyn(b, r, 1);
+					_, err := io.Copyn(b, r, 1)
 					if err != nil {
-						t.Errorf("%s: first Copyn: %s", test, err);
-						continue;
+						t.Errorf("%s: first Copyn: %s", test, err)
+						continue
 					}
 				}
 				for n := 1; n <= maxio/2; n *= 2 {
-					_, err := io.Copyn(b, r, int64(n));
+					_, err := io.Copyn(b, r, int64(n))
 					if err != nil {
 						t.Errorf("%s: Copyn %d: %s", test, n, err)
 					}
 				}
 				if frag != 0 {
-					_, err := io.Copyn(b, r, 1);
+					_, err := io.Copyn(b, r, 1)
 					if err != nil {
-						t.Errorf("%s: last Copyn: %s", test, err);
-						continue;
+						t.Errorf("%s: last Copyn: %s", test, err)
+						continue
 					}
 				}
 
 				// check output
-				data := b.Bytes();
+				data := b.Bytes()
 				if len(data) != maxio {
-					t.Errorf("%s: want %d bytes, got %d", test, maxio, len(data));
-					continue;
+					t.Errorf("%s: want %d bytes, got %d", test, maxio, len(data))
+					continue
 				}
 
 				if string(data) != string(plain[0:maxio]) {
diff --git a/src/pkg/crypto/block/ofb.go b/src/pkg/crypto/block/ofb.go
index c297541e3..bffdc53db 100644
--- a/src/pkg/crypto/block/ofb.go
+++ b/src/pkg/crypto/block/ofb.go
@@ -13,28 +13,28 @@
 package block
 
 import (
-	"io";
+	"io"
 )
 
 type ofbStream struct {
-	c	Cipher;
-	iv	[]byte;
+	c  Cipher
+	iv []byte
 }
 
 func newOFBStream(c Cipher, iv []byte) *ofbStream {
-	x := new(ofbStream);
-	x.c = c;
-	n := len(iv);
+	x := new(ofbStream)
+	x.c = c
+	n := len(iv)
 	if n != c.BlockSize() {
 		panicln("crypto/block: newOFBStream: invalid iv size", n, "!=", c.BlockSize())
 	}
-	x.iv = copy(iv);
-	return x;
+	x.iv = copy(iv)
+	return x
 }
 
 func (x *ofbStream) Next() []byte {
-	x.c.Encrypt(x.iv, x.iv);
-	return x.iv;
+	x.c.Encrypt(x.iv, x.iv)
+	return x.iv
 }
 
 // NewOFBReader returns a reader that reads data from r, decrypts (or encrypts)
diff --git a/src/pkg/crypto/block/ofb_aes_test.go b/src/pkg/crypto/block/ofb_aes_test.go
index 80af78fe4..f2faa4432 100644
--- a/src/pkg/crypto/block/ofb_aes_test.go
+++ b/src/pkg/crypto/block/ofb_aes_test.go
@@ -11,18 +11,18 @@
 package block
 
 import (
-	"bytes";
-	"crypto/aes";
-	"io";
-	"testing";
+	"bytes"
+	"crypto/aes"
+	"io"
+	"testing"
 )
 
 type ofbTest struct {
-	name	string;
-	key	[]byte;
-	iv	[]byte;
-	in	[]byte;
-	out	[]byte;
+	name string
+	key  []byte
+	iv   []byte
+	in   []byte
+	out  []byte
 }
 
 var ofbAESTests = []ofbTest{
@@ -67,20 +67,20 @@ var ofbAESTests = []ofbTest{
 
 func TestOFB_AES(t *testing.T) {
 	for _, tt := range ofbAESTests {
-		test := tt.name;
+		test := tt.name
 
-		c, err := aes.NewCipher(tt.key);
+		c, err := aes.NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err);
-			continue;
+			t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err)
+			continue
 		}
 
 		for j := 0; j <= 5; j += 5 {
-			var crypt bytes.Buffer;
-			in := tt.in[0 : len(tt.in)-j];
-			w := NewOFBWriter(c, tt.iv, &crypt);
-			var r io.Reader = bytes.NewBuffer(in);
-			n, err := io.Copy(w, r);
+			var crypt bytes.Buffer
+			in := tt.in[0 : len(tt.in)-j]
+			w := NewOFBWriter(c, tt.iv, &crypt)
+			var r io.Reader = bytes.NewBuffer(in)
+			n, err := io.Copy(w, r)
 			if n != int64(len(in)) || err != nil {
 				t.Errorf("%s/%d: OFBWriter io.Copy = %d, %v want %d, nil", test, len(in), n, err, len(in))
 			} else if d, out := crypt.Bytes(), tt.out[0:len(in)]; !same(out, d) {
@@ -89,11 +89,11 @@ func TestOFB_AES(t *testing.T) {
 		}
 
 		for j := 0; j <= 7; j += 7 {
-			var plain bytes.Buffer;
-			out := tt.out[0 : len(tt.out)-j];
-			r := NewOFBReader(c, tt.iv, bytes.NewBuffer(out));
-			w := &plain;
-			n, err := io.Copy(w, r);
+			var plain bytes.Buffer
+			out := tt.out[0 : len(tt.out)-j]
+			r := NewOFBReader(c, tt.iv, bytes.NewBuffer(out))
+			w := &plain
+			n, err := io.Copy(w, r)
 			if n != int64(len(out)) || err != nil {
 				t.Errorf("%s/%d: OFBReader io.Copy = %d, %v want %d, nil", test, len(out), n, err, len(out))
 			} else if d, in := plain.Bytes(), tt.in[0:len(out)]; !same(in, d) {
diff --git a/src/pkg/crypto/block/xor.go b/src/pkg/crypto/block/xor.go
index ffb76c5c4..9d8b17224 100644
--- a/src/pkg/crypto/block/xor.go
+++ b/src/pkg/crypto/block/xor.go
@@ -7,8 +7,8 @@
 package block
 
 import (
-	"io";
-	"os";
+	"io"
+	"os"
 )
 
 // A dataStream is an interface to an unending stream of data,
@@ -16,62 +16,62 @@ import (
 // Calls to Next() return sequential blocks of data from the stream.
 // Each call must return at least one byte: there is no EOF.
 type dataStream interface {
-	Next() []byte;
+	Next() []byte
 }
 
 type xorReader struct {
-	r	io.Reader;
-	rand	dataStream;	// pseudo-random
-	buf	[]byte;		// data available from last call to rand
+	r    io.Reader
+	rand dataStream // pseudo-random
+	buf  []byte     // data available from last call to rand
 }
 
 func newXorReader(rand dataStream, r io.Reader) io.Reader {
-	x := new(xorReader);
-	x.r = r;
-	x.rand = rand;
-	return x;
+	x := new(xorReader)
+	x.r = r
+	x.rand = rand
+	return x
 }
 
 func (x *xorReader) Read(p []byte) (n int, err os.Error) {
-	n, err = x.r.Read(p);
+	n, err = x.r.Read(p)
 
 	// xor input with stream.
-	bp := 0;
-	buf := x.buf;
+	bp := 0
+	buf := x.buf
 	for i := 0; i < n; i++ {
 		if bp >= len(buf) {
-			buf = x.rand.Next();
-			bp = 0;
+			buf = x.rand.Next()
+			bp = 0
 		}
-		p[i] ^= buf[bp];
-		bp++;
+		p[i] ^= buf[bp]
+		bp++
 	}
-	x.buf = buf[bp:];
-	return n, err;
+	x.buf = buf[bp:]
+	return n, err
 }
 
 type xorWriter struct {
-	w	io.Writer;
-	rand	dataStream;	// pseudo-random
-	buf	[]byte;		// last buffer returned by rand
-	extra	[]byte;		// extra random data (use before buf)
-	work	[]byte;		// work space
+	w     io.Writer
+	rand  dataStream // pseudo-random
+	buf   []byte     // last buffer returned by rand
+	extra []byte     // extra random data (use before buf)
+	work  []byte     // work space
 }
 
 func newXorWriter(rand dataStream, w io.Writer) io.Writer {
-	x := new(xorWriter);
-	x.w = w;
-	x.rand = rand;
-	x.work = make([]byte, 4096);
-	return x;
+	x := new(xorWriter)
+	x.w = w
+	x.rand = rand
+	x.work = make([]byte, 4096)
+	return x
 }
 
 func (x *xorWriter) Write(p []byte) (n int, err os.Error) {
 	for len(p) > 0 {
 		// Determine next chunk of random data
 		// and xor with p into x.work.
-		var chunk []byte;
-		m := len(p);
+		var chunk []byte
+		m := len(p)
 		if nn := len(x.extra); nn > 0 {
 			// extra points into work, so edit directly
 			if m > nn {
@@ -80,29 +80,29 @@ func (x *xorWriter) Write(p []byte) (n int, err os.Error) {
 			for i := 0; i < m; i++ {
 				x.extra[i] ^= p[i]
 			}
-			chunk = x.extra[0:m];
+			chunk = x.extra[0:m]
 		} else {
 			// xor p ^ buf into work, refreshing buf as needed
 			if nn := len(x.work); m > nn {
 				m = nn
 			}
-			bp := 0;
-			buf := x.buf;
+			bp := 0
+			buf := x.buf
 			for i := 0; i < m; i++ {
 				if bp >= len(buf) {
-					buf = x.rand.Next();
-					bp = 0;
+					buf = x.rand.Next()
+					bp = 0
 				}
-				x.work[i] = buf[bp] ^ p[i];
-				bp++;
+				x.work[i] = buf[bp] ^ p[i]
+				bp++
 			}
-			x.buf = buf[bp:];
-			chunk = x.work[0:m];
+			x.buf = buf[bp:]
+			chunk = x.work[0:m]
 		}
 
 		// Write chunk.
-		var nn int;
-		nn, err = x.w.Write(chunk);
+		var nn int
+		nn, err = x.w.Write(chunk)
 		if nn != len(chunk) && err == nil {
 			err = io.ErrShortWrite
 		}
@@ -112,13 +112,13 @@ func (x *xorWriter) Write(p []byte) (n int, err os.Error) {
 			for i := nn; i < m; i++ {
 				chunk[i] ^= p[i]
 			}
-			x.extra = chunk[nn:];
+			x.extra = chunk[nn:]
 		}
-		n += nn;
+		n += nn
 		if err != nil {
 			return
 		}
-		p = p[m:];
+		p = p[m:]
 	}
-	return;
+	return
 }
diff --git a/src/pkg/crypto/block/xor_test.go b/src/pkg/crypto/block/xor_test.go
index 1815be3fc..87b493a40 100644
--- a/src/pkg/crypto/block/xor_test.go
+++ b/src/pkg/crypto/block/xor_test.go
@@ -5,80 +5,80 @@
 package block
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"fmt"
+	"io"
+	"testing"
+	"testing/iotest"
 )
 
 // Simple "pseudo-random" stream for testing.
 type incStream struct {
-	buf	[]byte;
-	n	byte;
+	buf []byte
+	n   byte
 }
 
 func newIncStream(blockSize int) *incStream {
-	x := new(incStream);
-	x.buf = make([]byte, blockSize);
-	return x;
+	x := new(incStream)
+	x.buf = make([]byte, blockSize)
+	return x
 }
 
 func (x *incStream) Next() []byte {
-	x.n++;
+	x.n++
 	for i := range x.buf {
-		x.buf[i] = x.n;
-		x.n++;
+		x.buf[i] = x.n
+		x.n++
 	}
-	return x.buf;
+	return x.buf
 }
 
 func testXorWriter(t *testing.T, maxio int) {
-	var plain, crypt [256]byte;
+	var plain, crypt [256]byte
 	for i := 0; i < len(plain); i++ {
 		plain[i] = byte(i)
 	}
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for block := 1; block <= 64 && block <= maxio; block *= 2 {
 		// compute encrypted version
-		n := byte(0);
+		n := byte(0)
 		for i := 0; i < len(crypt); i++ {
 			if i%block == 0 {
 				n++
 			}
-			crypt[i] = plain[i] ^ n;
-			n++;
+			crypt[i] = plain[i] ^ n
+			n++
 		}
 
 		for frag := 0; frag < 2; frag++ {
-			test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio);
-			b.Reset();
-			r := bytes.NewBuffer(&plain);
-			s := newIncStream(block);
-			w := newXorWriter(s, b);
+			test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio)
+			b.Reset()
+			r := bytes.NewBuffer(&plain)
+			s := newIncStream(block)
+			w := newXorWriter(s, b)
 
 			// copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ...
 			// if frag != 0, move the 1 to the end to cause fragmentation.
 			if frag == 0 {
-				_, err := io.Copyn(w, r, 1);
+				_, err := io.Copyn(w, r, 1)
 				if err != nil {
-					t.Errorf("%s: first Copyn: %s", test, err);
-					continue;
+					t.Errorf("%s: first Copyn: %s", test, err)
+					continue
 				}
 			}
 			for n := 1; n <= len(plain)/2; n *= 2 {
-				_, err := io.Copyn(w, r, int64(n));
+				_, err := io.Copyn(w, r, int64(n))
 				if err != nil {
 					t.Errorf("%s: Copyn %d: %s", test, n, err)
 				}
 			}
 
 			// check output
-			crypt := crypt[0 : len(crypt)-frag];
-			data := b.Bytes();
+			crypt := crypt[0 : len(crypt)-frag]
+			data := b.Bytes()
 			if len(data) != len(crypt) {
-				t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data));
-				continue;
+				t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data))
+				continue
 			}
 
 			if string(data) != string(crypt) {
@@ -101,53 +101,53 @@ func testXorReader(t *testing.T, maxio int) {
 		func(r io.Reader) io.Reader { return r },
 		iotest.OneByteReader,
 		iotest.HalfReader,
-	};
-	var plain, crypt [256]byte;
+	}
+	var plain, crypt [256]byte
 	for i := 0; i < len(plain); i++ {
 		plain[i] = byte(255 - i)
 	}
-	b := new(bytes.Buffer);
+	b := new(bytes.Buffer)
 	for block := 1; block <= 64 && block <= maxio; block *= 2 {
 		// compute encrypted version
-		n := byte(0);
+		n := byte(0)
 		for i := 0; i < len(crypt); i++ {
 			if i%block == 0 {
 				n++
 			}
-			crypt[i] = plain[i] ^ n;
-			n++;
+			crypt[i] = plain[i] ^ n
+			n++
 		}
 
 		for mode := 0; mode < len(readers); mode++ {
 			for frag := 0; frag < 2; frag++ {
-				test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio);
-				s := newIncStream(block);
-				b.Reset();
-				r := newXorReader(s, readers[mode](bytes.NewBuffer(crypt[0:maxio])));
+				test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio)
+				s := newIncStream(block)
+				b.Reset()
+				r := newXorReader(s, readers[mode](bytes.NewBuffer(crypt[0:maxio])))
 
 				// read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ...
 				// if frag == 1, move the 1 to the end to cause fragmentation.
 				if frag == 0 {
-					_, err := io.Copyn(b, r, 1);
+					_, err := io.Copyn(b, r, 1)
 					if err != nil {
-						t.Errorf("%s: first Copyn: %s", test, err);
-						continue;
+						t.Errorf("%s: first Copyn: %s", test, err)
+						continue
 					}
 				}
 				for n := 1; n <= maxio/2; n *= 2 {
-					_, err := io.Copyn(b, r, int64(n));
+					_, err := io.Copyn(b, r, int64(n))
 					if err != nil {
 						t.Errorf("%s: Copyn %d: %s", test, n, err)
 					}
 				}
 
 				// check output
-				data := b.Bytes();
-				crypt := crypt[0 : maxio-frag];
-				plain := plain[0 : maxio-frag];
+				data := b.Bytes()
+				crypt := crypt[0 : maxio-frag]
+				plain := plain[0 : maxio-frag]
 				if len(data) != len(plain) {
-					t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data));
-					continue;
+					t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data))
+					continue
 				}
 
 				if string(data) != string(plain) {
diff --git a/src/pkg/crypto/hmac/hmac.go b/src/pkg/crypto/hmac/hmac.go
index 8a9a4cbb5..38d13738d 100644
--- a/src/pkg/crypto/hmac/hmac.go
+++ b/src/pkg/crypto/hmac/hmac.go
@@ -9,10 +9,10 @@
 package hmac
 
 import (
-	"crypto/md5";
-	"crypto/sha1";
-	"hash";
-	"os";
+	"crypto/md5"
+	"crypto/sha1"
+	"hash"
+	"os"
 )
 
 // FIPS 198:
@@ -30,14 +30,14 @@ const (
 	// MD5 and SHA1, and both use 64-byte blocks.
 	// The hash.Hash interface doesn't provide a
 	// way to find out the block size.
-	padSize = 64;
+	padSize = 64
 )
 
 type hmac struct {
-	size	int;
-	key	[]byte;
-	tmp	[]byte;
-	inner	hash.Hash;
+	size  int
+	key   []byte
+	tmp   []byte
+	inner hash.Hash
 }
 
 func (h *hmac) tmpPad(xor byte) {
@@ -50,49 +50,49 @@ func (h *hmac) tmpPad(xor byte) {
 }
 
 func (h *hmac) Sum() []byte {
-	h.tmpPad(0x5c);
-	sum := h.inner.Sum();
+	h.tmpPad(0x5c)
+	sum := h.inner.Sum()
 	for i, b := range sum {
 		h.tmp[padSize+i] = b
 	}
-	h.inner.Reset();
-	h.inner.Write(h.tmp);
-	return h.inner.Sum();
+	h.inner.Reset()
+	h.inner.Write(h.tmp)
+	return h.inner.Sum()
 }
 
 func (h *hmac) Write(p []byte) (n int, err os.Error) {
 	return h.inner.Write(p)
 }
 
-func (h *hmac) Size() int	{ return h.size }
+func (h *hmac) Size() int { return h.size }
 
 func (h *hmac) Reset() {
-	h.inner.Reset();
-	h.tmpPad(0x36);
-	h.inner.Write(h.tmp[0:padSize]);
+	h.inner.Reset()
+	h.tmpPad(0x36)
+	h.inner.Write(h.tmp[0:padSize])
 }
 
 // New returns a new HMAC hash using the given hash and key.
 func New(h hash.Hash, key []byte) hash.Hash {
 	if len(key) > padSize {
 		// If key is too big, hash it.
-		h.Write(key);
-		key = h.Sum();
+		h.Write(key)
+		key = h.Sum()
 	}
-	hm := new(hmac);
-	hm.inner = h;
-	hm.size = h.Size();
-	hm.key = make([]byte, len(key));
+	hm := new(hmac)
+	hm.inner = h
+	hm.size = h.Size()
+	hm.key = make([]byte, len(key))
 	for i, k := range key {
 		hm.key[i] = k
 	}
-	hm.tmp = make([]byte, padSize+hm.size);
-	hm.Reset();
-	return hm;
+	hm.tmp = make([]byte, padSize+hm.size)
+	hm.Reset()
+	return hm
 }
 
 // NewMD5 returns a new HMAC-MD5 hash using the given key.
-func NewMD5(key []byte) hash.Hash	{ return New(md5.New(), key) }
+func NewMD5(key []byte) hash.Hash { return New(md5.New(), key) }
 
 // NewSHA1 returns a new HMAC-SHA1 hash using the given key.
-func NewSHA1(key []byte) hash.Hash	{ return New(sha1.New(), key) }
+func NewSHA1(key []byte) hash.Hash { return New(sha1.New(), key) }
diff --git a/src/pkg/crypto/hmac/hmac_test.go b/src/pkg/crypto/hmac/hmac_test.go
index 1c81fd990..98e32df01 100644
--- a/src/pkg/crypto/hmac/hmac_test.go
+++ b/src/pkg/crypto/hmac/hmac_test.go
@@ -5,17 +5,17 @@
 package hmac
 
 import (
-	"hash";
-	"fmt";
-	"strings";
-	"testing";
+	"hash"
+	"fmt"
+	"strings"
+	"testing"
 )
 
 type hmacTest struct {
-	hash	func([]byte) hash.Hash;
-	key	[]byte;
-	in	[]byte;
-	out	string;
+	hash func([]byte) hash.Hash
+	key  []byte
+	in   []byte
+	out  string
 }
 
 // Tests from US FIPS 198
@@ -78,20 +78,20 @@ var hmacTests = []hmacTest{
 
 func TestHMAC(t *testing.T) {
 	for i, tt := range hmacTests {
-		h := tt.hash(tt.key);
+		h := tt.hash(tt.key)
 		for j := 0; j < 2; j++ {
-			n, err := h.Write(tt.in);
+			n, err := h.Write(tt.in)
 			if n != len(tt.in) || err != nil {
-				t.Errorf("test %d.%d: Write(%d) = %d, %v", i, j, len(tt.in), n, err);
-				continue;
+				t.Errorf("test %d.%d: Write(%d) = %d, %v", i, j, len(tt.in), n, err)
+				continue
 			}
-			sum := fmt.Sprintf("%x", h.Sum());
+			sum := fmt.Sprintf("%x", h.Sum())
 			if sum != tt.out {
 				t.Errorf("test %d.%d: have %s want %s\n", i, j, sum, tt.out)
 			}
 
 			// Second iteration: make sure reset works.
-			h.Reset();
+			h.Reset()
 		}
 	}
 }
diff --git a/src/pkg/crypto/md4/md4.go b/src/pkg/crypto/md4/md4.go
index 8efb74e47..650fce313 100644
--- a/src/pkg/crypto/md4/md4.go
+++ b/src/pkg/crypto/md4/md4.go
@@ -6,81 +6,81 @@
 package md4
 
 import (
-	"hash";
-	"os";
+	"hash"
+	"os"
 )
 
 // The size of an MD4 checksum in bytes.
 const Size = 16
 
 const (
-	_Chunk	= 64;
-	_Init0	= 0x67452301;
-	_Init1	= 0xEFCDAB89;
-	_Init2	= 0x98BADCFE;
-	_Init3	= 0x10325476;
+	_Chunk = 64
+	_Init0 = 0x67452301
+	_Init1 = 0xEFCDAB89
+	_Init2 = 0x98BADCFE
+	_Init3 = 0x10325476
 )
 
 // digest represents the partial evaluation of a checksum.
 type digest struct {
-	s	[4]uint32;
-	x	[_Chunk]byte;
-	nx	int;
-	len	uint64;
+	s   [4]uint32
+	x   [_Chunk]byte
+	nx  int
+	len uint64
 }
 
 func (d *digest) Reset() {
-	d.s[0] = _Init0;
-	d.s[1] = _Init1;
-	d.s[2] = _Init2;
-	d.s[3] = _Init3;
-	d.nx = 0;
-	d.len = 0;
+	d.s[0] = _Init0
+	d.s[1] = _Init1
+	d.s[2] = _Init2
+	d.s[3] = _Init3
+	d.nx = 0
+	d.len = 0
 }
 
 // New returns a new hash.Hash computing the MD4 checksum.
 func New() hash.Hash {
-	d := new(digest);
-	d.Reset();
-	return d;
+	d := new(digest)
+	d.Reset()
+	return d
 }
 
-func (d *digest) Size() int	{ return Size }
+func (d *digest) Size() int { return Size }
 
 func (d *digest) Write(p []byte) (nn int, err os.Error) {
-	nn = len(p);
-	d.len += uint64(nn);
+	nn = len(p)
+	d.len += uint64(nn)
 	if d.nx > 0 {
-		n := len(p);
+		n := len(p)
 		if n > _Chunk-d.nx {
 			n = _Chunk - d.nx
 		}
 		for i := 0; i < n; i++ {
 			d.x[d.nx+i] = p[i]
 		}
-		d.nx += n;
+		d.nx += n
 		if d.nx == _Chunk {
-			_Block(d, &d.x);
-			d.nx = 0;
+			_Block(d, &d.x)
+			d.nx = 0
 		}
-		p = p[n:];
+		p = p[n:]
 	}
-	n := _Block(d, p);
-	p = p[n:];
+	n := _Block(d, p)
+	p = p[n:]
 	if len(p) > 0 {
 		for i := 0; i < len(p); i++ {
 			d.x[i] = p[i]
 		}
-		d.nx = len(p);
+		d.nx = len(p)
 	}
-	return;
+	return
 }
 
 func (d *digest) Sum() []byte {
 	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
-	len := d.len;
-	var tmp [64]byte;
-	tmp[0] = 0x80;
+	len := d.len
+	var tmp [64]byte
+	tmp[0] = 0x80
 	if len%64 < 56 {
 		d.Write(tmp[0 : 56-len%64])
 	} else {
@@ -88,28 +88,28 @@ func (d *digest) Sum() []byte {
 	}
 
 	// Length in bits.
-	len <<= 3;
+	len <<= 3
 	for i := uint(0); i < 8; i++ {
 		tmp[i] = byte(len >> (8 * i))
 	}
-	d.Write(tmp[0:8]);
+	d.Write(tmp[0:8])
 
 	if d.nx != 0 {
 		panicln("oops")
 	}
 
-	p := make([]byte, 16);
-	j := 0;
+	p := make([]byte, 16)
+	j := 0
 	for i := 0; i < 4; i++ {
-		s := d.s[i];
-		p[j] = byte(s);
-		j++;
-		p[j] = byte(s >> 8);
-		j++;
-		p[j] = byte(s >> 16);
-		j++;
-		p[j] = byte(s >> 24);
-		j++;
+		s := d.s[i]
+		p[j] = byte(s)
+		j++
+		p[j] = byte(s >> 8)
+		j++
+		p[j] = byte(s >> 16)
+		j++
+		p[j] = byte(s >> 24)
+		j++
 	}
-	return p;
+	return p
 }
diff --git a/src/pkg/crypto/md4/md4_test.go b/src/pkg/crypto/md4/md4_test.go
index 31aa67527..9cab80c63 100644
--- a/src/pkg/crypto/md4/md4_test.go
+++ b/src/pkg/crypto/md4/md4_test.go
@@ -5,14 +5,14 @@
 package md4
 
 import (
-	"fmt";
-	"io";
-	"testing";
+	"fmt"
+	"io"
+	"testing"
 )
 
 type md4Test struct {
-	out	string;
-	in	string;
+	out string
+	in  string
 }
 
 var golden = []md4Test{
@@ -51,16 +51,16 @@ var golden = []md4Test{
 
 func TestGolden(t *testing.T) {
 	for i := 0; i < len(golden); i++ {
-		g := golden[i];
-		c := New();
+		g := golden[i]
+		c := New()
 		for j := 0; j < 2; j++ {
-			io.WriteString(c, g.in);
-			s := fmt.Sprintf("%x", c.Sum());
+			io.WriteString(c, g.in)
+			s := fmt.Sprintf("%x", c.Sum())
 			if s != g.out {
-				t.Errorf("md4[%d](%s) = %s want %s", j, g.in, s, g.out);
-				t.FailNow();
+				t.Errorf("md4[%d](%s) = %s want %s", j, g.in, s, g.out)
+				t.FailNow()
 			}
-			c.Reset();
+			c.Reset()
 		}
 	}
 }
diff --git a/src/pkg/crypto/md4/md4block.go b/src/pkg/crypto/md4/md4block.go
index 6f2c2d5a2..492e960ca 100644
--- a/src/pkg/crypto/md4/md4block.go
+++ b/src/pkg/crypto/md4/md4block.go
@@ -16,18 +16,18 @@ var xIndex2 = []uint{0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15}
 var xIndex3 = []uint{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15}
 
 func _Block(dig *digest, p []byte) int {
-	a := dig.s[0];
-	b := dig.s[1];
-	c := dig.s[2];
-	d := dig.s[3];
-	n := 0;
-	var X [16]uint32;
+	a := dig.s[0]
+	b := dig.s[1]
+	c := dig.s[2]
+	d := dig.s[3]
+	n := 0
+	var X [16]uint32
 	for len(p) >= _Chunk {
-		aa, bb, cc, dd := a, b, c, d;
+		aa, bb, cc, dd := a, b, c, d
 
 		for i := 0; i < 16; i++ {
-			j := i * 4;
-			X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24;
+			j := i * 4
+			X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
 		}
 
 		// If this needs to be made faster in the future,
@@ -40,46 +40,46 @@ func _Block(dig *digest, p []byte) int {
 
 		// Round 1.
 		for i := 0; i < 16; i++ {
-			x := i;
-			s := shift1[i%4];
-			f := ((c ^ d) & b) ^ d;
-			a += f + X[x];
-			a = a<<s | a>>(32-s);
-			a, b, c, d = d, a, b, c;
+			x := i
+			s := shift1[i%4]
+			f := ((c ^ d) & b) ^ d
+			a += f + X[x]
+			a = a<<s | a>>(32-s)
+			a, b, c, d = d, a, b, c
 		}
 
 		// Round 2.
 		for i := 0; i < 16; i++ {
-			x := xIndex2[i];
-			s := shift2[i%4];
-			g := (b & c) | (b & d) | (c & d);
-			a += g + X[x] + 0x5a827999;
-			a = a<<s | a>>(32-s);
-			a, b, c, d = d, a, b, c;
+			x := xIndex2[i]
+			s := shift2[i%4]
+			g := (b & c) | (b & d) | (c & d)
+			a += g + X[x] + 0x5a827999
+			a = a<<s | a>>(32-s)
+			a, b, c, d = d, a, b, c
 		}
 
 		// Round 3.
 		for i := 0; i < 16; i++ {
-			x := xIndex3[i];
-			s := shift3[i%4];
-			h := b ^ c ^ d;
-			a += h + X[x] + 0x6ed9eba1;
-			a = a<<s | a>>(32-s);
-			a, b, c, d = d, a, b, c;
+			x := xIndex3[i]
+			s := shift3[i%4]
+			h := b ^ c ^ d
+			a += h + X[x] + 0x6ed9eba1
+			a = a<<s | a>>(32-s)
+			a, b, c, d = d, a, b, c
 		}
 
-		a += aa;
-		b += bb;
-		c += cc;
-		d += dd;
+		a += aa
+		b += bb
+		c += cc
+		d += dd
 
-		p = p[_Chunk:];
-		n += _Chunk;
+		p = p[_Chunk:]
+		n += _Chunk
 	}
 
-	dig.s[0] = a;
-	dig.s[1] = b;
-	dig.s[2] = c;
-	dig.s[3] = d;
-	return n;
+	dig.s[0] = a
+	dig.s[1] = b
+	dig.s[2] = c
+	dig.s[3] = d
+	return n
 }
diff --git a/src/pkg/crypto/md5/md5.go b/src/pkg/crypto/md5/md5.go
index 375288691..2ee57f421 100644
--- a/src/pkg/crypto/md5/md5.go
+++ b/src/pkg/crypto/md5/md5.go
@@ -6,81 +6,81 @@
 package md5
 
 import (
-	"hash";
-	"os";
+	"hash"
+	"os"
 )
 
 // The size of an MD5 checksum in bytes.
 const Size = 16
 
 const (
-	_Chunk	= 64;
-	_Init0	= 0x67452301;
-	_Init1	= 0xEFCDAB89;
-	_Init2	= 0x98BADCFE;
-	_Init3	= 0x10325476;
+	_Chunk = 64
+	_Init0 = 0x67452301
+	_Init1 = 0xEFCDAB89
+	_Init2 = 0x98BADCFE
+	_Init3 = 0x10325476
 )
 
 // digest represents the partial evaluation of a checksum.
 type digest struct {
-	s	[4]uint32;
-	x	[_Chunk]byte;
-	nx	int;
-	len	uint64;
+	s   [4]uint32
+	x   [_Chunk]byte
+	nx  int
+	len uint64
 }
 
 func (d *digest) Reset() {
-	d.s[0] = _Init0;
-	d.s[1] = _Init1;
-	d.s[2] = _Init2;
-	d.s[3] = _Init3;
-	d.nx = 0;
-	d.len = 0;
+	d.s[0] = _Init0
+	d.s[1] = _Init1
+	d.s[2] = _Init2
+	d.s[3] = _Init3
+	d.nx = 0
+	d.len = 0
 }
 
 // New returns a new hash.Hash computing the MD5 checksum.
 func New() hash.Hash {
-	d := new(digest);
-	d.Reset();
-	return d;
+	d := new(digest)
+	d.Reset()
+	return d
 }
 
-func (d *digest) Size() int	{ return Size }
+func (d *digest) Size() int { return Size }
 
 func (d *digest) Write(p []byte) (nn int, err os.Error) {
-	nn = len(p);
-	d.len += uint64(nn);
+	nn = len(p)
+	d.len += uint64(nn)
 	if d.nx > 0 {
-		n := len(p);
+		n := len(p)
 		if n > _Chunk-d.nx {
 			n = _Chunk - d.nx
 		}
 		for i := 0; i < n; i++ {
 			d.x[d.nx+i] = p[i]
 		}
-		d.nx += n;
+		d.nx += n
 		if d.nx == _Chunk {
-			_Block(d, &d.x);
-			d.nx = 0;
+			_Block(d, &d.x)
+			d.nx = 0
 		}
-		p = p[n:];
+		p = p[n:]
 	}
-	n := _Block(d, p);
-	p = p[n:];
+	n := _Block(d, p)
+	p = p[n:]
 	if len(p) > 0 {
 		for i := 0; i < len(p); i++ {
 			d.x[i] = p[i]
 		}
-		d.nx = len(p);
+		d.nx = len(p)
 	}
-	return;
+	return
 }
 
 func (d *digest) Sum() []byte {
 	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
-	len := d.len;
-	var tmp [64]byte;
-	tmp[0] = 0x80;
+	len := d.len
+	var tmp [64]byte
+	tmp[0] = 0x80
 	if len%64 < 56 {
 		d.Write(tmp[0 : 56-len%64])
 	} else {
@@ -88,28 +88,28 @@ func (d *digest) Sum() []byte {
 	}
 
 	// Length in bits.
-	len <<= 3;
+	len <<= 3
 	for i := uint(0); i < 8; i++ {
 		tmp[i] = byte(len >> (8 * i))
 	}
-	d.Write(tmp[0:8]);
+	d.Write(tmp[0:8])
 
 	if d.nx != 0 {
 		panicln("oops")
 	}
 
-	p := make([]byte, 16);
-	j := 0;
+	p := make([]byte, 16)
+	j := 0
 	for i := 0; i < 4; i++ {
-		s := d.s[i];
-		p[j] = byte(s);
-		j++;
-		p[j] = byte(s >> 8);
-		j++;
-		p[j] = byte(s >> 16);
-		j++;
-		p[j] = byte(s >> 24);
-		j++;
+		s := d.s[i]
+		p[j] = byte(s)
+		j++
+		p[j] = byte(s >> 8)
+		j++
+		p[j] = byte(s >> 16)
+		j++
+		p[j] = byte(s >> 24)
+		j++
 	}
-	return p;
+	return p
 }
diff --git a/src/pkg/crypto/md5/md5_test.go b/src/pkg/crypto/md5/md5_test.go
index 51fd5a53a..7d5737b26 100644
--- a/src/pkg/crypto/md5/md5_test.go
+++ b/src/pkg/crypto/md5/md5_test.go
@@ -5,14 +5,14 @@
 package md5
 
 import (
-	"fmt";
-	"io";
-	"testing";
+	"fmt"
+	"io"
+	"testing"
 )
 
 type md5Test struct {
-	out	string;
-	in	string;
+	out string
+	in  string
 }
 
 var golden = []md5Test{
@@ -51,16 +51,16 @@ var golden = []md5Test{
 
 func TestGolden(t *testing.T) {
 	for i := 0; i < len(golden); i++ {
-		g := golden[i];
-		c := New();
+		g := golden[i]
+		c := New()
 		for j := 0; j < 2; j++ {
-			io.WriteString(c, g.in);
-			s := fmt.Sprintf("%x", c.Sum());
+			io.WriteString(c, g.in)
+			s := fmt.Sprintf("%x", c.Sum())
 			if s != g.out {
-				t.Errorf("md5[%d](%s) = %s want %s", j, g.in, s, g.out);
-				t.FailNow();
+				t.Errorf("md5[%d](%s) = %s want %s", j, g.in, s, g.out)
+				t.FailNow()
 			}
-			c.Reset();
+			c.Reset()
 		}
 	}
 }
diff --git a/src/pkg/crypto/md5/md5block.go b/src/pkg/crypto/md5/md5block.go
index 4421acf8e..f35096d50 100644
--- a/src/pkg/crypto/md5/md5block.go
+++ b/src/pkg/crypto/md5/md5block.go
@@ -89,18 +89,18 @@ var shift3 = []uint{4, 11, 16, 23}
 var shift4 = []uint{6, 10, 15, 21}
 
 func _Block(dig *digest, p []byte) int {
-	a := dig.s[0];
-	b := dig.s[1];
-	c := dig.s[2];
-	d := dig.s[3];
-	n := 0;
-	var X [16]uint32;
+	a := dig.s[0]
+	b := dig.s[1]
+	c := dig.s[2]
+	d := dig.s[3]
+	n := 0
+	var X [16]uint32
 	for len(p) >= _Chunk {
-		aa, bb, cc, dd := a, b, c, d;
+		aa, bb, cc, dd := a, b, c, d
 
 		for i := 0; i < 16; i++ {
-			j := i * 4;
-			X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24;
+			j := i * 4
+			X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
 		}
 
 		// If this needs to be made faster in the future,
@@ -113,64 +113,64 @@ func _Block(dig *digest, p []byte) int {
 
 		// Round 1.
 		for i := 0; i < 16; i++ {
-			x := i;
-			t := i;
-			s := shift1[i%4];
-			f := ((c ^ d) & b) ^ d;
-			a += f + X[x] + table[t];
-			a = a<<s | a>>(32-s);
-			a += b;
-			a, b, c, d = d, a, b, c;
+			x := i
+			t := i
+			s := shift1[i%4]
+			f := ((c ^ d) & b) ^ d
+			a += f + X[x] + table[t]
+			a = a<<s | a>>(32-s)
+			a += b
+			a, b, c, d = d, a, b, c
 		}
 
 		// Round 2.
 		for i := 0; i < 16; i++ {
-			x := (1 + 5*i) % 16;
-			t := 16 + i;
-			s := shift2[i%4];
-			g := ((b ^ c) & d) ^ c;
-			a += g + X[x] + table[t];
-			a = a<<s | a>>(32-s);
-			a += b;
-			a, b, c, d = d, a, b, c;
+			x := (1 + 5*i) % 16
+			t := 16 + i
+			s := shift2[i%4]
+			g := ((b ^ c) & d) ^ c
+			a += g + X[x] + table[t]
+			a = a<<s | a>>(32-s)
+			a += b
+			a, b, c, d = d, a, b, c
 		}
 
 		// Round 3.
 		for i := 0; i < 16; i++ {
-			x := (5 + 3*i) % 16;
-			t := 32 + i;
-			s := shift3[i%4];
-			h := b ^ c ^ d;
-			a += h + X[x] + table[t];
-			a = a<<s | a>>(32-s);
-			a += b;
-			a, b, c, d = d, a, b, c;
+			x := (5 + 3*i) % 16
+			t := 32 + i
+			s := shift3[i%4]
+			h := b ^ c ^ d
+			a += h + X[x] + table[t]
+			a = a<<s | a>>(32-s)
+			a += b
+			a, b, c, d = d, a, b, c
 		}
 
 		// Round 4.
 		for i := 0; i < 16; i++ {
-			x := (7 * i) % 16;
-			s := shift4[i%4];
-			t := 48 + i;
-			ii := c ^ (b | ^d);
-			a += ii + X[x] + table[t];
-			a = a<<s | a>>(32-s);
-			a += b;
-			a, b, c, d = d, a, b, c;
+			x := (7 * i) % 16
+			s := shift4[i%4]
+			t := 48 + i
+			ii := c ^ (b | ^d)
+			a += ii + X[x] + table[t]
+			a = a<<s | a>>(32-s)
+			a += b
+			a, b, c, d = d, a, b, c
 		}
 
-		a += aa;
-		b += bb;
-		c += cc;
-		d += dd;
+		a += aa
+		b += bb
+		c += cc
+		d += dd
 
-		p = p[_Chunk:];
-		n += _Chunk;
+		p = p[_Chunk:]
+		n += _Chunk
 	}
 
-	dig.s[0] = a;
-	dig.s[1] = b;
-	dig.s[2] = c;
-	dig.s[3] = d;
-	return n;
+	dig.s[0] = a
+	dig.s[1] = b
+	dig.s[2] = c
+	dig.s[3] = d
+	return n
 }
diff --git a/src/pkg/crypto/rc4/rc4.go b/src/pkg/crypto/rc4/rc4.go
index d965f827b..e47a01513 100644
--- a/src/pkg/crypto/rc4/rc4.go
+++ b/src/pkg/crypto/rc4/rc4.go
@@ -10,14 +10,14 @@ package rc4
 // it a poor choice for new protocols.
 
 import (
-	"os";
-	"strconv";
+	"os"
+	"strconv"
 )
 
 // A Cipher is an instance of RC4 using a particular key.
 type Cipher struct {
-	s	[256]byte;
-	i, j	uint8;
+	s    [256]byte
+	i, j uint8
 }
 
 type KeySizeError int
@@ -29,30 +29,30 @@ func (k KeySizeError) String() string {
 // NewCipher creates and returns a new Cipher.  The key argument should be the
 // RC4 key, at least 1 byte and at most 256 bytes.
 func NewCipher(key []byte) (*Cipher, os.Error) {
-	k := len(key);
+	k := len(key)
 	if k < 1 || k > 256 {
 		return nil, KeySizeError(k)
 	}
-	var c Cipher;
+	var c Cipher
 	for i := 0; i < 256; i++ {
 		c.s[i] = uint8(i)
 	}
-	var j uint8 = 0;
+	var j uint8 = 0
 	for i := 0; i < 256; i++ {
-		j += c.s[i] + key[i%k];
-		c.s[i], c.s[j] = c.s[j], c.s[i];
+		j += c.s[i] + key[i%k]
+		c.s[i], c.s[j] = c.s[j], c.s[i]
 	}
-	return &c, nil;
+	return &c, nil
 }
 
 // XORKeyStream will XOR each byte of the given buffer with a byte of the
 // generated keystream.
 func (c *Cipher) XORKeyStream(buf []byte) {
 	for i := range buf {
-		c.i += 1;
-		c.j += c.s[c.i];
-		c.s[c.i], c.s[c.j] = c.s[c.j], c.s[c.i];
-		buf[i] ^= c.s[c.s[c.i]+c.s[c.j]];
+		c.i += 1
+		c.j += c.s[c.i]
+		c.s[c.i], c.s[c.j] = c.s[c.j], c.s[c.i]
+		buf[i] ^= c.s[c.s[c.i]+c.s[c.j]]
 	}
 }
 
@@ -62,5 +62,5 @@ func (c *Cipher) Reset() {
 	for i := range c.s {
 		c.s[i] = 0
 	}
-	c.i, c.j = 0, 0;
+	c.i, c.j = 0, 0
 }
diff --git a/src/pkg/crypto/rc4/rc4_test.go b/src/pkg/crypto/rc4/rc4_test.go
index e0ca4a4ae..1d39b2f17 100644
--- a/src/pkg/crypto/rc4/rc4_test.go
+++ b/src/pkg/crypto/rc4/rc4_test.go
@@ -5,11 +5,11 @@
 package rc4
 
 import (
-	"testing";
+	"testing"
 )
 
 type rc4Test struct {
-	key, keystream []byte;
+	key, keystream []byte
 }
 
 var golden = []rc4Test{
@@ -41,18 +41,18 @@ var golden = []rc4Test{
 
 func TestGolden(t *testing.T) {
 	for i := 0; i < len(golden); i++ {
-		g := golden[i];
-		c, err := NewCipher(g.key);
+		g := golden[i]
+		c, err := NewCipher(g.key)
 		if err != nil {
-			t.Errorf("Failed to create cipher at golden index %d", i);
-			return;
+			t.Errorf("Failed to create cipher at golden index %d", i)
+			return
 		}
-		keystream := make([]byte, len(g.keystream));
-		c.XORKeyStream(keystream);
+		keystream := make([]byte, len(g.keystream))
+		c.XORKeyStream(keystream)
 		for j, v := range keystream {
 			if g.keystream[j] != v {
-				t.Errorf("Failed at golden index %d", i);
-				break;
+				t.Errorf("Failed at golden index %d", i)
+				break
 			}
 		}
 	}
diff --git a/src/pkg/crypto/rsa/pkcs1v15.go b/src/pkg/crypto/rsa/pkcs1v15.go
index 9dbc20f29..cfad95454 100644
--- a/src/pkg/crypto/rsa/pkcs1v15.go
+++ b/src/pkg/crypto/rsa/pkcs1v15.go
@@ -5,10 +5,10 @@
 package rsa
 
 import (
-	"big";
-	"crypto/subtle";
-	"io";
-	"os";
+	"big"
+	"crypto/subtle"
+	"io"
+	"os"
 )
 
 // This file implements encryption and decryption using PKCS#1 v1.5 padding.
@@ -18,38 +18,38 @@ import (
 // WARNING: use of this function to encrypt plaintexts other than session keys
 // is dangerous. Use RSA OAEP in new protocols.
 func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err os.Error) {
-	k := (pub.N.Len() + 7) / 8;
+	k := (pub.N.Len() + 7) / 8
 	if len(msg) > k-11 {
-		err = MessageTooLongError{};
-		return;
+		err = MessageTooLongError{}
+		return
 	}
 
 	// EM = 0x02 || PS || 0x00 || M
-	em := make([]byte, k-1);
-	em[0] = 2;
-	ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):];
-	err = nonZeroRandomBytes(ps, rand);
+	em := make([]byte, k-1)
+	em[0] = 2
+	ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):]
+	err = nonZeroRandomBytes(ps, rand)
 	if err != nil {
 		return
 	}
-	em[len(em)-len(msg)-1] = 0;
-	copy(mm, msg);
+	em[len(em)-len(msg)-1] = 0
+	copy(mm, msg)
 
-	m := new(big.Int).SetBytes(em);
-	c := encrypt(new(big.Int), pub, m);
-	out = c.Bytes();
-	return;
+	m := new(big.Int).SetBytes(em)
+	c := encrypt(new(big.Int), pub, m)
+	out = c.Bytes()
+	return
 }
 
 // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS#1 v1.5.
 // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks.
 func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err os.Error) {
-	valid, out, err := decryptPKCS1v15(rand, priv, ciphertext);
+	valid, out, err := decryptPKCS1v15(rand, priv, ciphertext)
 	if err == nil && valid == 0 {
 		err = DecryptionError{}
 	}
 
-	return;
+	return
 }
 
 // DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding scheme from PKCS#1 v1.5.
@@ -66,74 +66,74 @@ func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out [
 // Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology
 // (Crypto '98),
 func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err os.Error) {
-	k := (priv.N.Len() + 7) / 8;
+	k := (priv.N.Len() + 7) / 8
 	if k-(len(key)+3+8) < 0 {
-		err = DecryptionError{};
-		return;
+		err = DecryptionError{}
+		return
 	}
 
-	valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext);
+	valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext)
 	if err != nil {
 		return
 	}
 
-	valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key)));
-	subtle.ConstantTimeCopy(valid, key, msg);
-	return;
+	valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key)))
+	subtle.ConstantTimeCopy(valid, key, msg)
+	return
 }
 
 func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, msg []byte, err os.Error) {
-	k := (priv.N.Len() + 7) / 8;
+	k := (priv.N.Len() + 7) / 8
 	if k < 11 {
-		err = DecryptionError{};
-		return;
+		err = DecryptionError{}
+		return
 	}
 
-	c := new(big.Int).SetBytes(ciphertext);
-	m, err := decrypt(rand, priv, c);
+	c := new(big.Int).SetBytes(ciphertext)
+	m, err := decrypt(rand, priv, c)
 	if err != nil {
 		return
 	}
 
-	em := leftPad(m.Bytes(), k);
-	firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0);
-	secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2);
+	em := leftPad(m.Bytes(), k)
+	firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0)
+	secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2)
 
 	// The remainder of the plaintext must be a string of non-zero random
 	// octets, followed by a 0, followed by the message.
 	//   lookingForIndex: 1 iff we are still looking for the zero.
 	//   index: the offset of the first zero byte.
-	var lookingForIndex, index int;
-	lookingForIndex = 1;
+	var lookingForIndex, index int
+	lookingForIndex = 1
 
 	for i := 2; i < len(em); i++ {
-		equals0 := subtle.ConstantTimeByteEq(em[i], 0);
-		index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index);
-		lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex);
+		equals0 := subtle.ConstantTimeByteEq(em[i], 0)
+		index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index)
+		lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex)
 	}
 
-	valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1);
-	msg = em[index+1:];
-	return;
+	valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1)
+	msg = em[index+1:]
+	return
 }
 
 // nonZeroRandomBytes fills the given slice with non-zero random octets.
 func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) {
-	_, err = io.ReadFull(rand, s);
+	_, err = io.ReadFull(rand, s)
 	if err != nil {
 		return
 	}
 
 	for i := 0; i < len(s); i++ {
 		for s[i] == 0 {
-			_, err = rand.Read(s[i : i+1]);
+			_, err = rand.Read(s[i : i+1])
 			if err != nil {
 				return
 			}
 		}
 	}
 
-	return;
+	return
 }
 
 // Due to the design of PKCS#1 v1.5, we need to know the exact hash function in
@@ -141,11 +141,11 @@ func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) {
 type PKCS1v15Hash int
 
 const (
-	HashMD5	PKCS1v15Hash	= iota;
-	HashSHA1;
-	HashSHA256;
-	HashSHA384;
-	HashSHA512;
+	HashMD5 PKCS1v15Hash = iota
+	HashSHA1
+	HashSHA256
+	HashSHA384
+	HashSHA512
 )
 
 // These are ASN1 DER structures:
@@ -173,32 +173,32 @@ var hashPrefixes = [][]byte{
 // Note that hashed must be the result of hashing the input message using the
 // given hash function.
 func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash PKCS1v15Hash, hashed []byte) (s []byte, err os.Error) {
-	hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed));
+	hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed))
 	if err != nil {
 		return
 	}
 
-	tLen := len(prefix) + hashLen;
-	k := (priv.N.Len() + 7) / 8;
+	tLen := len(prefix) + hashLen
+	k := (priv.N.Len() + 7) / 8
 	if k < tLen+11 {
 		return nil, MessageTooLongError{}
 	}
 
 	// EM = 0x00 || 0x01 || PS || 0x00 || T
-	em := make([]byte, k);
-	em[1] = 1;
+	em := make([]byte, k)
+	em[1] = 1
 	for i := 2; i < k-tLen-1; i++ {
 		em[i] = 0xff
 	}
-	copy(em[k-tLen:k-hashLen], prefix);
-	copy(em[k-hashLen:k], hashed);
+	copy(em[k-tLen:k-hashLen], prefix)
+	copy(em[k-hashLen:k], hashed)
 
-	m := new(big.Int).SetBytes(em);
-	c, err := decrypt(rand, priv, m);
+	m := new(big.Int).SetBytes(em)
+	c, err := decrypt(rand, priv, m)
 	if err == nil {
 		s = c.Bytes()
 	}
-	return;
+	return
 }
 
 // VerifyPKCS1v15 verifies an RSA PKCS#1 v1.5 signature.
@@ -206,28 +206,28 @@ func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash PKCS1v15Hash, hashed []
 // function and sig is the signature. A valid signature is indicated by
 // returning a nil error.
 func VerifyPKCS1v15(pub *PublicKey, hash PKCS1v15Hash, hashed []byte, sig []byte) (err os.Error) {
-	hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed));
+	hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed))
 	if err != nil {
 		return
 	}
 
-	tLen := len(prefix) + hashLen;
-	k := (pub.N.Len() + 7) / 8;
+	tLen := len(prefix) + hashLen
+	k := (pub.N.Len() + 7) / 8
 	if k < tLen+11 {
-		err = VerificationError{};
-		return;
+		err = VerificationError{}
+		return
 	}
 
-	c := new(big.Int).SetBytes(sig);
-	m := encrypt(new(big.Int), pub, c);
-	em := leftPad(m.Bytes(), k);
+	c := new(big.Int).SetBytes(sig)
+	m := encrypt(new(big.Int), pub, c)
+	em := leftPad(m.Bytes(), k)
 	// EM = 0x00 || 0x01 || PS || 0x00 || T
 
-	ok := subtle.ConstantTimeByteEq(em[0], 0);
-	ok &= subtle.ConstantTimeByteEq(em[1], 1);
-	ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed);
-	ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix);
-	ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0);
+	ok := subtle.ConstantTimeByteEq(em[0], 0)
+	ok &= subtle.ConstantTimeByteEq(em[1], 1)
+	ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed)
+	ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix)
+	ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0)
 
 	for i := 2; i < k-tLen-1; i++ {
 		ok &= subtle.ConstantTimeByteEq(em[i], 0xff)
@@ -237,7 +237,7 @@ func VerifyPKCS1v15(pub *PublicKey, hash PKCS1v15Hash, hashed []byte, sig []byte
 		return VerificationError{}
 	}
 
-	return nil;
+	return nil
 }
 
 func pkcs1v15HashInfo(hash PKCS1v15Hash, inLen int) (hashLen int, prefix []byte, err os.Error) {
@@ -260,6 +260,6 @@ func pkcs1v15HashInfo(hash PKCS1v15Hash, inLen int) (hashLen int, prefix []byte,
 		return 0, nil, os.ErrorString("input must be hashed message")
 	}
 
-	prefix = hashPrefixes[int(hash)];
-	return;
+	prefix = hashPrefixes[int(hash)]
+	return
 }
diff --git a/src/pkg/crypto/rsa/pkcs1v15_test.go b/src/pkg/crypto/rsa/pkcs1v15_test.go
index 4d62deac1..6bdd64876 100644
--- a/src/pkg/crypto/rsa/pkcs1v15_test.go
+++ b/src/pkg/crypto/rsa/pkcs1v15_test.go
@@ -5,29 +5,29 @@
 package rsa
 
 import (
-	"big";
-	"bytes";
-	"crypto/sha1";
-	"encoding/base64";
-	"encoding/hex";
-	"os";
-	"io";
-	"strings";
-	"testing";
-	"testing/quick";
+	"big"
+	"bytes"
+	"crypto/sha1"
+	"encoding/base64"
+	"encoding/hex"
+	"os"
+	"io"
+	"strings"
+	"testing"
+	"testing/quick"
 )
 
 func decodeBase64(in string) []byte {
-	out := make([]byte, base64.StdEncoding.DecodedLen(len(in)));
-	n, err := base64.StdEncoding.Decode(out, strings.Bytes(in));
+	out := make([]byte, base64.StdEncoding.DecodedLen(len(in)))
+	n, err := base64.StdEncoding.Decode(out, strings.Bytes(in))
 	if err != nil {
 		return nil
 	}
-	return out[0:n];
+	return out[0:n]
 }
 
 type DecryptPKCS1v15Test struct {
-	in, out string;
+	in, out string
 }
 
 // These test vectors were generated with `openssl rsautl -pkcs -encrypt`
@@ -52,11 +52,11 @@ var decryptPKCS1v15Tests = []DecryptPKCS1v15Test{
 
 func TestDecryptPKCS1v15(t *testing.T) {
 	for i, test := range decryptPKCS1v15Tests {
-		out, err := DecryptPKCS1v15(nil, rsaPrivateKey, decodeBase64(test.in));
+		out, err := DecryptPKCS1v15(nil, rsaPrivateKey, decodeBase64(test.in))
 		if err != nil {
 			t.Errorf("#%d error decrypting", i)
 		}
-		want := strings.Bytes(test.out);
+		want := strings.Bytes(test.out)
 		if bytes.Compare(out, want) != 0 {
 			t.Errorf("#%d got:%#v want:%#v", i, out, want)
 		}
@@ -64,43 +64,43 @@ func TestDecryptPKCS1v15(t *testing.T) {
 }
 
 func TestEncryptPKCS1v15(t *testing.T) {
-	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0);
+	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0)
 	if err != nil {
 		t.Errorf("Failed to open /dev/urandom")
 	}
-	k := (rsaPrivateKey.N.Len() + 7) / 8;
+	k := (rsaPrivateKey.N.Len() + 7) / 8
 
 	tryEncryptDecrypt := func(in []byte, blind bool) bool {
 		if len(in) > k-11 {
 			in = in[0 : k-11]
 		}
 
-		ciphertext, err := EncryptPKCS1v15(urandom, &rsaPrivateKey.PublicKey, in);
+		ciphertext, err := EncryptPKCS1v15(urandom, &rsaPrivateKey.PublicKey, in)
 		if err != nil {
-			t.Errorf("error encrypting: %s", err);
-			return false;
+			t.Errorf("error encrypting: %s", err)
+			return false
 		}
 
-		var rand io.Reader;
+		var rand io.Reader
 		if !blind {
 			rand = nil
 		} else {
 			rand = urandom
 		}
-		plaintext, err := DecryptPKCS1v15(rand, rsaPrivateKey, ciphertext);
+		plaintext, err := DecryptPKCS1v15(rand, rsaPrivateKey, ciphertext)
 		if err != nil {
-			t.Errorf("error decrypting: %s", err);
-			return false;
+			t.Errorf("error decrypting: %s", err)
+			return false
 		}
 
 		if bytes.Compare(plaintext, in) != 0 {
-			t.Errorf("output mismatch: %#v %#v", plaintext, in);
-			return false;
+			t.Errorf("output mismatch: %#v %#v", plaintext, in)
+			return false
 		}
-		return true;
-	};
+		return true
+	}
 
-	quick.Check(tryEncryptDecrypt, nil);
+	quick.Check(tryEncryptDecrypt, nil)
 }
 
 // These test vectors were generated with `openssl rsautl -pkcs -encrypt`
@@ -125,12 +125,12 @@ var decryptPKCS1v15SessionKeyTests = []DecryptPKCS1v15Test{
 
 func TestEncryptPKCS1v15SessionKey(t *testing.T) {
 	for i, test := range decryptPKCS1v15SessionKeyTests {
-		key := strings.Bytes("FAIL");
-		err := DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, decodeBase64(test.in), key);
+		key := strings.Bytes("FAIL")
+		err := DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, decodeBase64(test.in), key)
 		if err != nil {
 			t.Errorf("#%d error decrypting", i)
 		}
-		want := strings.Bytes(test.out);
+		want := strings.Bytes(test.out)
 		if bytes.Compare(key, want) != 0 {
 			t.Errorf("#%d got:%#v want:%#v", i, key, want)
 		}
@@ -138,26 +138,26 @@ func TestEncryptPKCS1v15SessionKey(t *testing.T) {
 }
 
 func TestNonZeroRandomBytes(t *testing.T) {
-	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0);
+	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0)
 	if err != nil {
 		t.Errorf("Failed to open /dev/urandom")
 	}
 
-	b := make([]byte, 512);
-	err = nonZeroRandomBytes(b, urandom);
+	b := make([]byte, 512)
+	err = nonZeroRandomBytes(b, urandom)
 	if err != nil {
 		t.Errorf("returned error: %s", err)
 	}
 	for _, b := range b {
 		if b == 0 {
-			t.Errorf("Zero octet found");
-			return;
+			t.Errorf("Zero octet found")
+			return
 		}
 	}
 }
 
 type signPKCS1v15Test struct {
-	in, out string;
+	in, out string
 }
 
 // These vectors have been tested with
@@ -168,16 +168,16 @@ var signPKCS1v15Tests = []signPKCS1v15Test{
 
 func TestSignPKCS1v15(t *testing.T) {
 	for i, test := range signPKCS1v15Tests {
-		h := sha1.New();
-		h.Write(strings.Bytes(test.in));
-		digest := h.Sum();
+		h := sha1.New()
+		h.Write(strings.Bytes(test.in))
+		digest := h.Sum()
 
-		s, err := SignPKCS1v15(nil, rsaPrivateKey, HashSHA1, digest);
+		s, err := SignPKCS1v15(nil, rsaPrivateKey, HashSHA1, digest)
 		if err != nil {
 			t.Errorf("#%d %s", i, err)
 		}
 
-		expected, _ := hex.DecodeString(test.out);
+		expected, _ := hex.DecodeString(test.out)
 		if bytes.Compare(s, expected) != 0 {
 			t.Errorf("#%d got: %x want: %x", i, s, expected)
 		}
@@ -186,13 +186,13 @@ func TestSignPKCS1v15(t *testing.T) {
 
 func TestVerifyPKCS1v15(t *testing.T) {
 	for i, test := range signPKCS1v15Tests {
-		h := sha1.New();
-		h.Write(strings.Bytes(test.in));
-		digest := h.Sum();
+		h := sha1.New()
+		h.Write(strings.Bytes(test.in))
+		digest := h.Sum()
 
-		sig, _ := hex.DecodeString(test.out);
+		sig, _ := hex.DecodeString(test.out)
 
-		err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, HashSHA1, digest, sig);
+		err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, HashSHA1, digest, sig)
 		if err != nil {
 			t.Errorf("#%d %s", i, err)
 		}
@@ -200,9 +200,9 @@ func TestVerifyPKCS1v15(t *testing.T) {
 }
 
 func bigFromString(s string) *big.Int {
-	ret := new(big.Int);
-	ret.SetString(s, 10);
-	return ret;
+	ret := new(big.Int)
+	ret.SetString(s, 10)
+	return ret
 }
 
 // In order to generate new test vectors you'll need the PEM form of this key:
diff --git a/src/pkg/crypto/rsa/rsa.go b/src/pkg/crypto/rsa/rsa.go
index e47b02060..a4a3cfd38 100644
--- a/src/pkg/crypto/rsa/rsa.go
+++ b/src/pkg/crypto/rsa/rsa.go
@@ -8,11 +8,11 @@ package rsa
 // TODO(agl): Add support for PSS padding.
 
 import (
-	"big";
-	"crypto/subtle";
-	"hash";
-	"io";
-	"os";
+	"big"
+	"crypto/subtle"
+	"hash"
+	"io"
+	"os"
 )
 
 var bigZero = big.NewInt(0)
@@ -25,77 +25,77 @@ func randomSafePrime(rand io.Reader, bits int) (p *big.Int, err os.Error) {
 		err = os.EINVAL
 	}
 
-	bytes := make([]byte, (bits+7)/8);
-	p = new(big.Int);
-	p2 := new(big.Int);
+	bytes := make([]byte, (bits+7)/8)
+	p = new(big.Int)
+	p2 := new(big.Int)
 
 	for {
-		_, err = io.ReadFull(rand, bytes);
+		_, err = io.ReadFull(rand, bytes)
 		if err != nil {
 			return
 		}
 
 		// Don't let the value be too small.
-		bytes[0] |= 0x80;
+		bytes[0] |= 0x80
 		// Make the value odd since an even number this large certainly isn't prime.
-		bytes[len(bytes)-1] |= 1;
+		bytes[len(bytes)-1] |= 1
 
-		p.SetBytes(bytes);
+		p.SetBytes(bytes)
 		if big.ProbablyPrime(p, 20) {
-			p2.Rsh(p, 1);	// p2 = (p - 1)/2
+			p2.Rsh(p, 1) // p2 = (p - 1)/2
 			if big.ProbablyPrime(p2, 20) {
 				return
 			}
 		}
 	}
 
-	return;
+	return
 }
 
 // randomNumber returns a uniform random value in [0, max).
 func randomNumber(rand io.Reader, max *big.Int) (n *big.Int, err os.Error) {
-	k := (max.Len() + 7) / 8;
+	k := (max.Len() + 7) / 8
 
 	// r is the number of bits in the used in the most significant byte of
 	// max.
-	r := uint(max.Len() % 8);
+	r := uint(max.Len() % 8)
 	if r == 0 {
 		r = 8
 	}
 
-	bytes := make([]byte, k);
-	n = new(big.Int);
+	bytes := make([]byte, k)
+	n = new(big.Int)
 
 	for {
-		_, err = io.ReadFull(rand, bytes);
+		_, err = io.ReadFull(rand, bytes)
 		if err != nil {
 			return
 		}
 
 		// Clear bits in the first byte to increase the probability
 		// that the candidate is < max.
-		bytes[0] &= uint8(int(1<<r) - 1);
+		bytes[0] &= uint8(int(1<<r) - 1)
 
-		n.SetBytes(bytes);
+		n.SetBytes(bytes)
 		if n.Cmp(max) < 0 {
 			return
 		}
 	}
 
-	return;
+	return
 }
 
 // A PublicKey represents the public part of an RSA key.
 type PublicKey struct {
-	N	*big.Int;	// modulus
-	E	int;		// public exponent
+	N *big.Int // modulus
+	E int      // public exponent
 }
 
 // A PrivateKey represents an RSA key
 type PrivateKey struct {
-	PublicKey;			// public part.
-	D		*big.Int;	// private exponent
-	P, Q		*big.Int;	// prime factors of N
+	PublicKey          // public part.
+	D         *big.Int // private exponent
+	P, Q      *big.Int // prime factors of N
 }
 
 // Validate performs basic sanity checks on the key.
@@ -114,34 +114,34 @@ func (priv PrivateKey) Validate() os.Error {
 	}
 
 	// Check that p*q == n.
-	modulus := new(big.Int).Mul(priv.P, priv.Q);
+	modulus := new(big.Int).Mul(priv.P, priv.Q)
 	if modulus.Cmp(priv.N) != 0 {
 		return os.ErrorString("invalid modulus")
 	}
 	// Check that e and totient(p, q) are coprime.
-	pminus1 := new(big.Int).Sub(priv.P, bigOne);
-	qminus1 := new(big.Int).Sub(priv.Q, bigOne);
-	totient := new(big.Int).Mul(pminus1, qminus1);
-	e := big.NewInt(int64(priv.E));
-	gcd := new(big.Int);
-	x := new(big.Int);
-	y := new(big.Int);
-	big.GcdInt(gcd, x, y, totient, e);
+	pminus1 := new(big.Int).Sub(priv.P, bigOne)
+	qminus1 := new(big.Int).Sub(priv.Q, bigOne)
+	totient := new(big.Int).Mul(pminus1, qminus1)
+	e := big.NewInt(int64(priv.E))
+	gcd := new(big.Int)
+	x := new(big.Int)
+	y := new(big.Int)
+	big.GcdInt(gcd, x, y, totient, e)
 	if gcd.Cmp(bigOne) != 0 {
 		return os.ErrorString("invalid public exponent E")
 	}
 	// Check that de ≡ 1 (mod totient(p, q))
-	de := new(big.Int).Mul(priv.D, e);
-	de.Mod(de, totient);
+	de := new(big.Int).Mul(priv.D, e)
+	de.Mod(de, totient)
 	if de.Cmp(bigOne) != 0 {
 		return os.ErrorString("invalid private exponent D")
 	}
-	return nil;
+	return nil
 }
 
 // GenerateKeyPair generates an RSA keypair of the given bit size.
 func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) {
-	priv = new(PrivateKey);
+	priv = new(PrivateKey)
 	// Smaller public exponents lead to faster public key
 	// operations. Since the exponent must be coprime to
 	// (p-1)(q-1), the smallest possible value is 3. Some have
@@ -150,19 +150,19 @@ func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) {
 	// was the case. However, there are no current reasons not to use
 	// small exponents.
 	// [1] http://marc.info/?l=cryptography&m=115694833312008&w=2
-	priv.E = 3;
+	priv.E = 3
 
-	pminus1 := new(big.Int);
-	qminus1 := new(big.Int);
-	totient := new(big.Int);
+	pminus1 := new(big.Int)
+	qminus1 := new(big.Int)
+	totient := new(big.Int)
 
 	for {
-		p, err := randomSafePrime(rand, bits/2);
+		p, err := randomSafePrime(rand, bits/2)
 		if err != nil {
 			return nil, err
 		}
 
-		q, err := randomSafePrime(rand, bits/2);
+		q, err := randomSafePrime(rand, bits/2)
 		if err != nil {
 			return nil, err
 		}
@@ -171,28 +171,28 @@ func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) {
 			continue
 		}
 
-		n := new(big.Int).Mul(p, q);
-		pminus1.Sub(p, bigOne);
-		qminus1.Sub(q, bigOne);
-		totient.Mul(pminus1, qminus1);
+		n := new(big.Int).Mul(p, q)
+		pminus1.Sub(p, bigOne)
+		qminus1.Sub(q, bigOne)
+		totient.Mul(pminus1, qminus1)
 
-		g := new(big.Int);
-		priv.D = new(big.Int);
-		y := new(big.Int);
-		e := big.NewInt(int64(priv.E));
-		big.GcdInt(g, priv.D, y, e, totient);
+		g := new(big.Int)
+		priv.D = new(big.Int)
+		y := new(big.Int)
+		e := big.NewInt(int64(priv.E))
+		big.GcdInt(g, priv.D, y, e, totient)
 
 		if g.Cmp(bigOne) == 0 {
-			priv.D.Add(priv.D, totient);
-			priv.P = p;
-			priv.Q = q;
-			priv.N = n;
+			priv.D.Add(priv.D, totient)
+			priv.P = p
+			priv.Q = q
+			priv.N = n
 
-			break;
+			break
 		}
 	}
 
-	return;
+	return
 }
 
 // incCounter increments a four byte, big-endian counter.
@@ -206,26 +206,26 @@ func incCounter(c *[4]byte) {
 	if c[1]++; c[1] != 0 {
 		return
 	}
-	c[0]++;
+	c[0]++
 }
 
 // mgf1XOR XORs the bytes in out with a mask generated using the MGF1 function
 // specified in PKCS#1 v2.1.
 func mgf1XOR(out []byte, hash hash.Hash, seed []byte) {
-	var counter [4]byte;
+	var counter [4]byte
 
-	done := 0;
+	done := 0
 	for done < len(out) {
-		hash.Write(seed);
-		hash.Write(counter[0:4]);
-		digest := hash.Sum();
-		hash.Reset();
+		hash.Write(seed)
+		hash.Write(counter[0:4])
+		digest := hash.Sum()
+		hash.Reset()
 
 		for i := 0; i < len(digest) && done < len(out); i++ {
-			out[done] ^= digest[i];
-			done++;
+			out[done] ^= digest[i]
+			done++
 		}
-		incCounter(&counter);
+		incCounter(&counter)
 	}
 }
 
@@ -238,68 +238,68 @@ func (MessageTooLongError) String() string {
 }
 
 func encrypt(c *big.Int, pub *PublicKey, m *big.Int) *big.Int {
-	e := big.NewInt(int64(pub.E));
-	c.Exp(m, e, pub.N);
-	return c;
+	e := big.NewInt(int64(pub.E))
+	c.Exp(m, e, pub.N)
+	return c
 }
 
 // EncryptOAEP encrypts the given message with RSA-OAEP.
 // The message must be no longer than the length of the public modulus less
 // twice the hash length plus 2.
 func EncryptOAEP(hash hash.Hash, rand io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err os.Error) {
-	hash.Reset();
-	k := (pub.N.Len() + 7) / 8;
+	hash.Reset()
+	k := (pub.N.Len() + 7) / 8
 	if len(msg) > k-2*hash.Size()-2 {
-		err = MessageTooLongError{};
-		return;
+		err = MessageTooLongError{}
+		return
 	}
 
-	hash.Write(label);
-	lHash := hash.Sum();
-	hash.Reset();
+	hash.Write(label)
+	lHash := hash.Sum()
+	hash.Reset()
 
-	em := make([]byte, k);
-	seed := em[1 : 1+hash.Size()];
-	db := em[1+hash.Size():];
+	em := make([]byte, k)
+	seed := em[1 : 1+hash.Size()]
+	db := em[1+hash.Size():]
 
-	copy(db[0:hash.Size()], lHash);
-	db[len(db)-len(msg)-1] = 1;
-	copy(db[len(db)-len(msg):], msg);
+	copy(db[0:hash.Size()], lHash)
+	db[len(db)-len(msg)-1] = 1
+	copy(db[len(db)-len(msg):], msg)
 
-	_, err = io.ReadFull(rand, seed);
+	_, err = io.ReadFull(rand, seed)
 	if err != nil {
 		return
 	}
 
-	mgf1XOR(db, hash, seed);
-	mgf1XOR(seed, hash, db);
+	mgf1XOR(db, hash, seed)
+	mgf1XOR(seed, hash, db)
 
-	m := new(big.Int);
-	m.SetBytes(em);
-	c := encrypt(new(big.Int), pub, m);
-	out = c.Bytes();
-	return;
+	m := new(big.Int)
+	m.SetBytes(em)
+	c := encrypt(new(big.Int), pub, m)
+	out = c.Bytes()
+	return
 }
 
 // A DecryptionError represents a failure to decrypt a message.
 // It is deliberately vague to avoid adaptive attacks.
 type DecryptionError struct{}
 
-func (DecryptionError) String() string	{ return "RSA decryption error" }
+func (DecryptionError) String() string { return "RSA decryption error" }
 
 // A VerificationError represents a failure to verify a signature.
 // It is deliberately vague to avoid adaptive attacks.
 type VerificationError struct{}
 
-func (VerificationError) String() string	{ return "RSA verification error" }
+func (VerificationError) String() string { return "RSA verification error" }
 
 // modInverse returns ia, the inverse of a in the multiplicative group of prime
 // order n. It requires that a be a member of the group (i.e. less than n).
 func modInverse(a, n *big.Int) (ia *big.Int, ok bool) {
-	g := new(big.Int);
-	x := new(big.Int);
-	y := new(big.Int);
-	big.GcdInt(g, x, y, a, n);
+	g := new(big.Int)
+	x := new(big.Int)
+	y := new(big.Int)
+	big.GcdInt(g, x, y, a, n)
 	if g.Cmp(bigOne) != 0 {
 		// In this case, a and n aren't coprime and we cannot calculate
 		// the inverse. This happens because the values of n are nearly
@@ -314,7 +314,7 @@ func modInverse(a, n *big.Int) (ia *big.Int, ok bool) {
 		x.Add(x, n)
 	}
 
-	return x, true;
+	return x, true
 }
 
 // decrypt performs an RSA decryption, resulting in a plaintext integer. If a
@@ -322,128 +322,128 @@ func modInverse(a, n *big.Int) (ia *big.Int, ok bool) {
 func decrypt(rand io.Reader, priv *PrivateKey, c *big.Int) (m *big.Int, err os.Error) {
 	// TODO(agl): can we get away with reusing blinds?
 	if c.Cmp(priv.N) > 0 {
-		err = DecryptionError{};
-		return;
+		err = DecryptionError{}
+		return
 	}
 
-	var ir *big.Int;
+	var ir *big.Int
 	if rand != nil {
 		// Blinding enabled. Blinding involves multiplying c by r^e.
 		// Then the decryption operation performs (m^e * r^e)^d mod n
 		// which equals mr mod n. The factor of r can then be removed
 		// by multipling by the multiplicative inverse of r.
 
-		var r *big.Int;
+		var r *big.Int
 
 		for {
-			r, err = randomNumber(rand, priv.N);
+			r, err = randomNumber(rand, priv.N)
 			if err != nil {
 				return
 			}
 			if r.Cmp(bigZero) == 0 {
 				r = bigOne
 			}
-			var ok bool;
-			ir, ok = modInverse(r, priv.N);
+			var ok bool
+			ir, ok = modInverse(r, priv.N)
 			if ok {
 				break
 			}
 		}
-		bigE := big.NewInt(int64(priv.E));
-		rpowe := new(big.Int).Exp(r, bigE, priv.N);
-		c.Mul(c, rpowe);
-		c.Mod(c, priv.N);
+		bigE := big.NewInt(int64(priv.E))
+		rpowe := new(big.Int).Exp(r, bigE, priv.N)
+		c.Mul(c, rpowe)
+		c.Mod(c, priv.N)
 	}
 
-	m = new(big.Int).Exp(c, priv.D, priv.N);
+	m = new(big.Int).Exp(c, priv.D, priv.N)
 
 	if ir != nil {
 		// Unblind.
-		m.Mul(m, ir);
-		m.Mod(m, priv.N);
+		m.Mul(m, ir)
+		m.Mod(m, priv.N)
 	}
 
-	return;
+	return
 }
 
 // DecryptOAEP decrypts ciphertext using RSA-OAEP.
 // If rand != nil, DecryptOAEP uses RSA blinding to avoid timing side-channel attacks.
 func DecryptOAEP(hash hash.Hash, rand io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err os.Error) {
-	k := (priv.N.Len() + 7) / 8;
+	k := (priv.N.Len() + 7) / 8
 	if len(ciphertext) > k ||
 		k < hash.Size()*2+2 {
-		err = DecryptionError{};
-		return;
+		err = DecryptionError{}
+		return
 	}
 
-	c := new(big.Int).SetBytes(ciphertext);
+	c := new(big.Int).SetBytes(ciphertext)
 
-	m, err := decrypt(rand, priv, c);
+	m, err := decrypt(rand, priv, c)
 	if err != nil {
 		return
 	}
 
-	hash.Write(label);
-	lHash := hash.Sum();
-	hash.Reset();
+	hash.Write(label)
+	lHash := hash.Sum()
+	hash.Reset()
 
 	// Converting the plaintext number to bytes will strip any
 	// leading zeros so we may have to left pad. We do this unconditionally
 	// to avoid leaking timing information. (Although we still probably
 	// leak the number of leading zeros. It's not clear that we can do
 	// anything about this.)
-	em := leftPad(m.Bytes(), k);
+	em := leftPad(m.Bytes(), k)
 
-	firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0);
+	firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0)
 
-	seed := em[1 : hash.Size()+1];
-	db := em[hash.Size()+1:];
+	seed := em[1 : hash.Size()+1]
+	db := em[hash.Size()+1:]
 
-	mgf1XOR(seed, hash, db);
-	mgf1XOR(db, hash, seed);
+	mgf1XOR(seed, hash, db)
+	mgf1XOR(db, hash, seed)
 
-	lHash2 := db[0:hash.Size()];
+	lHash2 := db[0:hash.Size()]
 
 	// We have to validate the plaintext in contanst time in order to avoid
 	// attacks like: J. Manger. A Chosen Ciphertext Attack on RSA Optimal
 	// Asymmetric Encryption Padding (OAEP) as Standardized in PKCS #1
 	// v2.0. In J. Kilian, editor, Advances in Cryptology.
-	lHash2Good := subtle.ConstantTimeCompare(lHash, lHash2);
+	lHash2Good := subtle.ConstantTimeCompare(lHash, lHash2)
 
 	// The remainder of the plaintext must be zero or more 0x00, followed
 	// by 0x01, followed by the message.
 	//   lookingForIndex: 1 iff we are still looking for the 0x01
 	//   index: the offset of the first 0x01 byte
 	//   invalid: 1 iff we saw a non-zero byte before the 0x01.
-	var lookingForIndex, index, invalid int;
-	lookingForIndex = 1;
-	rest := db[hash.Size():];
+	var lookingForIndex, index, invalid int
+	lookingForIndex = 1
+	rest := db[hash.Size():]
 
 	for i := 0; i < len(rest); i++ {
-		equals0 := subtle.ConstantTimeByteEq(rest[i], 0);
-		equals1 := subtle.ConstantTimeByteEq(rest[i], 1);
-		index = subtle.ConstantTimeSelect(lookingForIndex&equals1, i, index);
-		lookingForIndex = subtle.ConstantTimeSelect(equals1, 0, lookingForIndex);
-		invalid = subtle.ConstantTimeSelect(lookingForIndex&^equals0, 1, invalid);
+		equals0 := subtle.ConstantTimeByteEq(rest[i], 0)
+		equals1 := subtle.ConstantTimeByteEq(rest[i], 1)
+		index = subtle.ConstantTimeSelect(lookingForIndex&equals1, i, index)
+		lookingForIndex = subtle.ConstantTimeSelect(equals1, 0, lookingForIndex)
+		invalid = subtle.ConstantTimeSelect(lookingForIndex&^equals0, 1, invalid)
 	}
 
 	if firstByteIsZero&lHash2Good&^invalid&^lookingForIndex != 1 {
-		err = DecryptionError{};
-		return;
+		err = DecryptionError{}
+		return
 	}
 
-	msg = rest[index+1:];
-	return;
+	msg = rest[index+1:]
+	return
 }
 
 // leftPad returns a new slice of length size. The contents of input are right
 // aligned in the new slice.
 func leftPad(input []byte, size int) (out []byte) {
-	n := len(input);
+	n := len(input)
 	if n > size {
 		n = size
 	}
-	out = make([]byte, size);
-	copy(out[len(out)-n:], input);
-	return;
+	out = make([]byte, size)
+	copy(out[len(out)-n:], input)
+	return
 }
diff --git a/src/pkg/crypto/rsa/rsa_test.go b/src/pkg/crypto/rsa/rsa_test.go
index cc15b8674..21acf6ed6 100644
--- a/src/pkg/crypto/rsa/rsa_test.go
+++ b/src/pkg/crypto/rsa/rsa_test.go
@@ -5,27 +5,27 @@
 package rsa
 
 import (
-	"big";
-	"bytes";
-	"crypto/sha1";
-	"os";
-	"testing";
+	"big"
+	"bytes"
+	"crypto/sha1"
+	"os"
+	"testing"
 )
 
 func TestKeyGeneration(t *testing.T) {
-	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0);
+	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0)
 	if err != nil {
 		t.Errorf("failed to open /dev/urandom")
 	}
 
-	priv, err := GenerateKey(urandom, 32);
+	priv, err := GenerateKey(urandom, 32)
 	if err != nil {
 		t.Errorf("failed to generate key")
 	}
-	pub := &priv.PublicKey;
-	m := big.NewInt(42);
-	c := encrypt(new(big.Int), pub, m);
-	m2, err := decrypt(nil, priv, c);
+	pub := &priv.PublicKey
+	m := big.NewInt(42)
+	c := encrypt(new(big.Int), pub, m)
+	m2, err := decrypt(nil, priv, c)
 	if err != nil {
 		t.Errorf("error while decrypting: %s", err)
 	}
@@ -33,7 +33,7 @@ func TestKeyGeneration(t *testing.T) {
 		t.Errorf("got:%v, want:%v (%s)", m2, m, priv)
 	}
 
-	m3, err := decrypt(urandom, priv, c);
+	m3, err := decrypt(urandom, priv, c)
 	if err != nil {
 		t.Errorf("error while decrypting (blind): %s", err)
 	}
@@ -43,28 +43,28 @@ func TestKeyGeneration(t *testing.T) {
 }
 
 type testEncryptOAEPMessage struct {
-	in	[]byte;
-	seed	[]byte;
-	out	[]byte;
+	in   []byte
+	seed []byte
+	out  []byte
 }
 
 type testEncryptOAEPStruct struct {
-	modulus	string;
-	e	int;
-	d	string;
-	msgs	[]testEncryptOAEPMessage;
+	modulus string
+	e       int
+	d       string
+	msgs    []testEncryptOAEPMessage
 }
 
 func TestEncryptOAEP(t *testing.T) {
-	sha1 := sha1.New();
-	n := new(big.Int);
+	sha1 := sha1.New()
+	n := new(big.Int)
 	for i, test := range testEncryptOAEPData {
-		n.SetString(test.modulus, 16);
-		public := PublicKey{n, test.e};
+		n.SetString(test.modulus, 16)
+		public := PublicKey{n, test.e}
 
 		for j, message := range test.msgs {
-			randomSource := bytes.NewBuffer(message.seed);
-			out, err := EncryptOAEP(sha1, randomSource, &public, message.in, nil);
+			randomSource := bytes.NewBuffer(message.seed)
+			out, err := EncryptOAEP(sha1, randomSource, &public, message.in, nil)
 			if err != nil {
 				t.Errorf("#%d,%d error: %s", i, j, err)
 			}
@@ -76,21 +76,21 @@ func TestEncryptOAEP(t *testing.T) {
 }
 
 func TestDecryptOAEP(t *testing.T) {
-	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0);
+	urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0)
 	if err != nil {
 		t.Errorf("Failed to open /dev/urandom")
 	}
 
-	sha1 := sha1.New();
-	n := new(big.Int);
-	d := new(big.Int);
+	sha1 := sha1.New()
+	n := new(big.Int)
+	d := new(big.Int)
 	for i, test := range testEncryptOAEPData {
-		n.SetString(test.modulus, 16);
-		d.SetString(test.d, 16);
-		private := PrivateKey{PublicKey{n, test.e}, d, nil, nil};
+		n.SetString(test.modulus, 16)
+		d.SetString(test.d, 16)
+		private := PrivateKey{PublicKey{n, test.e}, d, nil, nil}
 
 		for j, message := range test.msgs {
-			out, err := DecryptOAEP(sha1, nil, &private, message.out, nil);
+			out, err := DecryptOAEP(sha1, nil, &private, message.out, nil)
 			if err != nil {
 				t.Errorf("#%d,%d error: %s", i, j, err)
 			} else if bytes.Compare(out, message.in) != 0 {
@@ -98,7 +98,7 @@ func TestDecryptOAEP(t *testing.T) {
 			}
 
 			// Decrypt with blinding.
-			out, err = DecryptOAEP(sha1, urandom, &private, message.out, nil);
+			out, err = DecryptOAEP(sha1, urandom, &private, message.out, nil)
 			if err != nil {
 				t.Errorf("#%d,%d (blind) error: %s", i, j, err)
 			} else if bytes.Compare(out, message.in) != 0 {
diff --git a/src/pkg/crypto/sha1/sha1.go b/src/pkg/crypto/sha1/sha1.go
index ad648d15d..da70b7314 100644
--- a/src/pkg/crypto/sha1/sha1.go
+++ b/src/pkg/crypto/sha1/sha1.go
@@ -6,83 +6,83 @@
 package sha1
 
 import (
-	"hash";
-	"os";
+	"hash"
+	"os"
 )
 
 // The size of a SHA1 checksum in bytes.
 const Size = 20
 
 const (
-	_Chunk	= 64;
-	_Init0	= 0x67452301;
-	_Init1	= 0xEFCDAB89;
-	_Init2	= 0x98BADCFE;
-	_Init3	= 0x10325476;
-	_Init4	= 0xC3D2E1F0;
+	_Chunk = 64
+	_Init0 = 0x67452301
+	_Init1 = 0xEFCDAB89
+	_Init2 = 0x98BADCFE
+	_Init3 = 0x10325476
+	_Init4 = 0xC3D2E1F0
 )
 
 // digest represents the partial evaluation of a checksum.
 type digest struct {
-	h	[5]uint32;
-	x	[_Chunk]byte;
-	nx	int;
-	len	uint64;
+	h   [5]uint32
+	x   [_Chunk]byte
+	nx  int
+	len uint64
 }
 
 func (d *digest) Reset() {
-	d.h[0] = _Init0;
-	d.h[1] = _Init1;
-	d.h[2] = _Init2;
-	d.h[3] = _Init3;
-	d.h[4] = _Init4;
-	d.nx = 0;
-	d.len = 0;
+	d.h[0] = _Init0
+	d.h[1] = _Init1
+	d.h[2] = _Init2
+	d.h[3] = _Init3
+	d.h[4] = _Init4
+	d.nx = 0
+	d.len = 0
 }
 
 // New returns a new hash.Hash computing the SHA1 checksum.
 func New() hash.Hash {
-	d := new(digest);
-	d.Reset();
-	return d;
+	d := new(digest)
+	d.Reset()
+	return d
 }
 
-func (d *digest) Size() int	{ return Size }
+func (d *digest) Size() int { return Size }
 
 func (d *digest) Write(p []byte) (nn int, err os.Error) {
-	nn = len(p);
-	d.len += uint64(nn);
+	nn = len(p)
+	d.len += uint64(nn)
 	if d.nx > 0 {
-		n := len(p);
+		n := len(p)
 		if n > _Chunk-d.nx {
 			n = _Chunk - d.nx
 		}
 		for i := 0; i < n; i++ {
 			d.x[d.nx+i] = p[i]
 		}
-		d.nx += n;
+		d.nx += n
 		if d.nx == _Chunk {
-			_Block(d, &d.x);
-			d.nx = 0;
+			_Block(d, &d.x)
+			d.nx = 0
 		}
-		p = p[n:];
+		p = p[n:]
 	}
-	n := _Block(d, p);
-	p = p[n:];
+	n := _Block(d, p)
+	p = p[n:]
 	if len(p) > 0 {
 		for i := 0; i < len(p); i++ {
 			d.x[i] = p[i]
 		}
-		d.nx = len(p);
+		d.nx = len(p)
 	}
-	return;
+	return
 }
 
 func (d *digest) Sum() []byte {
 	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
-	len := d.len;
-	var tmp [64]byte;
-	tmp[0] = 0x80;
+	len := d.len
+	var tmp [64]byte
+	tmp[0] = 0x80
 	if len%64 < 56 {
 		d.Write(tmp[0 : 56-len%64])
 	} else {
@@ -90,28 +90,28 @@ func (d *digest) Sum() []byte {
 	}
 
 	// Length in bits.
-	len <<= 3;
+	len <<= 3
 	for i := uint(0); i < 8; i++ {
 		tmp[i] = byte(len >> (56 - 8*i))
 	}
-	d.Write(tmp[0:8]);
+	d.Write(tmp[0:8])
 
 	if d.nx != 0 {
 		panicln("oops")
 	}
 
-	p := make([]byte, 20);
-	j := 0;
+	p := make([]byte, 20)
+	j := 0
 	for i := 0; i < 5; i++ {
-		s := d.h[i];
-		p[j] = byte(s >> 24);
-		j++;
-		p[j] = byte(s >> 16);
-		j++;
-		p[j] = byte(s >> 8);
-		j++;
-		p[j] = byte(s);
-		j++;
+		s := d.h[i]
+		p[j] = byte(s >> 24)
+		j++
+		p[j] = byte(s >> 16)
+		j++
+		p[j] = byte(s >> 8)
+		j++
+		p[j] = byte(s)
+		j++
 	}
-	return p;
+	return p
 }
diff --git a/src/pkg/crypto/sha1/sha1_test.go b/src/pkg/crypto/sha1/sha1_test.go
index 7536300c2..8d4485282 100644
--- a/src/pkg/crypto/sha1/sha1_test.go
+++ b/src/pkg/crypto/sha1/sha1_test.go
@@ -7,14 +7,14 @@
 package sha1
 
 import (
-	"fmt";
-	"io";
-	"testing";
+	"fmt"
+	"io"
+	"testing"
 )
 
 type sha1Test struct {
-	out	string;
-	in	string;
+	out string
+	in  string
 }
 
 var golden = []sha1Test{
@@ -53,16 +53,16 @@ var golden = []sha1Test{
 
 func TestGolden(t *testing.T) {
 	for i := 0; i < len(golden); i++ {
-		g := golden[i];
-		c := New();
+		g := golden[i]
+		c := New()
 		for j := 0; j < 2; j++ {
-			io.WriteString(c, g.in);
-			s := fmt.Sprintf("%x", c.Sum());
+			io.WriteString(c, g.in)
+			s := fmt.Sprintf("%x", c.Sum())
 			if s != g.out {
-				t.Errorf("sha1[%d](%s) = %s want %s", j, g.in, s, g.out);
-				t.FailNow();
+				t.Errorf("sha1[%d](%s) = %s want %s", j, g.in, s, g.out)
+				t.FailNow()
 			}
-			c.Reset();
+			c.Reset()
 		}
 	}
 }
diff --git a/src/pkg/crypto/sha1/sha1block.go b/src/pkg/crypto/sha1/sha1block.go
index ff11520c0..b5d32af70 100644
--- a/src/pkg/crypto/sha1/sha1block.go
+++ b/src/pkg/crypto/sha1/sha1block.go
@@ -9,73 +9,73 @@
 package sha1
 
 const (
-	_K0	= 0x5A827999;
-	_K1	= 0x6ED9EBA1;
-	_K2	= 0x8F1BBCDC;
-	_K3	= 0xCA62C1D6;
+	_K0 = 0x5A827999
+	_K1 = 0x6ED9EBA1
+	_K2 = 0x8F1BBCDC
+	_K3 = 0xCA62C1D6
 )
 
 func _Block(dig *digest, p []byte) int {
-	var w [80]uint32;
+	var w [80]uint32
 
-	n := 0;
-	h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4];
+	n := 0
+	h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4]
 	for len(p) >= _Chunk {
 		// Can interlace the computation of w with the
 		// rounds below if needed for speed.
 		for i := 0; i < 16; i++ {
-			j := i * 4;
-			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]);
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
 		}
 		for i := 16; i < 80; i++ {
-			tmp := w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
-			w[i] = tmp<<1 | tmp>>(32-1);
+			tmp := w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]
+			w[i] = tmp<<1 | tmp>>(32-1)
 		}
 
-		a, b, c, d, e := h0, h1, h2, h3, h4;
+		a, b, c, d, e := h0, h1, h2, h3, h4
 
 		// Each of the four 20-iteration rounds
 		// differs only in the computation of f and
 		// the choice of K (_K0, _K1, etc).
 		for i := 0; i < 20; i++ {
-			f := b&c | (^b)&d;
-			a5 := a<<5 | a>>(32-5);
-			b30 := b<<30 | b>>(32-30);
-			t := a5 + f + e + w[i] + _K0;
-			a, b, c, d, e = t, a, b30, c, d;
+			f := b&c | (^b)&d
+			a5 := a<<5 | a>>(32-5)
+			b30 := b<<30 | b>>(32-30)
+			t := a5 + f + e + w[i] + _K0
+			a, b, c, d, e = t, a, b30, c, d
 		}
 		for i := 20; i < 40; i++ {
-			f := b ^ c ^ d;
-			a5 := a<<5 | a>>(32-5);
-			b30 := b<<30 | b>>(32-30);
-			t := a5 + f + e + w[i] + _K1;
-			a, b, c, d, e = t, a, b30, c, d;
+			f := b ^ c ^ d
+			a5 := a<<5 | a>>(32-5)
+			b30 := b<<30 | b>>(32-30)
+			t := a5 + f + e + w[i] + _K1
+			a, b, c, d, e = t, a, b30, c, d
 		}
 		for i := 40; i < 60; i++ {
-			f := b&c | b&d | c&d;
-			a5 := a<<5 | a>>(32-5);
-			b30 := b<<30 | b>>(32-30);
-			t := a5 + f + e + w[i] + _K2;
-			a, b, c, d, e = t, a, b30, c, d;
+			f := b&c | b&d | c&d
+			a5 := a<<5 | a>>(32-5)
+			b30 := b<<30 | b>>(32-30)
+			t := a5 + f + e + w[i] + _K2
+			a, b, c, d, e = t, a, b30, c, d
 		}
 		for i := 60; i < 80; i++ {
-			f := b ^ c ^ d;
-			a5 := a<<5 | a>>(32-5);
-			b30 := b<<30 | b>>(32-30);
-			t := a5 + f + e + w[i] + _K3;
-			a, b, c, d, e = t, a, b30, c, d;
+			f := b ^ c ^ d
+			a5 := a<<5 | a>>(32-5)
+			b30 := b<<30 | b>>(32-30)
+			t := a5 + f + e + w[i] + _K3
+			a, b, c, d, e = t, a, b30, c, d
 		}
 
-		h0 += a;
-		h1 += b;
-		h2 += c;
-		h3 += d;
-		h4 += e;
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
 
-		p = p[_Chunk:];
-		n += _Chunk;
+		p = p[_Chunk:]
+		n += _Chunk
 	}
 
-	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4;
-	return n;
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4
+	return n
 }
diff --git a/src/pkg/crypto/sha256/sha256.go b/src/pkg/crypto/sha256/sha256.go
index a4dbcf912..050dd2211 100644
--- a/src/pkg/crypto/sha256/sha256.go
+++ b/src/pkg/crypto/sha256/sha256.go
@@ -6,89 +6,89 @@
 package sha256
 
 import (
-	"hash";
-	"os";
+	"hash"
+	"os"
 )
 
 // The size of a SHA256 checksum in bytes.
 const Size = 32
 
 const (
-	_Chunk	= 64;
-	_Init0	= 0x6A09E667;
-	_Init1	= 0xBB67AE85;
-	_Init2	= 0x3C6EF372;
-	_Init3	= 0xA54FF53A;
-	_Init4	= 0x510E527F;
-	_Init5	= 0x9B05688C;
-	_Init6	= 0x1F83D9AB;
-	_Init7	= 0x5BE0CD19;
+	_Chunk = 64
+	_Init0 = 0x6A09E667
+	_Init1 = 0xBB67AE85
+	_Init2 = 0x3C6EF372
+	_Init3 = 0xA54FF53A
+	_Init4 = 0x510E527F
+	_Init5 = 0x9B05688C
+	_Init6 = 0x1F83D9AB
+	_Init7 = 0x5BE0CD19
 )
 
 // digest represents the partial evaluation of a checksum.
 type digest struct {
-	h	[8]uint32;
-	x	[_Chunk]byte;
-	nx	int;
-	len	uint64;
+	h   [8]uint32
+	x   [_Chunk]byte
+	nx  int
+	len uint64
 }
 
 func (d *digest) Reset() {
-	d.h[0] = _Init0;
-	d.h[1] = _Init1;
-	d.h[2] = _Init2;
-	d.h[3] = _Init3;
-	d.h[4] = _Init4;
-	d.h[5] = _Init5;
-	d.h[6] = _Init6;
-	d.h[7] = _Init7;
-	d.nx = 0;
-	d.len = 0;
+	d.h[0] = _Init0
+	d.h[1] = _Init1
+	d.h[2] = _Init2
+	d.h[3] = _Init3
+	d.h[4] = _Init4
+	d.h[5] = _Init5
+	d.h[6] = _Init6
+	d.h[7] = _Init7
+	d.nx = 0
+	d.len = 0
 }
 
 // New returns a new hash.Hash computing the SHA256 checksum.
 func New() hash.Hash {
-	d := new(digest);
-	d.Reset();
-	return d;
+	d := new(digest)
+	d.Reset()
+	return d
 }
 
-func (d *digest) Size() int	{ return Size }
+func (d *digest) Size() int { return Size }
 
 func (d *digest) Write(p []byte) (nn int, err os.Error) {
-	nn = len(p);
-	d.len += uint64(nn);
+	nn = len(p)
+	d.len += uint64(nn)
 	if d.nx > 0 {
-		n := len(p);
+		n := len(p)
 		if n > _Chunk-d.nx {
 			n = _Chunk - d.nx
 		}
 		for i := 0; i < n; i++ {
 			d.x[d.nx+i] = p[i]
 		}
-		d.nx += n;
+		d.nx += n
 		if d.nx == _Chunk {
-			_Block(d, &d.x);
-			d.nx = 0;
+			_Block(d, &d.x)
+			d.nx = 0
 		}
-		p = p[n:];
+		p = p[n:]
 	}
-	n := _Block(d, p);
-	p = p[n:];
+	n := _Block(d, p)
+	p = p[n:]
 	if len(p) > 0 {
 		for i := 0; i < len(p); i++ {
 			d.x[i] = p[i]
 		}
-		d.nx = len(p);
+		d.nx = len(p)
 	}
-	return;
+	return
 }
 
 func (d *digest) Sum() []byte {
 	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
-	len := d.len;
-	var tmp [64]byte;
-	tmp[0] = 0x80;
+	len := d.len
+	var tmp [64]byte
+	tmp[0] = 0x80
 	if len%64 < 56 {
 		d.Write(tmp[0 : 56-len%64])
 	} else {
@@ -96,28 +96,28 @@ func (d *digest) Sum() []byte {
 	}
 
 	// Length in bits.
-	len <<= 3;
+	len <<= 3
 	for i := uint(0); i < 8; i++ {
 		tmp[i] = byte(len >> (56 - 8*i))
 	}
-	d.Write(tmp[0:8]);
+	d.Write(tmp[0:8])
 
 	if d.nx != 0 {
 		panicln("oops")
 	}
 
-	p := make([]byte, 32);
-	j := 0;
+	p := make([]byte, 32)
+	j := 0
 	for i := 0; i < 8; i++ {
-		s := d.h[i];
-		p[j] = byte(s >> 24);
-		j++;
-		p[j] = byte(s >> 16);
-		j++;
-		p[j] = byte(s >> 8);
-		j++;
-		p[j] = byte(s);
-		j++;
+		s := d.h[i]
+		p[j] = byte(s >> 24)
+		j++
+		p[j] = byte(s >> 16)
+		j++
+		p[j] = byte(s >> 8)
+		j++
+		p[j] = byte(s)
+		j++
 	}
-	return p;
+	return p
 }
diff --git a/src/pkg/crypto/sha256/sha256_test.go b/src/pkg/crypto/sha256/sha256_test.go
index 5f1c96924..29c0bce60 100644
--- a/src/pkg/crypto/sha256/sha256_test.go
+++ b/src/pkg/crypto/sha256/sha256_test.go
@@ -7,14 +7,14 @@
 package sha256
 
 import (
-	"fmt";
-	"io";
-	"testing";
+	"fmt"
+	"io"
+	"testing"
 )
 
 type sha256Test struct {
-	out	string;
-	in	string;
+	out string
+	in  string
 }
 
 var golden = []sha256Test{
@@ -53,16 +53,16 @@ var golden = []sha256Test{
 
 func TestGolden(t *testing.T) {
 	for i := 0; i < len(golden); i++ {
-		g := golden[i];
-		c := New();
+		g := golden[i]
+		c := New()
 		for j := 0; j < 2; j++ {
-			io.WriteString(c, g.in);
-			s := fmt.Sprintf("%x", c.Sum());
+			io.WriteString(c, g.in)
+			s := fmt.Sprintf("%x", c.Sum())
 			if s != g.out {
-				t.Errorf("sha256[%d](%s) = %s want %s", j, g.in, s, g.out);
-				t.FailNow();
+				t.Errorf("sha256[%d](%s) = %s want %s", j, g.in, s, g.out)
+				t.FailNow()
 			}
-			c.Reset();
+			c.Reset()
 		}
 	}
 }
diff --git a/src/pkg/crypto/sha256/sha256block.go b/src/pkg/crypto/sha256/sha256block.go
index a00170859..7b0f55444 100644
--- a/src/pkg/crypto/sha256/sha256block.go
+++ b/src/pkg/crypto/sha256/sha256block.go
@@ -76,54 +76,54 @@ var _K = []uint32{
 }
 
 func _Block(dig *digest, p []byte) int {
-	var w [64]uint32;
-	n := 0;
-	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7];
+	var w [64]uint32
+	n := 0
+	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
 	for len(p) >= _Chunk {
 		// Can interlace the computation of w with the
 		// rounds below if needed for speed.
 		for i := 0; i < 16; i++ {
-			j := i * 4;
-			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]);
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
 		}
 		for i := 16; i < 64; i++ {
-			t1 := (w[i-2]>>17 | w[i-2]<<(32-17)) ^ (w[i-2]>>19 | w[i-2]<<(32-19)) ^ (w[i-2] >> 10);
+			t1 := (w[i-2]>>17 | w[i-2]<<(32-17)) ^ (w[i-2]>>19 | w[i-2]<<(32-19)) ^ (w[i-2] >> 10)
 
-			t2 := (w[i-15]>>7 | w[i-15]<<(32-7)) ^ (w[i-15]>>18 | w[i-15]<<(32-18)) ^ (w[i-15] >> 3);
+			t2 := (w[i-15]>>7 | w[i-15]<<(32-7)) ^ (w[i-15]>>18 | w[i-15]<<(32-18)) ^ (w[i-15] >> 3)
 
-			w[i] = t1 + w[i-7] + t2 + w[i-16];
+			w[i] = t1 + w[i-7] + t2 + w[i-16]
 		}
 
-		a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7;
+		a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
 
 		for i := 0; i < 64; i++ {
-			t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i];
+			t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
 
-			t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c));
+			t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
 
-			h = g;
-			g = f;
-			f = e;
-			e = d + t1;
-			d = c;
-			c = b;
-			b = a;
-			a = t1 + t2;
+			h = g
+			g = f
+			f = e
+			e = d + t1
+			d = c
+			c = b
+			b = a
+			a = t1 + t2
 		}
 
-		h0 += a;
-		h1 += b;
-		h2 += c;
-		h3 += d;
-		h4 += e;
-		h5 += f;
-		h6 += g;
-		h7 += h;
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
+		h5 += f
+		h6 += g
+		h7 += h
 
-		p = p[_Chunk:];
-		n += _Chunk;
+		p = p[_Chunk:]
+		n += _Chunk
 	}
 
-	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7;
-	return n;
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+	return n
 }
diff --git a/src/pkg/crypto/subtle/constant_time.go b/src/pkg/crypto/subtle/constant_time.go
index 79a96ec96..a3d70b9c9 100644
--- a/src/pkg/crypto/subtle/constant_time.go
+++ b/src/pkg/crypto/subtle/constant_time.go
@@ -10,48 +10,48 @@ package subtle
 // and y, have equal contents. The time taken is a function of the length of
 // the slices and is independent of the contents.
 func ConstantTimeCompare(x, y []byte) int {
-	var v byte;
+	var v byte
 
 	for i := 0; i < len(x); i++ {
 		v |= x[i] ^ y[i]
 	}
 
-	return ConstantTimeByteEq(v, 0);
+	return ConstantTimeByteEq(v, 0)
 }
 
 // ConstantTimeSelect returns x if v is 1 and y if v is 0.
 // Its behavior is undefined if v takes any other value.
-func ConstantTimeSelect(v, x, y int) int	{ return ^(v-1)&x | (v-1)&y }
+func ConstantTimeSelect(v, x, y int) int { return ^(v-1)&x | (v-1)&y }
 
 // ConstantTimeByteEq returns 1 if x == y and 0 otherwise.
 func ConstantTimeByteEq(x, y uint8) int {
-	z := ^(x ^ y);
-	z &= z >> 4;
-	z &= z >> 2;
-	z &= z >> 1;
+	z := ^(x ^ y)
+	z &= z >> 4
+	z &= z >> 2
+	z &= z >> 1
 
-	return int(z);
+	return int(z)
 }
 
 // ConstantTimeEq returns 1 if x == y and 0 otherwise.
 func ConstantTimeEq(x, y int32) int {
-	z := ^(x ^ y);
-	z &= z >> 16;
-	z &= z >> 8;
-	z &= z >> 4;
-	z &= z >> 2;
-	z &= z >> 1;
-
-	return int(z & 1);
+	z := ^(x ^ y)
+	z &= z >> 16
+	z &= z >> 8
+	z &= z >> 4
+	z &= z >> 2
+	z &= z >> 1
+
+	return int(z & 1)
 }
 
 // ConstantTimeCopy copies the contents of y into x iff v == 1. If v == 0, x is left unchanged.
 // Its behavior is undefined if v takes any other value.
 func ConstantTimeCopy(v int, x, y []byte) {
-	xmask := byte(v - 1);
-	ymask := byte(^(v - 1));
+	xmask := byte(v - 1)
+	ymask := byte(^(v - 1))
 	for i := 0; i < len(x); i++ {
 		x[i] = x[i]&xmask | y[i]&ymask
 	}
-	return;
+	return
 }
diff --git a/src/pkg/crypto/subtle/constant_time_test.go b/src/pkg/crypto/subtle/constant_time_test.go
index d9faafe5f..25962b9ae 100644
--- a/src/pkg/crypto/subtle/constant_time_test.go
+++ b/src/pkg/crypto/subtle/constant_time_test.go
@@ -5,13 +5,13 @@
 package subtle
 
 import (
-	"testing";
-	"testing/quick";
+	"testing"
+	"testing/quick"
 )
 
 type TestConstantTimeCompareStruct struct {
-	a, b	[]byte;
-	out	int;
+	a, b []byte
+	out  int
 }
 
 var testConstandTimeCompareData = []TestConstantTimeCompareStruct{
@@ -29,8 +29,8 @@ func TestConstantTimeCompare(t *testing.T) {
 }
 
 type TestConstantTimeByteEqStruct struct {
-	a, b	uint8;
-	out	int;
+	a, b uint8
+	out  int
 }
 
 var testConstandTimeByteEqData = []TestConstantTimeByteEqStruct{
@@ -45,7 +45,7 @@ func byteEq(a, b uint8) int {
 	if a == b {
 		return 1
 	}
-	return 0;
+	return 0
 }
 
 func TestConstantTimeByteEq(t *testing.T) {
@@ -54,7 +54,7 @@ func TestConstantTimeByteEq(t *testing.T) {
 			t.Errorf("#%d bad result (got %x, want %x)", i, r, test.out)
 		}
 	}
-	err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil);
+	err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -64,11 +64,11 @@ func eq(a, b int32) int {
 	if a == b {
 		return 1
 	}
-	return 0;
+	return 0
 }
 
 func TestConstantTimeEq(t *testing.T) {
-	err := quick.CheckEqual(ConstantTimeEq, eq, nil);
+	err := quick.CheckEqual(ConstantTimeEq, eq, nil)
 	if err != nil {
 		t.Error(err)
 	}
@@ -83,7 +83,7 @@ func makeCopy(v int, x, y []byte) []byte {
 	if v == 1 {
 		copy(x, y)
 	}
-	return x;
+	return x
 }
 
 func constantTimeCopyWrapper(v int, x, y []byte) []byte {
@@ -92,13 +92,13 @@ func constantTimeCopyWrapper(v int, x, y []byte) []byte {
 	} else {
 		y = y[0:len(x)]
 	}
-	v &= 1;
-	ConstantTimeCopy(v, x, y);
-	return x;
+	v &= 1
+	ConstantTimeCopy(v, x, y)
+	return x
 }
 
 func TestConstantTimeCopy(t *testing.T) {
-	err := quick.CheckEqual(constantTimeCopyWrapper, makeCopy, nil);
+	err := quick.CheckEqual(constantTimeCopyWrapper, makeCopy, nil)
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/src/pkg/crypto/tls/alert.go b/src/pkg/crypto/tls/alert.go
index 4cf62e7a4..2f740b39e 100644
--- a/src/pkg/crypto/tls/alert.go
+++ b/src/pkg/crypto/tls/alert.go
@@ -8,36 +8,36 @@ type alertLevel int
 type alertType int
 
 const (
-	alertLevelWarning	alertLevel	= 1;
-	alertLevelError		alertLevel	= 2;
+	alertLevelWarning alertLevel = 1
+	alertLevelError   alertLevel = 2
 )
 
 const (
-	alertCloseNotify		alertType	= 0;
-	alertUnexpectedMessage		alertType	= 10;
-	alertBadRecordMAC		alertType	= 20;
-	alertDecryptionFailed		alertType	= 21;
-	alertRecordOverflow		alertType	= 22;
-	alertDecompressionFailure	alertType	= 30;
-	alertHandshakeFailure		alertType	= 40;
-	alertBadCertificate		alertType	= 42;
-	alertUnsupportedCertificate	alertType	= 43;
-	alertCertificateRevoked		alertType	= 44;
-	alertCertificateExpired		alertType	= 45;
-	alertCertificateUnknown		alertType	= 46;
-	alertIllegalParameter		alertType	= 47;
-	alertUnknownCA			alertType	= 48;
-	alertAccessDenied		alertType	= 49;
-	alertDecodeError		alertType	= 50;
-	alertDecryptError		alertType	= 51;
-	alertProtocolVersion		alertType	= 70;
-	alertInsufficientSecurity	alertType	= 71;
-	alertInternalError		alertType	= 80;
-	alertUserCanceled		alertType	= 90;
-	alertNoRenegotiation		alertType	= 100;
+	alertCloseNotify            alertType = 0
+	alertUnexpectedMessage      alertType = 10
+	alertBadRecordMAC           alertType = 20
+	alertDecryptionFailed       alertType = 21
+	alertRecordOverflow         alertType = 22
+	alertDecompressionFailure   alertType = 30
+	alertHandshakeFailure       alertType = 40
+	alertBadCertificate         alertType = 42
+	alertUnsupportedCertificate alertType = 43
+	alertCertificateRevoked     alertType = 44
+	alertCertificateExpired     alertType = 45
+	alertCertificateUnknown     alertType = 46
+	alertIllegalParameter       alertType = 47
+	alertUnknownCA              alertType = 48
+	alertAccessDenied           alertType = 49
+	alertDecodeError            alertType = 50
+	alertDecryptError           alertType = 51
+	alertProtocolVersion        alertType = 70
+	alertInsufficientSecurity   alertType = 71
+	alertInternalError          alertType = 80
+	alertUserCanceled           alertType = 90
+	alertNoRenegotiation        alertType = 100
 )
 
 type alert struct {
-	level	alertLevel;
-	error	alertType;
+	level alertLevel
+	error alertType
 }
diff --git a/src/pkg/crypto/tls/ca_set.go b/src/pkg/crypto/tls/ca_set.go
index e8cddd6f4..00f6a8730 100644
--- a/src/pkg/crypto/tls/ca_set.go
+++ b/src/pkg/crypto/tls/ca_set.go
@@ -5,14 +5,14 @@
 package tls
 
 import (
-	"crypto/x509";
-	"encoding/pem";
+	"crypto/x509"
+	"encoding/pem"
 )
 
 // A CASet is a set of certificates.
 type CASet struct {
-	bySubjectKeyId	map[string]*x509.Certificate;
-	byName		map[string]*x509.Certificate;
+	bySubjectKeyId map[string]*x509.Certificate
+	byName         map[string]*x509.Certificate
 }
 
 func NewCASet() *CASet {
@@ -29,7 +29,7 @@ func nameToKey(name *x509.Name) string {
 // FindParent attempts to find the certificate in s which signs the given
 // certificate. If no such certificate can be found, it returns nil.
 func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) {
-	var ok bool;
+	var ok bool
 
 	if len(cert.AuthorityKeyId) > 0 {
 		parent, ok = s.bySubjectKeyId[string(cert.AuthorityKeyId)]
@@ -40,7 +40,7 @@ func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) {
 	if !ok {
 		return nil
 	}
-	return parent;
+	return parent
 }
 
 // SetFromPEM attempts to parse a series of PEM encoded root certificates. It
@@ -50,8 +50,8 @@ func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) {
 // function.
 func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) {
 	for len(pemCerts) > 0 {
-		var block *pem.Block;
-		block, pemCerts = pem.Decode(pemCerts);
+		var block *pem.Block
+		block, pemCerts = pem.Decode(pemCerts)
 		if block == nil {
 			break
 		}
@@ -59,7 +59,7 @@ func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) {
 			continue
 		}
 
-		cert, err := x509.ParseCertificate(block.Bytes);
+		cert, err := x509.ParseCertificate(block.Bytes)
 		if err != nil {
 			continue
 		}
@@ -67,9 +67,9 @@ func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) {
 		if len(cert.SubjectKeyId) > 0 {
 			s.bySubjectKeyId[string(cert.SubjectKeyId)] = cert
 		}
-		s.byName[nameToKey(&cert.Subject)] = cert;
-		ok = true;
+		s.byName[nameToKey(&cert.Subject)] = cert
+		ok = true
 	}
 
-	return;
+	return
 }
diff --git a/src/pkg/crypto/tls/common.go b/src/pkg/crypto/tls/common.go
index e1318a893..51de53389 100644
--- a/src/pkg/crypto/tls/common.go
+++ b/src/pkg/crypto/tls/common.go
@@ -5,21 +5,21 @@
 package tls
 
 import (
-	"crypto/rsa";
-	"io";
-	"os";
+	"crypto/rsa"
+	"io"
+	"os"
 )
 
 const (
 	// maxTLSCiphertext is the maximum length of a plaintext payload.
-	maxTLSPlaintext	= 16384;
+	maxTLSPlaintext = 16384
 	// maxTLSCiphertext is the maximum length payload after compression and encryption.
-	maxTLSCiphertext	= 16384 + 2048;
+	maxTLSCiphertext = 16384 + 2048
 	// maxHandshakeMsg is the largest single handshake message that we'll buffer.
-	maxHandshakeMsg	= 65536;
+	maxHandshakeMsg = 65536
 	// defaultMajor and defaultMinor are the maximum TLS version that we support.
-	defaultMajor	= 3;
-	defaultMinor	= 2;
+	defaultMajor = 3
+	defaultMinor = 2
 )
 
 
@@ -27,68 +27,68 @@ const (
 type recordType uint8
 
 const (
-	recordTypeChangeCipherSpec	recordType	= 20;
-	recordTypeAlert			recordType	= 21;
-	recordTypeHandshake		recordType	= 22;
-	recordTypeApplicationData	recordType	= 23;
+	recordTypeChangeCipherSpec recordType = 20
+	recordTypeAlert            recordType = 21
+	recordTypeHandshake        recordType = 22
+	recordTypeApplicationData  recordType = 23
 )
 
 // TLS handshake message types.
 const (
-	typeClientHello		uint8	= 1;
-	typeServerHello		uint8	= 2;
-	typeCertificate		uint8	= 11;
-	typeServerHelloDone	uint8	= 14;
-	typeClientKeyExchange	uint8	= 16;
-	typeFinished		uint8	= 20;
+	typeClientHello       uint8 = 1
+	typeServerHello       uint8 = 2
+	typeCertificate       uint8 = 11
+	typeServerHelloDone   uint8 = 14
+	typeClientKeyExchange uint8 = 16
+	typeFinished          uint8 = 20
 )
 
 // TLS cipher suites.
 var (
-	TLS_RSA_WITH_RC4_128_SHA uint16 = 5;
+	TLS_RSA_WITH_RC4_128_SHA uint16 = 5
 )
 
 // TLS compression types.
 var (
-	compressionNone uint8 = 0;
+	compressionNone uint8 = 0
 )
 
 type ConnectionState struct {
-	HandshakeComplete	bool;
-	CipherSuite		string;
-	Error			alertType;
+	HandshakeComplete bool
+	CipherSuite       string
+	Error             alertType
 }
 
 // A Config structure is used to configure a TLS client or server. After one
 // has been passed to a TLS function it must not be modified.
 type Config struct {
 	// Rand provides the source of entropy for nonces and RSA blinding.
-	Rand	io.Reader;
+	Rand io.Reader
 	// Time returns the current time as the number of seconds since the epoch.
-	Time		func() int64;
-	Certificates	[]Certificate;
-	RootCAs		*CASet;
+	Time         func() int64
+	Certificates []Certificate
+	RootCAs      *CASet
 }
 
 type Certificate struct {
-	Certificate	[][]byte;
-	PrivateKey	*rsa.PrivateKey;
+	Certificate [][]byte
+	PrivateKey  *rsa.PrivateKey
 }
 
 // A TLS record.
 type record struct {
-	contentType	recordType;
-	major, minor	uint8;
-	payload		[]byte;
+	contentType  recordType
+	major, minor uint8
+	payload      []byte
 }
 
 type handshakeMessage interface {
-	marshal() []byte;
+	marshal() []byte
 }
 
 type encryptor interface {
 	// XORKeyStream xors the contents of the slice with bytes from the key stream.
-	XORKeyStream(buf []byte);
+	XORKeyStream(buf []byte)
 }
 
 // mutualVersion returns the protocol version to use given the advertised
@@ -98,24 +98,24 @@ func mutualVersion(theirMajor, theirMinor uint8) (major, minor uint8, ok bool) {
 	if theirMajor < 3 || theirMajor == 3 && theirMinor < 1 {
 		return 0, 0, false
 	}
-	major = 3;
-	minor = 2;
+	major = 3
+	minor = 2
 	if theirMinor < minor {
 		minor = theirMinor
 	}
-	ok = true;
-	return;
+	ok = true
+	return
 }
 
 // A nop implements the NULL encryption and MAC algorithms.
 type nop struct{}
 
-func (nop) XORKeyStream(buf []byte)	{}
+func (nop) XORKeyStream(buf []byte) {}
 
-func (nop) Write(buf []byte) (int, os.Error)	{ return len(buf), nil }
+func (nop) Write(buf []byte) (int, os.Error) { return len(buf), nil }
 
-func (nop) Sum() []byte	{ return nil }
+func (nop) Sum() []byte { return nil }
 
-func (nop) Reset()	{}
+func (nop) Reset() {}
 
-func (nop) Size() int	{ return 0 }
+func (nop) Size() int { return 0 }
diff --git a/src/pkg/crypto/tls/handshake_client.go b/src/pkg/crypto/tls/handshake_client.go
index 1c6bd4b81..4e31e7094 100644
--- a/src/pkg/crypto/tls/handshake_client.go
+++ b/src/pkg/crypto/tls/handshake_client.go
@@ -5,33 +5,33 @@
 package tls
 
 import (
-	"crypto/hmac";
-	"crypto/rc4";
-	"crypto/rsa";
-	"crypto/sha1";
-	"crypto/subtle";
-	"crypto/x509";
-	"io";
+	"crypto/hmac"
+	"crypto/rc4"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/subtle"
+	"crypto/x509"
+	"io"
 )
 
 // A serverHandshake performs the server side of the TLS 1.1 handshake protocol.
 type clientHandshake struct {
-	writeChan	chan<- interface{};
-	controlChan	chan<- interface{};
-	msgChan		<-chan interface{};
-	config		*Config;
+	writeChan   chan<- interface{}
+	controlChan chan<- interface{}
+	msgChan     <-chan interface{}
+	config      *Config
 }
 
 func (h *clientHandshake) loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config) {
-	h.writeChan = writeChan;
-	h.controlChan = controlChan;
-	h.msgChan = msgChan;
-	h.config = config;
+	h.writeChan = writeChan
+	h.controlChan = controlChan
+	h.msgChan = msgChan
+	h.config = config
 
-	defer close(writeChan);
-	defer close(controlChan);
+	defer close(writeChan)
+	defer close(controlChan)
 
-	finishedHash := newFinishedHash();
+	finishedHash := newFinishedHash()
 
 	hello := &clientHelloMsg{
 		major: defaultMajor,
@@ -39,175 +39,175 @@ func (h *clientHandshake) loop(writeChan chan<- interface{}, controlChan chan<-
 		cipherSuites: []uint16{TLS_RSA_WITH_RC4_128_SHA},
 		compressionMethods: []uint8{compressionNone},
 		random: make([]byte, 32),
-	};
-
-	currentTime := uint32(config.Time());
-	hello.random[0] = byte(currentTime >> 24);
-	hello.random[1] = byte(currentTime >> 16);
-	hello.random[2] = byte(currentTime >> 8);
-	hello.random[3] = byte(currentTime);
-	_, err := io.ReadFull(config.Rand, hello.random[4:]);
+	}
+
+	currentTime := uint32(config.Time())
+	hello.random[0] = byte(currentTime >> 24)
+	hello.random[1] = byte(currentTime >> 16)
+	hello.random[2] = byte(currentTime >> 8)
+	hello.random[3] = byte(currentTime)
+	_, err := io.ReadFull(config.Rand, hello.random[4:])
 	if err != nil {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
 
-	finishedHash.Write(hello.marshal());
-	writeChan <- writerSetVersion{defaultMajor, defaultMinor};
-	writeChan <- hello;
+	finishedHash.Write(hello.marshal())
+	writeChan <- writerSetVersion{defaultMajor, defaultMinor}
+	writeChan <- hello
 
-	serverHello, ok := h.readHandshakeMsg().(*serverHelloMsg);
+	serverHello, ok := h.readHandshakeMsg().(*serverHelloMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
-	finishedHash.Write(serverHello.marshal());
-	major, minor, ok := mutualVersion(serverHello.major, serverHello.minor);
+	finishedHash.Write(serverHello.marshal())
+	major, minor, ok := mutualVersion(serverHello.major, serverHello.minor)
 	if !ok {
-		h.error(alertProtocolVersion);
-		return;
+		h.error(alertProtocolVersion)
+		return
 	}
 
-	writeChan <- writerSetVersion{major, minor};
+	writeChan <- writerSetVersion{major, minor}
 
 	if serverHello.cipherSuite != TLS_RSA_WITH_RC4_128_SHA ||
 		serverHello.compressionMethod != compressionNone {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
 
-	certMsg, ok := h.readHandshakeMsg().(*certificateMsg);
+	certMsg, ok := h.readHandshakeMsg().(*certificateMsg)
 	if !ok || len(certMsg.certificates) == 0 {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
-	finishedHash.Write(certMsg.marshal());
+	finishedHash.Write(certMsg.marshal())
 
-	certs := make([]*x509.Certificate, len(certMsg.certificates));
+	certs := make([]*x509.Certificate, len(certMsg.certificates))
 	for i, asn1Data := range certMsg.certificates {
-		cert, err := x509.ParseCertificate(asn1Data);
+		cert, err := x509.ParseCertificate(asn1Data)
 		if err != nil {
-			h.error(alertBadCertificate);
-			return;
+			h.error(alertBadCertificate)
+			return
 		}
-		certs[i] = cert;
+		certs[i] = cert
 	}
 
 	// TODO(agl): do better validation of certs: max path length, name restrictions etc.
 	for i := 1; i < len(certs); i++ {
 		if certs[i-1].CheckSignatureFrom(certs[i]) != nil {
-			h.error(alertBadCertificate);
-			return;
+			h.error(alertBadCertificate)
+			return
 		}
 	}
 
 	if config.RootCAs != nil {
-		root := config.RootCAs.FindParent(certs[len(certs)-1]);
+		root := config.RootCAs.FindParent(certs[len(certs)-1])
 		if root == nil {
-			h.error(alertBadCertificate);
-			return;
+			h.error(alertBadCertificate)
+			return
 		}
 		if certs[len(certs)-1].CheckSignatureFrom(root) != nil {
-			h.error(alertBadCertificate);
-			return;
+			h.error(alertBadCertificate)
+			return
 		}
 	}
 
-	pub, ok := certs[0].PublicKey.(*rsa.PublicKey);
+	pub, ok := certs[0].PublicKey.(*rsa.PublicKey)
 	if !ok {
-		h.error(alertUnsupportedCertificate);
-		return;
+		h.error(alertUnsupportedCertificate)
+		return
 	}
 
-	shd, ok := h.readHandshakeMsg().(*serverHelloDoneMsg);
+	shd, ok := h.readHandshakeMsg().(*serverHelloDoneMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
-	finishedHash.Write(shd.marshal());
+	finishedHash.Write(shd.marshal())
 
-	ckx := new(clientKeyExchangeMsg);
-	preMasterSecret := make([]byte, 48);
+	ckx := new(clientKeyExchangeMsg)
+	preMasterSecret := make([]byte, 48)
 	// Note that the version number in the preMasterSecret must be the
 	// version offered in the ClientHello.
-	preMasterSecret[0] = defaultMajor;
-	preMasterSecret[1] = defaultMinor;
-	_, err = io.ReadFull(config.Rand, preMasterSecret[2:]);
+	preMasterSecret[0] = defaultMajor
+	preMasterSecret[1] = defaultMinor
+	_, err = io.ReadFull(config.Rand, preMasterSecret[2:])
 	if err != nil {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
 
-	ckx.ciphertext, err = rsa.EncryptPKCS1v15(config.Rand, pub, preMasterSecret);
+	ckx.ciphertext, err = rsa.EncryptPKCS1v15(config.Rand, pub, preMasterSecret)
 	if err != nil {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
 
-	finishedHash.Write(ckx.marshal());
-	writeChan <- ckx;
+	finishedHash.Write(ckx.marshal())
+	writeChan <- ckx
 
-	suite := cipherSuites[0];
+	suite := cipherSuites[0]
 	masterSecret, clientMAC, serverMAC, clientKey, serverKey :=
-		keysFromPreMasterSecret11(preMasterSecret, hello.random, serverHello.random, suite.hashLength, suite.cipherKeyLength);
+		keysFromPreMasterSecret11(preMasterSecret, hello.random, serverHello.random, suite.hashLength, suite.cipherKeyLength)
 
-	cipher, _ := rc4.NewCipher(clientKey);
-	writeChan <- writerChangeCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)};
+	cipher, _ := rc4.NewCipher(clientKey)
+	writeChan <- writerChangeCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)}
 
-	finished := new(finishedMsg);
-	finished.verifyData = finishedHash.clientSum(masterSecret);
-	finishedHash.Write(finished.marshal());
-	writeChan <- finished;
+	finished := new(finishedMsg)
+	finished.verifyData = finishedHash.clientSum(masterSecret)
+	finishedHash.Write(finished.marshal())
+	writeChan <- finished
 
 	// TODO(agl): this is cut-through mode which should probably be an option.
-	writeChan <- writerEnableApplicationData{};
+	writeChan <- writerEnableApplicationData{}
 
-	_, ok = h.readHandshakeMsg().(changeCipherSpec);
+	_, ok = h.readHandshakeMsg().(changeCipherSpec)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
 
-	cipher2, _ := rc4.NewCipher(serverKey);
-	controlChan <- &newCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)};
+	cipher2, _ := rc4.NewCipher(serverKey)
+	controlChan <- &newCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)}
 
-	serverFinished, ok := h.readHandshakeMsg().(*finishedMsg);
+	serverFinished, ok := h.readHandshakeMsg().(*finishedMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
 
-	verify := finishedHash.serverSum(masterSecret);
+	verify := finishedHash.serverSum(masterSecret)
 	if len(verify) != len(serverFinished.verifyData) ||
 		subtle.ConstantTimeCompare(verify, serverFinished.verifyData) != 1 {
-		h.error(alertHandshakeFailure);
-		return;
+		h.error(alertHandshakeFailure)
+		return
 	}
 
-	controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0};
+	controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}
 
 	// This should just block forever.
-	_ = h.readHandshakeMsg();
-	h.error(alertUnexpectedMessage);
-	return;
+	_ = h.readHandshakeMsg()
+	h.error(alertUnexpectedMessage)
+	return
 }
 
 func (h *clientHandshake) readHandshakeMsg() interface{} {
-	v := <-h.msgChan;
+	v := <-h.msgChan
 	if closed(h.msgChan) {
 		// If the channel closed then the processor received an error
 		// from the peer and we don't want to echo it back to them.
-		h.msgChan = nil;
-		return 0;
+		h.msgChan = nil
+		return 0
 	}
 	if _, ok := v.(alert); ok {
 		// We got an alert from the processor. We forward to the writer
 		// and shutdown.
-		h.writeChan <- v;
-		h.msgChan = nil;
-		return 0;
+		h.writeChan <- v
+		h.msgChan = nil
+		return 0
 	}
-	return v;
+	return v
 }
 
 func (h *clientHandshake) error(e alertType) {
@@ -217,9 +217,9 @@ func (h *clientHandshake) error(e alertType) {
 		go func() {
 			for _ = range h.msgChan {
 			}
-		}();
-		h.controlChan <- ConnectionState{false, "", e};
-		close(h.controlChan);
-		h.writeChan <- alert{alertLevelError, e};
+		}()
+		h.controlChan <- ConnectionState{false, "", e}
+		close(h.controlChan)
+		h.writeChan <- alert{alertLevelError, e}
 	}
 }
diff --git a/src/pkg/crypto/tls/handshake_messages.go b/src/pkg/crypto/tls/handshake_messages.go
index b5f2aa731..2870969eb 100644
--- a/src/pkg/crypto/tls/handshake_messages.go
+++ b/src/pkg/crypto/tls/handshake_messages.go
@@ -5,12 +5,12 @@
 package tls
 
 type clientHelloMsg struct {
-	raw			[]byte;
-	major, minor		uint8;
-	random			[]byte;
-	sessionId		[]byte;
-	cipherSuites		[]uint16;
-	compressionMethods	[]uint8;
+	raw                []byte
+	major, minor       uint8
+	random             []byte
+	sessionId          []byte
+	cipherSuites       []uint16
+	compressionMethods []uint8
 }
 
 func (m *clientHelloMsg) marshal() []byte {
@@ -18,81 +18,81 @@ func (m *clientHelloMsg) marshal() []byte {
 		return m.raw
 	}
 
-	length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods);
-	x := make([]byte, 4+length);
-	x[0] = typeClientHello;
-	x[1] = uint8(length >> 16);
-	x[2] = uint8(length >> 8);
-	x[3] = uint8(length);
-	x[4] = m.major;
-	x[5] = m.minor;
-	copy(x[6:38], m.random);
-	x[38] = uint8(len(m.sessionId));
-	copy(x[39:39+len(m.sessionId)], m.sessionId);
-	y := x[39+len(m.sessionId):];
-	y[0] = uint8(len(m.cipherSuites) >> 7);
-	y[1] = uint8(len(m.cipherSuites) << 1);
+	length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods)
+	x := make([]byte, 4+length)
+	x[0] = typeClientHello
+	x[1] = uint8(length >> 16)
+	x[2] = uint8(length >> 8)
+	x[3] = uint8(length)
+	x[4] = m.major
+	x[5] = m.minor
+	copy(x[6:38], m.random)
+	x[38] = uint8(len(m.sessionId))
+	copy(x[39:39+len(m.sessionId)], m.sessionId)
+	y := x[39+len(m.sessionId):]
+	y[0] = uint8(len(m.cipherSuites) >> 7)
+	y[1] = uint8(len(m.cipherSuites) << 1)
 	for i, suite := range m.cipherSuites {
-		y[2+i*2] = uint8(suite >> 8);
-		y[3+i*2] = uint8(suite);
+		y[2+i*2] = uint8(suite >> 8)
+		y[3+i*2] = uint8(suite)
 	}
-	z := y[2+len(m.cipherSuites)*2:];
-	z[0] = uint8(len(m.compressionMethods));
-	copy(z[1:], m.compressionMethods);
-	m.raw = x;
+	z := y[2+len(m.cipherSuites)*2:]
+	z[0] = uint8(len(m.compressionMethods))
+	copy(z[1:], m.compressionMethods)
+	m.raw = x
 
-	return x;
+	return x
 }
 
 func (m *clientHelloMsg) unmarshal(data []byte) bool {
 	if len(data) < 43 {
 		return false
 	}
-	m.raw = data;
-	m.major = data[4];
-	m.minor = data[5];
-	m.random = data[6:38];
-	sessionIdLen := int(data[38]);
+	m.raw = data
+	m.major = data[4]
+	m.minor = data[5]
+	m.random = data[6:38]
+	sessionIdLen := int(data[38])
 	if sessionIdLen > 32 || len(data) < 39+sessionIdLen {
 		return false
 	}
-	m.sessionId = data[39 : 39+sessionIdLen];
-	data = data[39+sessionIdLen:];
+	m.sessionId = data[39 : 39+sessionIdLen]
+	data = data[39+sessionIdLen:]
 	if len(data) < 2 {
 		return false
 	}
 	// cipherSuiteLen is the number of bytes of cipher suite numbers. Since
 	// they are uint16s, the number must be even.
-	cipherSuiteLen := int(data[0])<<8 | int(data[1]);
+	cipherSuiteLen := int(data[0])<<8 | int(data[1])
 	if cipherSuiteLen%2 == 1 || len(data) < 2+cipherSuiteLen {
 		return false
 	}
-	numCipherSuites := cipherSuiteLen / 2;
-	m.cipherSuites = make([]uint16, numCipherSuites);
+	numCipherSuites := cipherSuiteLen / 2
+	m.cipherSuites = make([]uint16, numCipherSuites)
 	for i := 0; i < numCipherSuites; i++ {
 		m.cipherSuites[i] = uint16(data[2+2*i])<<8 | uint16(data[3+2*i])
 	}
-	data = data[2+cipherSuiteLen:];
+	data = data[2+cipherSuiteLen:]
 	if len(data) < 2 {
 		return false
 	}
-	compressionMethodsLen := int(data[0]);
+	compressionMethodsLen := int(data[0])
 	if len(data) < 1+compressionMethodsLen {
 		return false
 	}
-	m.compressionMethods = data[1 : 1+compressionMethodsLen];
+	m.compressionMethods = data[1 : 1+compressionMethodsLen]
 
 	// A ClientHello may be following by trailing data: RFC 4346 section 7.4.1.2
-	return true;
+	return true
 }
 
 type serverHelloMsg struct {
-	raw			[]byte;
-	major, minor		uint8;
-	random			[]byte;
-	sessionId		[]byte;
-	cipherSuite		uint16;
-	compressionMethod	uint8;
+	raw               []byte
+	major, minor      uint8
+	random            []byte
+	sessionId         []byte
+	cipherSuite       uint16
+	compressionMethod uint8
 }
 
 func (m *serverHelloMsg) marshal() []byte {
@@ -100,53 +100,53 @@ func (m *serverHelloMsg) marshal() []byte {
 		return m.raw
 	}
 
-	length := 38 + len(m.sessionId);
-	x := make([]byte, 4+length);
-	x[0] = typeServerHello;
-	x[1] = uint8(length >> 16);
-	x[2] = uint8(length >> 8);
-	x[3] = uint8(length);
-	x[4] = m.major;
-	x[5] = m.minor;
-	copy(x[6:38], m.random);
-	x[38] = uint8(len(m.sessionId));
-	copy(x[39:39+len(m.sessionId)], m.sessionId);
-	z := x[39+len(m.sessionId):];
-	z[0] = uint8(m.cipherSuite >> 8);
-	z[1] = uint8(m.cipherSuite);
-	z[2] = uint8(m.compressionMethod);
-	m.raw = x;
-
-	return x;
+	length := 38 + len(m.sessionId)
+	x := make([]byte, 4+length)
+	x[0] = typeServerHello
+	x[1] = uint8(length >> 16)
+	x[2] = uint8(length >> 8)
+	x[3] = uint8(length)
+	x[4] = m.major
+	x[5] = m.minor
+	copy(x[6:38], m.random)
+	x[38] = uint8(len(m.sessionId))
+	copy(x[39:39+len(m.sessionId)], m.sessionId)
+	z := x[39+len(m.sessionId):]
+	z[0] = uint8(m.cipherSuite >> 8)
+	z[1] = uint8(m.cipherSuite)
+	z[2] = uint8(m.compressionMethod)
+	m.raw = x
+
+	return x
 }
 
 func (m *serverHelloMsg) unmarshal(data []byte) bool {
 	if len(data) < 42 {
 		return false
 	}
-	m.raw = data;
-	m.major = data[4];
-	m.minor = data[5];
-	m.random = data[6:38];
-	sessionIdLen := int(data[38]);
+	m.raw = data
+	m.major = data[4]
+	m.minor = data[5]
+	m.random = data[6:38]
+	sessionIdLen := int(data[38])
 	if sessionIdLen > 32 || len(data) < 39+sessionIdLen {
 		return false
 	}
-	m.sessionId = data[39 : 39+sessionIdLen];
-	data = data[39+sessionIdLen:];
+	m.sessionId = data[39 : 39+sessionIdLen]
+	data = data[39+sessionIdLen:]
 	if len(data) < 3 {
 		return false
 	}
-	m.cipherSuite = uint16(data[0])<<8 | uint16(data[1]);
-	m.compressionMethod = data[2];
+	m.cipherSuite = uint16(data[0])<<8 | uint16(data[1])
+	m.compressionMethod = data[2]
 
 	// Trailing data is allowed because extensions may be present.
-	return true;
+	return true
 }
 
 type certificateMsg struct {
-	raw		[]byte;
-	certificates	[][]byte;
+	raw          []byte
+	certificates [][]byte
 }
 
 func (m *certificateMsg) marshal() (x []byte) {
@@ -154,34 +154,34 @@ func (m *certificateMsg) marshal() (x []byte) {
 		return m.raw
 	}
 
-	var i int;
+	var i int
 	for _, slice := range m.certificates {
 		i += len(slice)
 	}
 
-	length := 3 + 3*len(m.certificates) + i;
-	x = make([]byte, 4+length);
-	x[0] = typeCertificate;
-	x[1] = uint8(length >> 16);
-	x[2] = uint8(length >> 8);
-	x[3] = uint8(length);
+	length := 3 + 3*len(m.certificates) + i
+	x = make([]byte, 4+length)
+	x[0] = typeCertificate
+	x[1] = uint8(length >> 16)
+	x[2] = uint8(length >> 8)
+	x[3] = uint8(length)
 
-	certificateOctets := length - 3;
-	x[4] = uint8(certificateOctets >> 16);
-	x[5] = uint8(certificateOctets >> 8);
-	x[6] = uint8(certificateOctets);
+	certificateOctets := length - 3
+	x[4] = uint8(certificateOctets >> 16)
+	x[5] = uint8(certificateOctets >> 8)
+	x[6] = uint8(certificateOctets)
 
-	y := x[7:];
+	y := x[7:]
 	for _, slice := range m.certificates {
-		y[0] = uint8(len(slice) >> 16);
-		y[1] = uint8(len(slice) >> 8);
-		y[2] = uint8(len(slice));
-		copy(y[3:], slice);
-		y = y[3+len(slice):];
+		y[0] = uint8(len(slice) >> 16)
+		y[1] = uint8(len(slice) >> 8)
+		y[2] = uint8(len(slice))
+		copy(y[3:], slice)
+		y = y[3+len(slice):]
 	}
 
-	m.raw = x;
-	return;
+	m.raw = x
+	return
 }
 
 func (m *certificateMsg) unmarshal(data []byte) bool {
@@ -189,44 +189,44 @@ func (m *certificateMsg) unmarshal(data []byte) bool {
 		return false
 	}
 
-	m.raw = data;
-	certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6]);
+	m.raw = data
+	certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6])
 	if uint32(len(data)) != certsLen+7 {
 		return false
 	}
 
-	numCerts := 0;
-	d := data[7:];
+	numCerts := 0
+	d := data[7:]
 	for certsLen > 0 {
 		if len(d) < 4 {
 			return false
 		}
-		certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]);
+		certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2])
 		if uint32(len(d)) < 3+certLen {
 			return false
 		}
-		d = d[3+certLen:];
-		certsLen -= 3 + certLen;
-		numCerts++;
+		d = d[3+certLen:]
+		certsLen -= 3 + certLen
+		numCerts++
 	}
 
-	m.certificates = make([][]byte, numCerts);
-	d = data[7:];
+	m.certificates = make([][]byte, numCerts)
+	d = data[7:]
 	for i := 0; i < numCerts; i++ {
-		certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]);
-		m.certificates[i] = d[3 : 3+certLen];
-		d = d[3+certLen:];
+		certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2])
+		m.certificates[i] = d[3 : 3+certLen]
+		d = d[3+certLen:]
 	}
 
-	return true;
+	return true
 }
 
 type serverHelloDoneMsg struct{}
 
 func (m *serverHelloDoneMsg) marshal() []byte {
-	x := make([]byte, 4);
-	x[0] = typeServerHelloDone;
-	return x;
+	x := make([]byte, 4)
+	x[0] = typeServerHelloDone
+	return x
 }
 
 func (m *serverHelloDoneMsg) unmarshal(data []byte) bool {
@@ -234,44 +234,44 @@ func (m *serverHelloDoneMsg) unmarshal(data []byte) bool {
 }
 
 type clientKeyExchangeMsg struct {
-	raw		[]byte;
-	ciphertext	[]byte;
+	raw        []byte
+	ciphertext []byte
 }
 
 func (m *clientKeyExchangeMsg) marshal() []byte {
 	if m.raw != nil {
 		return m.raw
 	}
-	length := len(m.ciphertext) + 2;
-	x := make([]byte, length+4);
-	x[0] = typeClientKeyExchange;
-	x[1] = uint8(length >> 16);
-	x[2] = uint8(length >> 8);
-	x[3] = uint8(length);
-	x[4] = uint8(len(m.ciphertext) >> 8);
-	x[5] = uint8(len(m.ciphertext));
-	copy(x[6:], m.ciphertext);
-
-	m.raw = x;
-	return x;
+	length := len(m.ciphertext) + 2
+	x := make([]byte, length+4)
+	x[0] = typeClientKeyExchange
+	x[1] = uint8(length >> 16)
+	x[2] = uint8(length >> 8)
+	x[3] = uint8(length)
+	x[4] = uint8(len(m.ciphertext) >> 8)
+	x[5] = uint8(len(m.ciphertext))
+	copy(x[6:], m.ciphertext)
+
+	m.raw = x
+	return x
 }
 
 func (m *clientKeyExchangeMsg) unmarshal(data []byte) bool {
-	m.raw = data;
+	m.raw = data
 	if len(data) < 7 {
 		return false
 	}
-	cipherTextLen := int(data[4])<<8 | int(data[5]);
+	cipherTextLen := int(data[4])<<8 | int(data[5])
 	if len(data) != 6+cipherTextLen {
 		return false
 	}
-	m.ciphertext = data[6:];
-	return true;
+	m.ciphertext = data[6:]
+	return true
 }
 
 type finishedMsg struct {
-	raw		[]byte;
-	verifyData	[]byte;
+	raw        []byte
+	verifyData []byte
 }
 
 func (m *finishedMsg) marshal() (x []byte) {
@@ -279,19 +279,19 @@ func (m *finishedMsg) marshal() (x []byte) {
 		return m.raw
 	}
 
-	x = make([]byte, 16);
-	x[0] = typeFinished;
-	x[3] = 12;
-	copy(x[4:], m.verifyData);
-	m.raw = x;
-	return;
+	x = make([]byte, 16)
+	x[0] = typeFinished
+	x[3] = 12
+	copy(x[4:], m.verifyData)
+	m.raw = x
+	return
 }
 
 func (m *finishedMsg) unmarshal(data []byte) bool {
-	m.raw = data;
+	m.raw = data
 	if len(data) != 4+12 {
 		return false
 	}
-	m.verifyData = data[4:];
-	return true;
+	m.verifyData = data[4:]
+	return true
 }
diff --git a/src/pkg/crypto/tls/handshake_messages_test.go b/src/pkg/crypto/tls/handshake_messages_test.go
index c580f65c6..4bfdd6c5f 100644
--- a/src/pkg/crypto/tls/handshake_messages_test.go
+++ b/src/pkg/crypto/tls/handshake_messages_test.go
@@ -5,10 +5,10 @@
 package tls
 
 import (
-	"rand";
-	"reflect";
-	"testing";
-	"testing/quick";
+	"rand"
+	"reflect"
+	"testing"
+	"testing/quick"
 )
 
 var tests = []interface{}{
@@ -20,41 +20,41 @@ var tests = []interface{}{
 }
 
 type testMessage interface {
-	marshal() []byte;
-	unmarshal([]byte) bool;
+	marshal() []byte
+	unmarshal([]byte) bool
 }
 
 func TestMarshalUnmarshal(t *testing.T) {
-	rand := rand.New(rand.NewSource(0));
+	rand := rand.New(rand.NewSource(0))
 	for i, iface := range tests {
-		ty := reflect.NewValue(iface).Type();
+		ty := reflect.NewValue(iface).Type()
 
 		for j := 0; j < 100; j++ {
-			v, ok := quick.Value(ty, rand);
+			v, ok := quick.Value(ty, rand)
 			if !ok {
-				t.Errorf("#%d: failed to create value", i);
-				break;
+				t.Errorf("#%d: failed to create value", i)
+				break
 			}
 
-			m1 := v.Interface().(testMessage);
-			marshaled := m1.marshal();
-			m2 := iface.(testMessage);
+			m1 := v.Interface().(testMessage)
+			marshaled := m1.marshal()
+			m2 := iface.(testMessage)
 			if !m2.unmarshal(marshaled) {
-				t.Errorf("#%d failed to unmarshal %#v", i, m1);
-				break;
+				t.Errorf("#%d failed to unmarshal %#v", i, m1)
+				break
 			}
-			m2.marshal();	// to fill any marshal cache in the message
+			m2.marshal() // to fill any marshal cache in the message
 
 			if !reflect.DeepEqual(m1, m2) {
-				t.Errorf("#%d got:%#v want:%#v", i, m1, m2);
-				break;
+				t.Errorf("#%d got:%#v want:%#v", i, m1, m2)
+				break
 			}
 
 			// Now check that all prefixes are invalid.
 			for j := 0; j < len(marshaled); j++ {
 				if m2.unmarshal(marshaled[0:j]) {
-					t.Errorf("#%d unmarshaled a prefix of length %d of %#v", i, j, m1);
-					break;
+					t.Errorf("#%d unmarshaled a prefix of length %d of %#v", i, j, m1)
+					break
 				}
 			}
 		}
@@ -62,71 +62,71 @@ func TestMarshalUnmarshal(t *testing.T) {
 }
 
 func TestFuzz(t *testing.T) {
-	rand := rand.New(rand.NewSource(0));
+	rand := rand.New(rand.NewSource(0))
 	for _, iface := range tests {
-		m := iface.(testMessage);
+		m := iface.(testMessage)
 
 		for j := 0; j < 1000; j++ {
-			len := rand.Intn(100);
-			bytes := randomBytes(len, rand);
+			len := rand.Intn(100)
+			bytes := randomBytes(len, rand)
 			// This just looks for crashes due to bounds errors etc.
-			m.unmarshal(bytes);
+			m.unmarshal(bytes)
 		}
 	}
 }
 
 func randomBytes(n int, rand *rand.Rand) []byte {
-	r := make([]byte, n);
+	r := make([]byte, n)
 	for i := 0; i < n; i++ {
 		r[i] = byte(rand.Int31())
 	}
-	return r;
+	return r
 }
 
 func (*clientHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value {
-	m := &clientHelloMsg{};
-	m.major = uint8(rand.Intn(256));
-	m.minor = uint8(rand.Intn(256));
-	m.random = randomBytes(32, rand);
-	m.sessionId = randomBytes(rand.Intn(32), rand);
-	m.cipherSuites = make([]uint16, rand.Intn(63)+1);
+	m := &clientHelloMsg{}
+	m.major = uint8(rand.Intn(256))
+	m.minor = uint8(rand.Intn(256))
+	m.random = randomBytes(32, rand)
+	m.sessionId = randomBytes(rand.Intn(32), rand)
+	m.cipherSuites = make([]uint16, rand.Intn(63)+1)
 	for i := 0; i < len(m.cipherSuites); i++ {
 		m.cipherSuites[i] = uint16(rand.Int31())
 	}
-	m.compressionMethods = randomBytes(rand.Intn(63)+1, rand);
+	m.compressionMethods = randomBytes(rand.Intn(63)+1, rand)
 
-	return reflect.NewValue(m);
+	return reflect.NewValue(m)
 }
 
 func (*serverHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value {
-	m := &serverHelloMsg{};
-	m.major = uint8(rand.Intn(256));
-	m.minor = uint8(rand.Intn(256));
-	m.random = randomBytes(32, rand);
-	m.sessionId = randomBytes(rand.Intn(32), rand);
-	m.cipherSuite = uint16(rand.Int31());
-	m.compressionMethod = uint8(rand.Intn(256));
-	return reflect.NewValue(m);
+	m := &serverHelloMsg{}
+	m.major = uint8(rand.Intn(256))
+	m.minor = uint8(rand.Intn(256))
+	m.random = randomBytes(32, rand)
+	m.sessionId = randomBytes(rand.Intn(32), rand)
+	m.cipherSuite = uint16(rand.Int31())
+	m.compressionMethod = uint8(rand.Intn(256))
+	return reflect.NewValue(m)
 }
 
 func (*certificateMsg) Generate(rand *rand.Rand, size int) reflect.Value {
-	m := &certificateMsg{};
-	numCerts := rand.Intn(20);
-	m.certificates = make([][]byte, numCerts);
+	m := &certificateMsg{}
+	numCerts := rand.Intn(20)
+	m.certificates = make([][]byte, numCerts)
 	for i := 0; i < numCerts; i++ {
 		m.certificates[i] = randomBytes(rand.Intn(10)+1, rand)
 	}
-	return reflect.NewValue(m);
+	return reflect.NewValue(m)
 }
 
 func (*clientKeyExchangeMsg) Generate(rand *rand.Rand, size int) reflect.Value {
-	m := &clientKeyExchangeMsg{};
-	m.ciphertext = randomBytes(rand.Intn(1000)+1, rand);
-	return reflect.NewValue(m);
+	m := &clientKeyExchangeMsg{}
+	m.ciphertext = randomBytes(rand.Intn(1000)+1, rand)
+	return reflect.NewValue(m)
 }
 
 func (*finishedMsg) Generate(rand *rand.Rand, size int) reflect.Value {
-	m := &finishedMsg{};
-	m.verifyData = randomBytes(12, rand);
-	return reflect.NewValue(m);
+	m := &finishedMsg{}
+	m.verifyData = randomBytes(12, rand)
+	return reflect.NewValue(m)
 }
diff --git a/src/pkg/crypto/tls/handshake_server.go b/src/pkg/crypto/tls/handshake_server.go
index 2e7760365..5314e5cd1 100644
--- a/src/pkg/crypto/tls/handshake_server.go
+++ b/src/pkg/crypto/tls/handshake_server.go
@@ -13,17 +13,17 @@ package tls
 // channel in the message (ChangeCipherSpec).
 
 import (
-	"crypto/hmac";
-	"crypto/rc4";
-	"crypto/rsa";
-	"crypto/sha1";
-	"crypto/subtle";
-	"io";
+	"crypto/hmac"
+	"crypto/rc4"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/subtle"
+	"io"
 )
 
 type cipherSuite struct {
-	id				uint16;	// The number of this suite on the wire.
-	hashLength, cipherKeyLength	int;
+	id                          uint16 // The number of this suite on the wire.
+	hashLength, cipherKeyLength int
 	// TODO(agl): need a method to create the cipher and hash interfaces.
 }
 
@@ -33,118 +33,118 @@ var cipherSuites = []cipherSuite{
 
 // A serverHandshake performs the server side of the TLS 1.1 handshake protocol.
 type serverHandshake struct {
-	writeChan	chan<- interface{};
-	controlChan	chan<- interface{};
-	msgChan		<-chan interface{};
-	config		*Config;
+	writeChan   chan<- interface{}
+	controlChan chan<- interface{}
+	msgChan     <-chan interface{}
+	config      *Config
 }
 
 func (h *serverHandshake) loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config) {
-	h.writeChan = writeChan;
-	h.controlChan = controlChan;
-	h.msgChan = msgChan;
-	h.config = config;
+	h.writeChan = writeChan
+	h.controlChan = controlChan
+	h.msgChan = msgChan
+	h.config = config
 
-	defer close(writeChan);
-	defer close(controlChan);
+	defer close(writeChan)
+	defer close(controlChan)
 
-	clientHello, ok := h.readHandshakeMsg().(*clientHelloMsg);
+	clientHello, ok := h.readHandshakeMsg().(*clientHelloMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
-	major, minor, ok := mutualVersion(clientHello.major, clientHello.minor);
+	major, minor, ok := mutualVersion(clientHello.major, clientHello.minor)
 	if !ok {
-		h.error(alertProtocolVersion);
-		return;
+		h.error(alertProtocolVersion)
+		return
 	}
 
-	finishedHash := newFinishedHash();
-	finishedHash.Write(clientHello.marshal());
+	finishedHash := newFinishedHash()
+	finishedHash.Write(clientHello.marshal())
 
-	hello := new(serverHelloMsg);
+	hello := new(serverHelloMsg)
 
 	// We only support a single ciphersuite so we look for it in the list
 	// of client supported suites.
 	//
 	// TODO(agl): Add additional cipher suites.
-	var suite *cipherSuite;
+	var suite *cipherSuite
 
 	for _, id := range clientHello.cipherSuites {
 		for _, supported := range cipherSuites {
 			if supported.id == id {
-				suite = &supported;
-				break;
+				suite = &supported
+				break
 			}
 		}
 	}
 
-	foundCompression := false;
+	foundCompression := false
 	// We only support null compression, so check that the client offered it.
 	for _, compression := range clientHello.compressionMethods {
 		if compression == compressionNone {
-			foundCompression = true;
-			break;
+			foundCompression = true
+			break
 		}
 	}
 
 	if suite == nil || !foundCompression {
-		h.error(alertHandshakeFailure);
-		return;
-	}
-
-	hello.major = major;
-	hello.minor = minor;
-	hello.cipherSuite = suite.id;
-	currentTime := uint32(config.Time());
-	hello.random = make([]byte, 32);
-	hello.random[0] = byte(currentTime >> 24);
-	hello.random[1] = byte(currentTime >> 16);
-	hello.random[2] = byte(currentTime >> 8);
-	hello.random[3] = byte(currentTime);
-	_, err := io.ReadFull(config.Rand, hello.random[4:]);
+		h.error(alertHandshakeFailure)
+		return
+	}
+
+	hello.major = major
+	hello.minor = minor
+	hello.cipherSuite = suite.id
+	currentTime := uint32(config.Time())
+	hello.random = make([]byte, 32)
+	hello.random[0] = byte(currentTime >> 24)
+	hello.random[1] = byte(currentTime >> 16)
+	hello.random[2] = byte(currentTime >> 8)
+	hello.random[3] = byte(currentTime)
+	_, err := io.ReadFull(config.Rand, hello.random[4:])
 	if err != nil {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
-	hello.compressionMethod = compressionNone;
+	hello.compressionMethod = compressionNone
 
-	finishedHash.Write(hello.marshal());
-	writeChan <- writerSetVersion{major, minor};
-	writeChan <- hello;
+	finishedHash.Write(hello.marshal())
+	writeChan <- writerSetVersion{major, minor}
+	writeChan <- hello
 
 	if len(config.Certificates) == 0 {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
 
-	certMsg := new(certificateMsg);
-	certMsg.certificates = config.Certificates[0].Certificate;
-	finishedHash.Write(certMsg.marshal());
-	writeChan <- certMsg;
+	certMsg := new(certificateMsg)
+	certMsg.certificates = config.Certificates[0].Certificate
+	finishedHash.Write(certMsg.marshal())
+	writeChan <- certMsg
 
-	helloDone := new(serverHelloDoneMsg);
-	finishedHash.Write(helloDone.marshal());
-	writeChan <- helloDone;
+	helloDone := new(serverHelloDoneMsg)
+	finishedHash.Write(helloDone.marshal())
+	writeChan <- helloDone
 
-	ckx, ok := h.readHandshakeMsg().(*clientKeyExchangeMsg);
+	ckx, ok := h.readHandshakeMsg().(*clientKeyExchangeMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
-	finishedHash.Write(ckx.marshal());
+	finishedHash.Write(ckx.marshal())
 
-	preMasterSecret := make([]byte, 48);
-	_, err = io.ReadFull(config.Rand, preMasterSecret[2:]);
+	preMasterSecret := make([]byte, 48)
+	_, err = io.ReadFull(config.Rand, preMasterSecret[2:])
 	if err != nil {
-		h.error(alertInternalError);
-		return;
+		h.error(alertInternalError)
+		return
 	}
 
-	err = rsa.DecryptPKCS1v15SessionKey(config.Rand, config.Certificates[0].PrivateKey, ckx.ciphertext, preMasterSecret);
+	err = rsa.DecryptPKCS1v15SessionKey(config.Rand, config.Certificates[0].PrivateKey, ckx.ciphertext, preMasterSecret)
 	if err != nil {
-		h.error(alertHandshakeFailure);
-		return;
+		h.error(alertHandshakeFailure)
+		return
 	}
 	// We don't check the version number in the premaster secret. For one,
 	// by checking it, we would leak information about the validity of the
@@ -154,70 +154,70 @@ func (h *serverHandshake) loop(writeChan chan<- interface{}, controlChan chan<-
 	// 7.4.7.1 of RFC 4346.
 
 	masterSecret, clientMAC, serverMAC, clientKey, serverKey :=
-		keysFromPreMasterSecret11(preMasterSecret, clientHello.random, hello.random, suite.hashLength, suite.cipherKeyLength);
+		keysFromPreMasterSecret11(preMasterSecret, clientHello.random, hello.random, suite.hashLength, suite.cipherKeyLength)
 
-	_, ok = h.readHandshakeMsg().(changeCipherSpec);
+	_, ok = h.readHandshakeMsg().(changeCipherSpec)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
 
-	cipher, _ := rc4.NewCipher(clientKey);
-	controlChan <- &newCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)};
+	cipher, _ := rc4.NewCipher(clientKey)
+	controlChan <- &newCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)}
 
-	clientFinished, ok := h.readHandshakeMsg().(*finishedMsg);
+	clientFinished, ok := h.readHandshakeMsg().(*finishedMsg)
 	if !ok {
-		h.error(alertUnexpectedMessage);
-		return;
+		h.error(alertUnexpectedMessage)
+		return
 	}
 
-	verify := finishedHash.clientSum(masterSecret);
+	verify := finishedHash.clientSum(masterSecret)
 	if len(verify) != len(clientFinished.verifyData) ||
 		subtle.ConstantTimeCompare(verify, clientFinished.verifyData) != 1 {
-		h.error(alertHandshakeFailure);
-		return;
+		h.error(alertHandshakeFailure)
+		return
 	}
 
-	controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0};
+	controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}
 
-	finishedHash.Write(clientFinished.marshal());
+	finishedHash.Write(clientFinished.marshal())
 
-	cipher2, _ := rc4.NewCipher(serverKey);
-	writeChan <- writerChangeCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)};
+	cipher2, _ := rc4.NewCipher(serverKey)
+	writeChan <- writerChangeCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)}
 
-	finished := new(finishedMsg);
-	finished.verifyData = finishedHash.serverSum(masterSecret);
-	writeChan <- finished;
+	finished := new(finishedMsg)
+	finished.verifyData = finishedHash.serverSum(masterSecret)
+	writeChan <- finished
 
-	writeChan <- writerEnableApplicationData{};
+	writeChan <- writerEnableApplicationData{}
 
 	for {
-		_, ok := h.readHandshakeMsg().(*clientHelloMsg);
+		_, ok := h.readHandshakeMsg().(*clientHelloMsg)
 		if !ok {
-			h.error(alertUnexpectedMessage);
-			return;
+			h.error(alertUnexpectedMessage)
+			return
 		}
 		// We reject all renegotication requests.
-		writeChan <- alert{alertLevelWarning, alertNoRenegotiation};
+		writeChan <- alert{alertLevelWarning, alertNoRenegotiation}
 	}
 }
 
 func (h *serverHandshake) readHandshakeMsg() interface{} {
-	v := <-h.msgChan;
+	v := <-h.msgChan
 	if closed(h.msgChan) {
 		// If the channel closed then the processor received an error
 		// from the peer and we don't want to echo it back to them.
-		h.msgChan = nil;
-		return 0;
+		h.msgChan = nil
+		return 0
 	}
 	if _, ok := v.(alert); ok {
 		// We got an alert from the processor. We forward to the writer
 		// and shutdown.
-		h.writeChan <- v;
-		h.msgChan = nil;
-		return 0;
+		h.writeChan <- v
+		h.msgChan = nil
+		return 0
 	}
-	return v;
+	return v
 }
 
 func (h *serverHandshake) error(e alertType) {
@@ -227,9 +227,9 @@ func (h *serverHandshake) error(e alertType) {
 		go func() {
 			for _ = range h.msgChan {
 			}
-		}();
-		h.controlChan <- ConnectionState{false, "", e};
-		close(h.controlChan);
-		h.writeChan <- alert{alertLevelError, e};
+		}()
+		h.controlChan <- ConnectionState{false, "", e}
+		close(h.controlChan)
+		h.writeChan <- alert{alertLevelError, e}
 	}
 }
diff --git a/src/pkg/crypto/tls/handshake_server_test.go b/src/pkg/crypto/tls/handshake_server_test.go
index 91583d2da..716098530 100644
--- a/src/pkg/crypto/tls/handshake_server_test.go
+++ b/src/pkg/crypto/tls/handshake_server_test.go
@@ -5,12 +5,12 @@
 package tls
 
 import (
-	"bytes";
-	"big";
-	"crypto/rsa";
-	"os";
-	"testing";
-	"testing/script";
+	"bytes"
+	"big"
+	"crypto/rsa"
+	"os"
+	"testing"
+	"testing/script"
 )
 
 type zeroSource struct{}
@@ -20,41 +20,41 @@ func (zeroSource) Read(b []byte) (n int, err os.Error) {
 		b[i] = 0
 	}
 
-	return len(b), nil;
+	return len(b), nil
 }
 
 var testConfig *Config
 
 func init() {
-	testConfig = new(Config);
-	testConfig.Time = func() int64 { return 0 };
-	testConfig.Rand = zeroSource{};
-	testConfig.Certificates = make([]Certificate, 1);
-	testConfig.Certificates[0].Certificate = [][]byte{testCertificate};
-	testConfig.Certificates[0].PrivateKey = testPrivateKey;
+	testConfig = new(Config)
+	testConfig.Time = func() int64 { return 0 }
+	testConfig.Rand = zeroSource{}
+	testConfig.Certificates = make([]Certificate, 1)
+	testConfig.Certificates[0].Certificate = [][]byte{testCertificate}
+	testConfig.Certificates[0].PrivateKey = testPrivateKey
 }
 
 func setupServerHandshake() (writeChan chan interface{}, controlChan chan interface{}, msgChan chan interface{}) {
-	sh := new(serverHandshake);
-	writeChan = make(chan interface{});
-	controlChan = make(chan interface{});
-	msgChan = make(chan interface{});
+	sh := new(serverHandshake)
+	writeChan = make(chan interface{})
+	controlChan = make(chan interface{})
+	msgChan = make(chan interface{})
 
-	go sh.loop(writeChan, controlChan, msgChan, testConfig);
-	return;
+	go sh.loop(writeChan, controlChan, msgChan, testConfig)
+	return
 }
 
 func testClientHelloFailure(t *testing.T, clientHello interface{}, expectedAlert alertType) {
-	writeChan, controlChan, msgChan := setupServerHandshake();
-	defer close(msgChan);
+	writeChan, controlChan, msgChan := setupServerHandshake()
+	defer close(msgChan)
 
-	send := script.NewEvent("send", nil, script.Send{msgChan, clientHello});
-	recvAlert := script.NewEvent("recv alert", []*script.Event{send}, script.Recv{writeChan, alert{alertLevelError, expectedAlert}});
-	close1 := script.NewEvent("msgChan close", []*script.Event{recvAlert}, script.Closed{writeChan});
-	recvState := script.NewEvent("recv state", []*script.Event{send}, script.Recv{controlChan, ConnectionState{false, "", expectedAlert}});
-	close2 := script.NewEvent("controlChan close", []*script.Event{recvState}, script.Closed{controlChan});
+	send := script.NewEvent("send", nil, script.Send{msgChan, clientHello})
+	recvAlert := script.NewEvent("recv alert", []*script.Event{send}, script.Recv{writeChan, alert{alertLevelError, expectedAlert}})
+	close1 := script.NewEvent("msgChan close", []*script.Event{recvAlert}, script.Closed{writeChan})
+	recvState := script.NewEvent("recv state", []*script.Event{send}, script.Recv{controlChan, ConnectionState{false, "", expectedAlert}})
+	close2 := script.NewEvent("controlChan close", []*script.Event{recvState}, script.Closed{controlChan})
 
-	err := script.Perform(0, []*script.Event{send, recvAlert, close1, recvState, close2});
+	err := script.Perform(0, []*script.Event{send, recvAlert, close1, recvState, close2})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
@@ -67,125 +67,125 @@ func TestSimpleError(t *testing.T) {
 var badProtocolVersions = []uint8{0, 0, 0, 5, 1, 0, 1, 5, 2, 0, 2, 5, 3, 0}
 
 func TestRejectBadProtocolVersion(t *testing.T) {
-	clientHello := new(clientHelloMsg);
+	clientHello := new(clientHelloMsg)
 
 	for i := 0; i < len(badProtocolVersions); i += 2 {
-		clientHello.major = badProtocolVersions[i];
-		clientHello.minor = badProtocolVersions[i+1];
+		clientHello.major = badProtocolVersions[i]
+		clientHello.minor = badProtocolVersions[i+1]
 
-		testClientHelloFailure(t, clientHello, alertProtocolVersion);
+		testClientHelloFailure(t, clientHello, alertProtocolVersion)
 	}
 }
 
 func TestNoSuiteOverlap(t *testing.T) {
-	clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{0xff00}, []uint8{0}};
-	testClientHelloFailure(t, clientHello, alertHandshakeFailure);
+	clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{0xff00}, []uint8{0}}
+	testClientHelloFailure(t, clientHello, alertHandshakeFailure)
 
 }
 
 func TestNoCompressionOverlap(t *testing.T) {
-	clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{TLS_RSA_WITH_RC4_128_SHA}, []uint8{0xff}};
-	testClientHelloFailure(t, clientHello, alertHandshakeFailure);
+	clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{TLS_RSA_WITH_RC4_128_SHA}, []uint8{0xff}}
+	testClientHelloFailure(t, clientHello, alertHandshakeFailure)
 }
 
 func matchServerHello(v interface{}) bool {
-	serverHello, ok := v.(*serverHelloMsg);
+	serverHello, ok := v.(*serverHelloMsg)
 	if !ok {
 		return false
 	}
 	return serverHello.major == 3 &&
 		serverHello.minor == 2 &&
 		serverHello.cipherSuite == TLS_RSA_WITH_RC4_128_SHA &&
-		serverHello.compressionMethod == compressionNone;
+		serverHello.compressionMethod == compressionNone
 }
 
 func TestAlertForwarding(t *testing.T) {
-	writeChan, controlChan, msgChan := setupServerHandshake();
-	defer close(msgChan);
+	writeChan, controlChan, msgChan := setupServerHandshake()
+	defer close(msgChan)
 
-	a := alert{alertLevelError, alertNoRenegotiation};
-	sendAlert := script.NewEvent("send alert", nil, script.Send{msgChan, a});
-	recvAlert := script.NewEvent("recv alert", []*script.Event{sendAlert}, script.Recv{writeChan, a});
-	closeWriter := script.NewEvent("close writer", []*script.Event{recvAlert}, script.Closed{writeChan});
-	closeControl := script.NewEvent("close control", []*script.Event{recvAlert}, script.Closed{controlChan});
+	a := alert{alertLevelError, alertNoRenegotiation}
+	sendAlert := script.NewEvent("send alert", nil, script.Send{msgChan, a})
+	recvAlert := script.NewEvent("recv alert", []*script.Event{sendAlert}, script.Recv{writeChan, a})
+	closeWriter := script.NewEvent("close writer", []*script.Event{recvAlert}, script.Closed{writeChan})
+	closeControl := script.NewEvent("close control", []*script.Event{recvAlert}, script.Closed{controlChan})
 
-	err := script.Perform(0, []*script.Event{sendAlert, recvAlert, closeWriter, closeControl});
+	err := script.Perform(0, []*script.Event{sendAlert, recvAlert, closeWriter, closeControl})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestClose(t *testing.T) {
-	writeChan, controlChan, msgChan := setupServerHandshake();
+	writeChan, controlChan, msgChan := setupServerHandshake()
 
-	close := script.NewEvent("close", nil, script.Close{msgChan});
-	closed1 := script.NewEvent("closed1", []*script.Event{close}, script.Closed{writeChan});
-	closed2 := script.NewEvent("closed2", []*script.Event{close}, script.Closed{controlChan});
+	close := script.NewEvent("close", nil, script.Close{msgChan})
+	closed1 := script.NewEvent("closed1", []*script.Event{close}, script.Closed{writeChan})
+	closed2 := script.NewEvent("closed2", []*script.Event{close}, script.Closed{controlChan})
 
-	err := script.Perform(0, []*script.Event{close, closed1, closed2});
+	err := script.Perform(0, []*script.Event{close, closed1, closed2})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func matchCertificate(v interface{}) bool {
-	cert, ok := v.(*certificateMsg);
+	cert, ok := v.(*certificateMsg)
 	if !ok {
 		return false
 	}
 	return len(cert.certificates) == 1 &&
-		bytes.Compare(cert.certificates[0], testCertificate) == 0;
+		bytes.Compare(cert.certificates[0], testCertificate) == 0
 }
 
 func matchSetCipher(v interface{}) bool {
-	_, ok := v.(writerChangeCipherSpec);
-	return ok;
+	_, ok := v.(writerChangeCipherSpec)
+	return ok
 }
 
 func matchDone(v interface{}) bool {
-	_, ok := v.(*serverHelloDoneMsg);
-	return ok;
+	_, ok := v.(*serverHelloDoneMsg)
+	return ok
 }
 
 func matchFinished(v interface{}) bool {
-	finished, ok := v.(*finishedMsg);
+	finished, ok := v.(*finishedMsg)
 	if !ok {
 		return false
 	}
-	return bytes.Compare(finished.verifyData, fromHex("29122ae11453e631487b02ed")) == 0;
+	return bytes.Compare(finished.verifyData, fromHex("29122ae11453e631487b02ed")) == 0
 }
 
 func matchNewCipherSpec(v interface{}) bool {
-	_, ok := v.(*newCipherSpec);
-	return ok;
+	_, ok := v.(*newCipherSpec)
+	return ok
 }
 
 func TestFullHandshake(t *testing.T) {
-	writeChan, controlChan, msgChan := setupServerHandshake();
-	defer close(msgChan);
+	writeChan, controlChan, msgChan := setupServerHandshake()
+	defer close(msgChan)
 
 	// The values for this test were obtained from running `gnutls-cli --insecure --debug 9`
-	clientHello := &clientHelloMsg{fromHex("0100007603024aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b310000340033004500390088001600320044003800870013006600900091008f008e002f004100350084000a00050004008c008d008b008a01000019000900030200010000000e000c0000093132372e302e302e31"), 3, 2, fromHex("4aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b31"), nil, []uint16{0x33, 0x45, 0x39, 0x88, 0x16, 0x32, 0x44, 0x38, 0x87, 0x13, 0x66, 0x90, 0x91, 0x8f, 0x8e, 0x2f, 0x41, 0x35, 0x84, 0xa, 0x5, 0x4, 0x8c, 0x8d, 0x8b, 0x8a}, []uint8{0x0}};
+	clientHello := &clientHelloMsg{fromHex("0100007603024aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b310000340033004500390088001600320044003800870013006600900091008f008e002f004100350084000a00050004008c008d008b008a01000019000900030200010000000e000c0000093132372e302e302e31"), 3, 2, fromHex("4aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b31"), nil, []uint16{0x33, 0x45, 0x39, 0x88, 0x16, 0x32, 0x44, 0x38, 0x87, 0x13, 0x66, 0x90, 0x91, 0x8f, 0x8e, 0x2f, 0x41, 0x35, 0x84, 0xa, 0x5, 0x4, 0x8c, 0x8d, 0x8b, 0x8a}, []uint8{0x0}}
 
-	sendHello := script.NewEvent("send hello", nil, script.Send{msgChan, clientHello});
-	setVersion := script.NewEvent("set version", []*script.Event{sendHello}, script.Recv{writeChan, writerSetVersion{3, 2}});
-	recvHello := script.NewEvent("recv hello", []*script.Event{setVersion}, script.RecvMatch{writeChan, matchServerHello});
-	recvCert := script.NewEvent("recv cert", []*script.Event{recvHello}, script.RecvMatch{writeChan, matchCertificate});
-	recvDone := script.NewEvent("recv done", []*script.Event{recvCert}, script.RecvMatch{writeChan, matchDone});
+	sendHello := script.NewEvent("send hello", nil, script.Send{msgChan, clientHello})
+	setVersion := script.NewEvent("set version", []*script.Event{sendHello}, script.Recv{writeChan, writerSetVersion{3, 2}})
+	recvHello := script.NewEvent("recv hello", []*script.Event{setVersion}, script.RecvMatch{writeChan, matchServerHello})
+	recvCert := script.NewEvent("recv cert", []*script.Event{recvHello}, script.RecvMatch{writeChan, matchCertificate})
+	recvDone := script.NewEvent("recv done", []*script.Event{recvCert}, script.RecvMatch{writeChan, matchDone})
 
-	ckx := &clientKeyExchangeMsg{nil, fromHex("872e1fee5f37dd86f3215938ac8de20b302b90074e9fb93097e6b7d1286d0f45abf2daf179deb618bb3c70ed0afee6ee24476ee4649e5a23358143c0f1d9c251")};
-	sendCKX := script.NewEvent("send ckx", []*script.Event{recvDone}, script.Send{msgChan, ckx});
+	ckx := &clientKeyExchangeMsg{nil, fromHex("872e1fee5f37dd86f3215938ac8de20b302b90074e9fb93097e6b7d1286d0f45abf2daf179deb618bb3c70ed0afee6ee24476ee4649e5a23358143c0f1d9c251")}
+	sendCKX := script.NewEvent("send ckx", []*script.Event{recvDone}, script.Send{msgChan, ckx})
 
-	sendCCS := script.NewEvent("send ccs", []*script.Event{sendCKX}, script.Send{msgChan, changeCipherSpec{}});
-	recvNCS := script.NewEvent("recv done", []*script.Event{sendCCS}, script.RecvMatch{controlChan, matchNewCipherSpec});
+	sendCCS := script.NewEvent("send ccs", []*script.Event{sendCKX}, script.Send{msgChan, changeCipherSpec{}})
+	recvNCS := script.NewEvent("recv done", []*script.Event{sendCCS}, script.RecvMatch{controlChan, matchNewCipherSpec})
 
-	finished := &finishedMsg{nil, fromHex("c8faca5d242f4423325c5b1a")};
-	sendFinished := script.NewEvent("send finished", []*script.Event{recvNCS}, script.Send{msgChan, finished});
-	recvFinished := script.NewEvent("recv finished", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchFinished});
-	setCipher := script.NewEvent("set cipher", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchSetCipher});
-	recvConnectionState := script.NewEvent("recv state", []*script.Event{sendFinished}, script.Recv{controlChan, ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}});
+	finished := &finishedMsg{nil, fromHex("c8faca5d242f4423325c5b1a")}
+	sendFinished := script.NewEvent("send finished", []*script.Event{recvNCS}, script.Send{msgChan, finished})
+	recvFinished := script.NewEvent("recv finished", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchFinished})
+	setCipher := script.NewEvent("set cipher", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchSetCipher})
+	recvConnectionState := script.NewEvent("recv state", []*script.Event{sendFinished}, script.Recv{controlChan, ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}})
 
-	err := script.Perform(0, []*script.Event{sendHello, setVersion, recvHello, recvCert, recvDone, sendCKX, sendCCS, recvNCS, sendFinished, setCipher, recvConnectionState, recvFinished});
+	err := script.Perform(0, []*script.Event{sendHello, setVersion, recvHello, recvCert, recvDone, sendCKX, sendCCS, recvNCS, sendFinished, setCipher, recvConnectionState, recvFinished})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
@@ -194,9 +194,9 @@ func TestFullHandshake(t *testing.T) {
 var testCertificate = fromHex("3082025930820203a003020102020900c2ec326b95228959300d06092a864886f70d01010505003054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374301e170d3039313032303232323434355a170d3130313032303232323434355a3054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374305c300d06092a864886f70d0101010500034b003048024100b2990f49c47dfa8cd400ae6a4d1b8a3b6a13642b23f28b003bfb97790ade9a4cc82b8b2a81747ddec08b6296e53a08c331687ef25c4bf4936ba1c0e6041e9d150203010001a381b73081b4301d0603551d0e0416041478a06086837c9293a8c9b70c0bdabdb9d77eeedf3081840603551d23047d307b801478a06086837c9293a8c9b70c0bdabdb9d77eeedfa158a4563054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374820900c2ec326b95228959300c0603551d13040530030101ff300d06092a864886f70d0101050500034100ac23761ae1349d85a439caad4d0b932b09ea96de1917c3e0507c446f4838cb3076fb4d431db8c1987e96f1d7a8a2054dea3a64ec99a3f0eda4d47a163bf1f6ac")
 
 func bigFromString(s string) *big.Int {
-	ret := new(big.Int);
-	ret.SetString(s, 10);
-	return ret;
+	ret := new(big.Int)
+	ret.SetString(s, 10)
+	return ret
 }
 
 var testPrivateKey = &rsa.PrivateKey{
diff --git a/src/pkg/crypto/tls/prf.go b/src/pkg/crypto/tls/prf.go
index b89b59c29..6b9c44c07 100644
--- a/src/pkg/crypto/tls/prf.go
+++ b/src/pkg/crypto/tls/prf.go
@@ -5,59 +5,59 @@
 package tls
 
 import (
-	"crypto/hmac";
-	"crypto/md5";
-	"crypto/sha1";
-	"hash";
-	"os";
-	"strings";
+	"crypto/hmac"
+	"crypto/md5"
+	"crypto/sha1"
+	"hash"
+	"os"
+	"strings"
 )
 
 // Split a premaster secret in two as specified in RFC 4346, section 5.
 func splitPreMasterSecret(secret []byte) (s1, s2 []byte) {
-	s1 = secret[0 : (len(secret)+1)/2];
-	s2 = secret[len(secret)/2:];
-	return;
+	s1 = secret[0 : (len(secret)+1)/2]
+	s2 = secret[len(secret)/2:]
+	return
 }
 
 // pHash implements the P_hash function, as defined in RFC 4346, section 5.
 func pHash(result, secret, seed []byte, hash hash.Hash) {
-	h := hmac.New(hash, secret);
-	h.Write(seed);
-	a := h.Sum();
+	h := hmac.New(hash, secret)
+	h.Write(seed)
+	a := h.Sum()
 
-	j := 0;
+	j := 0
 	for j < len(result) {
-		h.Reset();
-		h.Write(a);
-		h.Write(seed);
-		b := h.Sum();
-		todo := len(b);
+		h.Reset()
+		h.Write(a)
+		h.Write(seed)
+		b := h.Sum()
+		todo := len(b)
 		if j+todo > len(result) {
 			todo = len(result) - j
 		}
-		copy(result[j:j+todo], b);
-		j += todo;
+		copy(result[j:j+todo], b)
+		j += todo
 
-		h.Reset();
-		h.Write(a);
-		a = h.Sum();
+		h.Reset()
+		h.Write(a)
+		a = h.Sum()
 	}
 }
 
 // pRF11 implements the TLS 1.1 pseudo-random function, as defined in RFC 4346, section 5.
 func pRF11(result, secret, label, seed []byte) {
-	hashSHA1 := sha1.New();
-	hashMD5 := md5.New();
+	hashSHA1 := sha1.New()
+	hashMD5 := md5.New()
 
-	labelAndSeed := make([]byte, len(label)+len(seed));
-	copy(labelAndSeed, label);
-	copy(labelAndSeed[len(label):], seed);
+	labelAndSeed := make([]byte, len(label)+len(seed))
+	copy(labelAndSeed, label)
+	copy(labelAndSeed[len(label):], seed)
 
-	s1, s2 := splitPreMasterSecret(secret);
-	pHash(result, s1, labelAndSeed, hashMD5);
-	result2 := make([]byte, len(result));
-	pHash(result2, s2, labelAndSeed, hashSHA1);
+	s1, s2 := splitPreMasterSecret(secret)
+	pHash(result, s1, labelAndSeed, hashMD5)
+	result2 := make([]byte, len(result))
+	pHash(result2, s2, labelAndSeed, hashSHA1)
 
 	for i, b := range result2 {
 		result[i] ^= b
@@ -65,9 +65,9 @@ func pRF11(result, secret, label, seed []byte) {
 }
 
 const (
-	tlsRandomLength		= 32;	// Length of a random nonce in TLS 1.1.
-	masterSecretLength	= 48;	// Length of a master secret in TLS 1.1.
-	finishedVerifyLength	= 12;	// Length of verify_data in a Finished message.
+	tlsRandomLength      = 32 // Length of a random nonce in TLS 1.1.
+	masterSecretLength   = 48 // Length of a master secret in TLS 1.1.
+	finishedVerifyLength = 12 // Length of verify_data in a Finished message.
 )
 
 var masterSecretLabel = strings.Bytes("master secret")
@@ -79,32 +79,32 @@ var serverFinishedLabel = strings.Bytes("server finished")
 // secret, given the lengths of the MAC and cipher keys, as defined in RFC
 // 4346, section 6.3.
 func keysFromPreMasterSecret11(preMasterSecret, clientRandom, serverRandom []byte, macLen, keyLen int) (masterSecret, clientMAC, serverMAC, clientKey, serverKey []byte) {
-	var seed [tlsRandomLength * 2]byte;
-	copy(seed[0:len(clientRandom)], clientRandom);
-	copy(seed[len(clientRandom):], serverRandom);
-	masterSecret = make([]byte, masterSecretLength);
-	pRF11(masterSecret, preMasterSecret, masterSecretLabel, seed[0:]);
-
-	copy(seed[0:len(clientRandom)], serverRandom);
-	copy(seed[len(serverRandom):], clientRandom);
-
-	n := 2*macLen + 2*keyLen;
-	keyMaterial := make([]byte, n);
-	pRF11(keyMaterial, masterSecret, keyExpansionLabel, seed[0:]);
-	clientMAC = keyMaterial[0:macLen];
-	serverMAC = keyMaterial[macLen : macLen*2];
-	clientKey = keyMaterial[macLen*2 : macLen*2+keyLen];
-	serverKey = keyMaterial[macLen*2+keyLen:];
-	return;
+	var seed [tlsRandomLength * 2]byte
+	copy(seed[0:len(clientRandom)], clientRandom)
+	copy(seed[len(clientRandom):], serverRandom)
+	masterSecret = make([]byte, masterSecretLength)
+	pRF11(masterSecret, preMasterSecret, masterSecretLabel, seed[0:])
+
+	copy(seed[0:len(clientRandom)], serverRandom)
+	copy(seed[len(serverRandom):], clientRandom)
+
+	n := 2*macLen + 2*keyLen
+	keyMaterial := make([]byte, n)
+	pRF11(keyMaterial, masterSecret, keyExpansionLabel, seed[0:])
+	clientMAC = keyMaterial[0:macLen]
+	serverMAC = keyMaterial[macLen : macLen*2]
+	clientKey = keyMaterial[macLen*2 : macLen*2+keyLen]
+	serverKey = keyMaterial[macLen*2+keyLen:]
+	return
 }
 
 // A finishedHash calculates the hash of a set of handshake messages suitable
 // for including in a Finished message.
 type finishedHash struct {
-	clientMD5	hash.Hash;
-	clientSHA1	hash.Hash;
-	serverMD5	hash.Hash;
-	serverSHA1	hash.Hash;
+	clientMD5  hash.Hash
+	clientSHA1 hash.Hash
+	serverMD5  hash.Hash
+	serverSHA1 hash.Hash
 }
 
 func newFinishedHash() finishedHash {
@@ -112,36 +112,36 @@ func newFinishedHash() finishedHash {
 }
 
 func (h finishedHash) Write(msg []byte) (n int, err os.Error) {
-	h.clientMD5.Write(msg);
-	h.clientSHA1.Write(msg);
-	h.serverMD5.Write(msg);
-	h.serverSHA1.Write(msg);
-	return len(msg), nil;
+	h.clientMD5.Write(msg)
+	h.clientSHA1.Write(msg)
+	h.serverMD5.Write(msg)
+	h.serverSHA1.Write(msg)
+	return len(msg), nil
 }
 
 // finishedSum calculates the contents of the verify_data member of a Finished
 // message given the MD5 and SHA1 hashes of a set of handshake messages.
 func finishedSum(md5, sha1, label, masterSecret []byte) []byte {
-	seed := make([]byte, len(md5)+len(sha1));
-	copy(seed, md5);
-	copy(seed[len(md5):], sha1);
-	out := make([]byte, finishedVerifyLength);
-	pRF11(out, masterSecret, label, seed);
-	return out;
+	seed := make([]byte, len(md5)+len(sha1))
+	copy(seed, md5)
+	copy(seed[len(md5):], sha1)
+	out := make([]byte, finishedVerifyLength)
+	pRF11(out, masterSecret, label, seed)
+	return out
 }
 
 // clientSum returns the contents of the verify_data member of a client's
 // Finished message.
 func (h finishedHash) clientSum(masterSecret []byte) []byte {
-	md5 := h.clientMD5.Sum();
-	sha1 := h.clientSHA1.Sum();
-	return finishedSum(md5, sha1, clientFinishedLabel, masterSecret);
+	md5 := h.clientMD5.Sum()
+	sha1 := h.clientSHA1.Sum()
+	return finishedSum(md5, sha1, clientFinishedLabel, masterSecret)
 }
 
 // serverSum returns the contents of the verify_data member of a server's
 // Finished message.
 func (h finishedHash) serverSum(masterSecret []byte) []byte {
-	md5 := h.serverMD5.Sum();
-	sha1 := h.serverSHA1.Sum();
-	return finishedSum(md5, sha1, serverFinishedLabel, masterSecret);
+	md5 := h.serverMD5.Sum()
+	sha1 := h.serverSHA1.Sum()
+	return finishedSum(md5, sha1, serverFinishedLabel, masterSecret)
 }
diff --git a/src/pkg/crypto/tls/prf_test.go b/src/pkg/crypto/tls/prf_test.go
index 0d4a4db35..5c23f368d 100644
--- a/src/pkg/crypto/tls/prf_test.go
+++ b/src/pkg/crypto/tls/prf_test.go
@@ -5,12 +5,12 @@
 package tls
 
 import (
-	"encoding/hex";
-	"testing";
+	"encoding/hex"
+	"testing"
 )
 
 type testSplitPreMasterSecretTest struct {
-	in, out1, out2 string;
+	in, out1, out2 string
 }
 
 var testSplitPreMasterSecretTests = []testSplitPreMasterSecretTest{
@@ -23,10 +23,10 @@ var testSplitPreMasterSecretTests = []testSplitPreMasterSecretTest{
 
 func TestSplitPreMasterSecret(t *testing.T) {
 	for i, test := range testSplitPreMasterSecretTests {
-		in, _ := hex.DecodeString(test.in);
-		out1, out2 := splitPreMasterSecret(in);
-		s1 := hex.EncodeToString(out1);
-		s2 := hex.EncodeToString(out2);
+		in, _ := hex.DecodeString(test.in)
+		out1, out2 := splitPreMasterSecret(in)
+		s1 := hex.EncodeToString(out1)
+		s2 := hex.EncodeToString(out2)
 		if s1 != test.out1 || s2 != test.out2 {
 			t.Errorf("#%d: got: (%s, %s) want: (%s, %s)", i, s1, s2, test.out1, test.out2)
 		}
@@ -34,25 +34,25 @@ func TestSplitPreMasterSecret(t *testing.T) {
 }
 
 type testKeysFromTest struct {
-	preMasterSecret			string;
-	clientRandom, serverRandom	string;
-	masterSecret			string;
-	clientMAC, serverMAC		string;
-	clientKey, serverKey		string;
-	macLen, keyLen			int;
+	preMasterSecret            string
+	clientRandom, serverRandom string
+	masterSecret               string
+	clientMAC, serverMAC       string
+	clientKey, serverKey       string
+	macLen, keyLen             int
 }
 
 func TestKeysFromPreMasterSecret(t *testing.T) {
 	for i, test := range testKeysFromTests {
-		in, _ := hex.DecodeString(test.preMasterSecret);
-		clientRandom, _ := hex.DecodeString(test.clientRandom);
-		serverRandom, _ := hex.DecodeString(test.serverRandom);
-		master, clientMAC, serverMAC, clientKey, serverKey := keysFromPreMasterSecret11(in, clientRandom, serverRandom, test.macLen, test.keyLen);
-		masterString := hex.EncodeToString(master);
-		clientMACString := hex.EncodeToString(clientMAC);
-		serverMACString := hex.EncodeToString(serverMAC);
-		clientKeyString := hex.EncodeToString(clientKey);
-		serverKeyString := hex.EncodeToString(serverKey);
+		in, _ := hex.DecodeString(test.preMasterSecret)
+		clientRandom, _ := hex.DecodeString(test.clientRandom)
+		serverRandom, _ := hex.DecodeString(test.serverRandom)
+		master, clientMAC, serverMAC, clientKey, serverKey := keysFromPreMasterSecret11(in, clientRandom, serverRandom, test.macLen, test.keyLen)
+		masterString := hex.EncodeToString(master)
+		clientMACString := hex.EncodeToString(clientMAC)
+		serverMACString := hex.EncodeToString(serverMAC)
+		clientKeyString := hex.EncodeToString(clientKey)
+		serverKeyString := hex.EncodeToString(serverKey)
 		if masterString != test.masterSecret ||
 			clientMACString != test.clientMAC ||
 			serverMACString != test.serverMAC ||
diff --git a/src/pkg/crypto/tls/record_process.go b/src/pkg/crypto/tls/record_process.go
index e356d67ca..ddeca0e2b 100644
--- a/src/pkg/crypto/tls/record_process.go
+++ b/src/pkg/crypto/tls/record_process.go
@@ -10,27 +10,27 @@ package tls
 // state, or for a notification when the state changes.
 
 import (
-	"container/list";
-	"crypto/subtle";
-	"hash";
+	"container/list"
+	"crypto/subtle"
+	"hash"
 )
 
 // getConnectionState is a request from the application to get the current
 // ConnectionState.
 type getConnectionState struct {
-	reply chan<- ConnectionState;
+	reply chan<- ConnectionState
 }
 
 // waitConnectionState is a request from the application to be notified when
 // the connection state changes.
 type waitConnectionState struct {
-	reply chan<- ConnectionState;
+	reply chan<- ConnectionState
 }
 
 // connectionStateChange is a message from the handshake processor that the
 // connection state has changed.
 type connectionStateChange struct {
-	connState ConnectionState;
+	connState ConnectionState
 }
 
 // changeCipherSpec is a message send to the handshake processor to signal that
@@ -40,32 +40,32 @@ type changeCipherSpec struct{}
 // newCipherSpec is a message from the handshake processor that future
 // records should be processed with a new cipher and MAC function.
 type newCipherSpec struct {
-	encrypt	encryptor;
-	mac	hash.Hash;
+	encrypt encryptor
+	mac     hash.Hash
 }
 
 type recordProcessor struct {
-	decrypt		encryptor;
-	mac		hash.Hash;
-	seqNum		uint64;
-	handshakeBuf	[]byte;
-	appDataChan	chan<- []byte;
-	requestChan	<-chan interface{};
-	controlChan	<-chan interface{};
-	recordChan	<-chan *record;
-	handshakeChan	chan<- interface{};
+	decrypt       encryptor
+	mac           hash.Hash
+	seqNum        uint64
+	handshakeBuf  []byte
+	appDataChan   chan<- []byte
+	requestChan   <-chan interface{}
+	controlChan   <-chan interface{}
+	recordChan    <-chan *record
+	handshakeChan chan<- interface{}
 
 	// recordRead is nil when we don't wish to read any more.
-	recordRead	<-chan *record;
+	recordRead <-chan *record
 	// appDataSend is nil when len(appData) == 0.
-	appDataSend	chan<- []byte;
+	appDataSend chan<- []byte
 	// appData contains any application data queued for upstream.
-	appData	[]byte;
+	appData []byte
 	// A list of channels waiting for connState to change.
-	waitQueue	*list.List;
-	connState	ConnectionState;
-	shutdown	bool;
-	header		[13]byte;
+	waitQueue *list.List
+	connState ConnectionState
+	shutdown  bool
+	header    [13]byte
 }
 
 // drainRequestChannel processes messages from the request channel until it's closed.
@@ -84,24 +84,24 @@ func drainRequestChannel(requestChan <-chan interface{}, c ConnectionState) {
 }
 
 func (p *recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan interface{}, controlChan <-chan interface{}, recordChan <-chan *record, handshakeChan chan<- interface{}) {
-	noop := nop{};
-	p.decrypt = noop;
-	p.mac = noop;
-	p.waitQueue = list.New();
-
-	p.appDataChan = appDataChan;
-	p.requestChan = requestChan;
-	p.controlChan = controlChan;
-	p.recordChan = recordChan;
-	p.handshakeChan = handshakeChan;
-	p.recordRead = recordChan;
+	noop := nop{}
+	p.decrypt = noop
+	p.mac = noop
+	p.waitQueue = list.New()
+
+	p.appDataChan = appDataChan
+	p.requestChan = requestChan
+	p.controlChan = controlChan
+	p.recordChan = recordChan
+	p.handshakeChan = handshakeChan
+	p.recordRead = recordChan
 
 	for !p.shutdown {
 		select {
 		case p.appDataSend <- p.appData:
-			p.appData = nil;
-			p.appDataSend = nil;
-			p.recordRead = p.recordChan;
+			p.appData = nil
+			p.appDataSend = nil
+			p.recordRead = p.recordChan
 		case c := <-controlChan:
 			p.processControlMsg(c)
 		case r := <-requestChan:
@@ -111,24 +111,24 @@ func (p *recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan int
 		}
 	}
 
-	p.wakeWaiters();
-	go drainRequestChannel(p.requestChan, p.connState);
+	p.wakeWaiters()
+	go drainRequestChannel(p.requestChan, p.connState)
 	go func() {
 		for _ = range controlChan {
 		}
-	}();
+	}()
 
-	close(handshakeChan);
+	close(handshakeChan)
 	if len(p.appData) > 0 {
 		appDataChan <- p.appData
 	}
-	close(appDataChan);
+	close(appDataChan)
 }
 
 func (p *recordProcessor) processRequestMsg(requestMsg interface{}) {
 	if closed(p.requestChan) {
-		p.shutdown = true;
-		return;
+		p.shutdown = true
+		return
 	}
 
 	switch r := requestMsg.(type) {
@@ -138,51 +138,51 @@ func (p *recordProcessor) processRequestMsg(requestMsg interface{}) {
 		if p.connState.HandshakeComplete {
 			r.reply <- p.connState
 		}
-		p.waitQueue.PushBack(r.reply);
+		p.waitQueue.PushBack(r.reply)
 	}
 }
 
 func (p *recordProcessor) processControlMsg(msg interface{}) {
-	connState, ok := msg.(ConnectionState);
+	connState, ok := msg.(ConnectionState)
 	if !ok || closed(p.controlChan) {
-		p.shutdown = true;
-		return;
+		p.shutdown = true
+		return
 	}
 
-	p.connState = connState;
-	p.wakeWaiters();
+	p.connState = connState
+	p.wakeWaiters()
 }
 
 func (p *recordProcessor) wakeWaiters() {
 	for i := p.waitQueue.Front(); i != nil; i = i.Next() {
 		i.Value.(chan<- ConnectionState) <- p.connState
 	}
-	p.waitQueue.Init();
+	p.waitQueue.Init()
 }
 
 func (p *recordProcessor) processRecord(r *record) {
 	if closed(p.recordChan) {
-		p.shutdown = true;
-		return;
+		p.shutdown = true
+		return
 	}
 
-	p.decrypt.XORKeyStream(r.payload);
+	p.decrypt.XORKeyStream(r.payload)
 	if len(r.payload) < p.mac.Size() {
-		p.error(alertBadRecordMAC);
-		return;
+		p.error(alertBadRecordMAC)
+		return
 	}
 
-	fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r);
-	p.seqNum++;
+	fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r)
+	p.seqNum++
 
-	p.mac.Reset();
-	p.mac.Write(p.header[0:13]);
-	p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()]);
-	macBytes := p.mac.Sum();
+	p.mac.Reset()
+	p.mac.Write(p.header[0:13])
+	p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()])
+	macBytes := p.mac.Sum()
 
 	if subtle.ConstantTimeCompare(macBytes, r.payload[len(r.payload)-p.mac.Size():]) != 1 {
-		p.error(alertBadRecordMAC);
-		return;
+		p.error(alertBadRecordMAC)
+		return
 	}
 
 	switch r.contentType {
@@ -190,31 +190,31 @@ func (p *recordProcessor) processRecord(r *record) {
 		p.processHandshakeRecord(r.payload[0 : len(r.payload)-p.mac.Size()])
 	case recordTypeChangeCipherSpec:
 		if len(r.payload) != 1 || r.payload[0] != 1 {
-			p.error(alertUnexpectedMessage);
-			return;
+			p.error(alertUnexpectedMessage)
+			return
 		}
 
-		p.handshakeChan <- changeCipherSpec{};
-		newSpec, ok := (<-p.controlChan).(*newCipherSpec);
+		p.handshakeChan <- changeCipherSpec{}
+		newSpec, ok := (<-p.controlChan).(*newCipherSpec)
 		if !ok {
-			p.connState.Error = alertUnexpectedMessage;
-			p.shutdown = true;
-			return;
+			p.connState.Error = alertUnexpectedMessage
+			p.shutdown = true
+			return
 		}
-		p.decrypt = newSpec.encrypt;
-		p.mac = newSpec.mac;
-		p.seqNum = 0;
+		p.decrypt = newSpec.encrypt
+		p.mac = newSpec.mac
+		p.seqNum = 0
 	case recordTypeApplicationData:
 		if p.connState.HandshakeComplete == false {
-			p.error(alertUnexpectedMessage);
-			return;
+			p.error(alertUnexpectedMessage)
+			return
 		}
-		p.recordRead = nil;
-		p.appData = r.payload[0 : len(r.payload)-p.mac.Size()];
-		p.appDataSend = p.appDataChan;
+		p.recordRead = nil
+		p.appData = r.payload[0 : len(r.payload)-p.mac.Size()]
+		p.appDataSend = p.appDataChan
 	default:
-		p.error(alertUnexpectedMessage);
-		return;
+		p.error(alertUnexpectedMessage)
+		return
 	}
 }
 
@@ -223,61 +223,61 @@ func (p *recordProcessor) processHandshakeRecord(data []byte) {
 		p.handshakeBuf = data
 	} else {
 		if len(p.handshakeBuf) > maxHandshakeMsg {
-			p.error(alertInternalError);
-			return;
+			p.error(alertInternalError)
+			return
 		}
-		newBuf := make([]byte, len(p.handshakeBuf)+len(data));
-		copy(newBuf, p.handshakeBuf);
-		copy(newBuf[len(p.handshakeBuf):], data);
-		p.handshakeBuf = newBuf;
+		newBuf := make([]byte, len(p.handshakeBuf)+len(data))
+		copy(newBuf, p.handshakeBuf)
+		copy(newBuf[len(p.handshakeBuf):], data)
+		p.handshakeBuf = newBuf
 	}
 
 	for len(p.handshakeBuf) >= 4 {
 		handshakeLen := int(p.handshakeBuf[1])<<16 |
 			int(p.handshakeBuf[2])<<8 |
-			int(p.handshakeBuf[3]);
+			int(p.handshakeBuf[3])
 		if handshakeLen+4 > len(p.handshakeBuf) {
 			break
 		}
 
-		bytes := p.handshakeBuf[0 : handshakeLen+4];
-		p.handshakeBuf = p.handshakeBuf[handshakeLen+4:];
+		bytes := p.handshakeBuf[0 : handshakeLen+4]
+		p.handshakeBuf = p.handshakeBuf[handshakeLen+4:]
 		if bytes[0] == typeFinished {
 			// Special case because Finished is synchronous: the
 			// handshake handler has to tell us if it's ok to start
 			// forwarding application data.
-			m := new(finishedMsg);
+			m := new(finishedMsg)
 			if !m.unmarshal(bytes) {
 				p.error(alertUnexpectedMessage)
 			}
-			p.handshakeChan <- m;
-			var ok bool;
-			p.connState, ok = (<-p.controlChan).(ConnectionState);
+			p.handshakeChan <- m
+			var ok bool
+			p.connState, ok = (<-p.controlChan).(ConnectionState)
 			if !ok || p.connState.Error != 0 {
-				p.shutdown = true;
-				return;
+				p.shutdown = true
+				return
 			}
 		} else {
-			msg, ok := parseHandshakeMsg(bytes);
+			msg, ok := parseHandshakeMsg(bytes)
 			if !ok {
-				p.error(alertUnexpectedMessage);
-				return;
+				p.error(alertUnexpectedMessage)
+				return
 			}
-			p.handshakeChan <- msg;
+			p.handshakeChan <- msg
 		}
 	}
 }
 
 func (p *recordProcessor) error(err alertType) {
-	close(p.handshakeChan);
-	p.connState.Error = err;
-	p.wakeWaiters();
-	p.shutdown = true;
+	close(p.handshakeChan)
+	p.connState.Error = err
+	p.wakeWaiters()
+	p.shutdown = true
 }
 
 func parseHandshakeMsg(data []byte) (interface{}, bool) {
 	var m interface {
-		unmarshal([]byte) bool;
+		unmarshal([]byte) bool
 	}
 
 	switch data[0] {
@@ -295,6 +295,6 @@ func parseHandshakeMsg(data []byte) (interface{}, bool) {
 		return nil, false
 	}
 
-	ok := m.unmarshal(data);
-	return m, ok;
+	ok := m.unmarshal(data)
+	return m, ok
 }
diff --git a/src/pkg/crypto/tls/record_process_test.go b/src/pkg/crypto/tls/record_process_test.go
index 1d019e30d..65ce3eba9 100644
--- a/src/pkg/crypto/tls/record_process_test.go
+++ b/src/pkg/crypto/tls/record_process_test.go
@@ -5,132 +5,132 @@
 package tls
 
 import (
-	"encoding/hex";
-	"testing";
-	"testing/script";
+	"encoding/hex"
+	"testing"
+	"testing/script"
 )
 
 func setup() (appDataChan chan []byte, requestChan chan interface{}, controlChan chan interface{}, recordChan chan *record, handshakeChan chan interface{}) {
-	rp := new(recordProcessor);
-	appDataChan = make(chan []byte);
-	requestChan = make(chan interface{});
-	controlChan = make(chan interface{});
-	recordChan = make(chan *record);
-	handshakeChan = make(chan interface{});
-
-	go rp.loop(appDataChan, requestChan, controlChan, recordChan, handshakeChan);
-	return;
+	rp := new(recordProcessor)
+	appDataChan = make(chan []byte)
+	requestChan = make(chan interface{})
+	controlChan = make(chan interface{})
+	recordChan = make(chan *record)
+	handshakeChan = make(chan interface{})
+
+	go rp.loop(appDataChan, requestChan, controlChan, recordChan, handshakeChan)
+	return
 }
 
 func fromHex(s string) []byte {
-	b, _ := hex.DecodeString(s);
-	return b;
+	b, _ := hex.DecodeString(s)
+	return b
 }
 
 func TestNullConnectionState(t *testing.T) {
-	_, requestChan, controlChan, recordChan, _ := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
+	_, requestChan, controlChan, recordChan, _ := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
 
 	// Test a simple request for the connection state.
-	replyChan := make(chan ConnectionState);
-	sendReq := script.NewEvent("send request", nil, script.Send{requestChan, getConnectionState{replyChan}});
-	getReply := script.NewEvent("get reply", []*script.Event{sendReq}, script.Recv{replyChan, ConnectionState{false, "", 0}});
+	replyChan := make(chan ConnectionState)
+	sendReq := script.NewEvent("send request", nil, script.Send{requestChan, getConnectionState{replyChan}})
+	getReply := script.NewEvent("get reply", []*script.Event{sendReq}, script.Recv{replyChan, ConnectionState{false, "", 0}})
 
-	err := script.Perform(0, []*script.Event{sendReq, getReply});
+	err := script.Perform(0, []*script.Event{sendReq, getReply})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestWaitConnectionState(t *testing.T) {
-	_, requestChan, controlChan, recordChan, _ := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
+	_, requestChan, controlChan, recordChan, _ := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
 
 	// Test that waitConnectionState doesn't get a reply until the connection state changes.
-	replyChan := make(chan ConnectionState);
-	sendReq := script.NewEvent("send request", nil, script.Send{requestChan, waitConnectionState{replyChan}});
-	replyChan2 := make(chan ConnectionState);
-	sendReq2 := script.NewEvent("send request 2", []*script.Event{sendReq}, script.Send{requestChan, getConnectionState{replyChan2}});
-	getReply2 := script.NewEvent("get reply 2", []*script.Event{sendReq2}, script.Recv{replyChan2, ConnectionState{false, "", 0}});
-	sendState := script.NewEvent("send state", []*script.Event{getReply2}, script.Send{controlChan, ConnectionState{true, "test", 1}});
-	getReply := script.NewEvent("get reply", []*script.Event{sendState}, script.Recv{replyChan, ConnectionState{true, "test", 1}});
-
-	err := script.Perform(0, []*script.Event{sendReq, sendReq2, getReply2, sendState, getReply});
+	replyChan := make(chan ConnectionState)
+	sendReq := script.NewEvent("send request", nil, script.Send{requestChan, waitConnectionState{replyChan}})
+	replyChan2 := make(chan ConnectionState)
+	sendReq2 := script.NewEvent("send request 2", []*script.Event{sendReq}, script.Send{requestChan, getConnectionState{replyChan2}})
+	getReply2 := script.NewEvent("get reply 2", []*script.Event{sendReq2}, script.Recv{replyChan2, ConnectionState{false, "", 0}})
+	sendState := script.NewEvent("send state", []*script.Event{getReply2}, script.Send{controlChan, ConnectionState{true, "test", 1}})
+	getReply := script.NewEvent("get reply", []*script.Event{sendState}, script.Recv{replyChan, ConnectionState{true, "test", 1}})
+
+	err := script.Perform(0, []*script.Event{sendReq, sendReq2, getReply2, sendState, getReply})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestHandshakeAssembly(t *testing.T) {
-	_, requestChan, controlChan, recordChan, handshakeChan := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
+	_, requestChan, controlChan, recordChan, handshakeChan := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
 
 	// Test the reassembly of a fragmented handshake message.
-	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("10000003")}});
-	send2 := script.NewEvent("send 2", []*script.Event{send1}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("0001")}});
-	send3 := script.NewEvent("send 3", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("42")}});
-	recvMsg := script.NewEvent("recv", []*script.Event{send3}, script.Recv{handshakeChan, &clientKeyExchangeMsg{fromHex("10000003000142"), fromHex("42")}});
+	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("10000003")}})
+	send2 := script.NewEvent("send 2", []*script.Event{send1}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("0001")}})
+	send3 := script.NewEvent("send 3", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("42")}})
+	recvMsg := script.NewEvent("recv", []*script.Event{send3}, script.Recv{handshakeChan, &clientKeyExchangeMsg{fromHex("10000003000142"), fromHex("42")}})
 
-	err := script.Perform(0, []*script.Event{send1, send2, send3, recvMsg});
+	err := script.Perform(0, []*script.Event{send1, send2, send3, recvMsg})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestEarlyApplicationData(t *testing.T) {
-	_, requestChan, controlChan, recordChan, handshakeChan := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
+	_, requestChan, controlChan, recordChan, handshakeChan := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
 
 	// Test that applicaton data received before the handshake has completed results in an error.
-	send := script.NewEvent("send", nil, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("")}});
-	recv := script.NewEvent("recv", []*script.Event{send}, script.Closed{handshakeChan});
+	send := script.NewEvent("send", nil, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("")}})
+	recv := script.NewEvent("recv", []*script.Event{send}, script.Closed{handshakeChan})
 
-	err := script.Perform(0, []*script.Event{send, recv});
+	err := script.Perform(0, []*script.Event{send, recv})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestApplicationData(t *testing.T) {
-	appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
+	appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
 
 	// Test that the application data is forwarded after a successful Finished message.
-	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("1400000c000000000000000000000000")}});
-	recv1 := script.NewEvent("recv finished", []*script.Event{send1}, script.Recv{handshakeChan, &finishedMsg{fromHex("1400000c000000000000000000000000"), fromHex("000000000000000000000000")}});
-	send2 := script.NewEvent("send connState", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{true, "", 0}});
-	send3 := script.NewEvent("send 2", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("0102")}});
-	recv2 := script.NewEvent("recv data", []*script.Event{send3}, script.Recv{appDataChan, []byte{0x01, 0x02}});
+	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("1400000c000000000000000000000000")}})
+	recv1 := script.NewEvent("recv finished", []*script.Event{send1}, script.Recv{handshakeChan, &finishedMsg{fromHex("1400000c000000000000000000000000"), fromHex("000000000000000000000000")}})
+	send2 := script.NewEvent("send connState", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{true, "", 0}})
+	send3 := script.NewEvent("send 2", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("0102")}})
+	recv2 := script.NewEvent("recv data", []*script.Event{send3}, script.Recv{appDataChan, []byte{0x01, 0x02}})
 
-	err := script.Perform(0, []*script.Event{send1, recv1, send2, send3, recv2});
+	err := script.Perform(0, []*script.Event{send1, recv1, send2, send3, recv2})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
 }
 
 func TestInvalidChangeCipherSpec(t *testing.T) {
-	appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup();
-	defer close(requestChan);
-	defer close(controlChan);
-	defer close(recordChan);
-
-	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeChangeCipherSpec, 0, 0, []byte{1}}});
-	recv1 := script.NewEvent("recv 1", []*script.Event{send1}, script.Recv{handshakeChan, changeCipherSpec{}});
-	send2 := script.NewEvent("send 2", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{false, "", 42}});
-	close := script.NewEvent("close 1", []*script.Event{send2}, script.Closed{appDataChan});
-	close2 := script.NewEvent("close 2", []*script.Event{send2}, script.Closed{handshakeChan});
-
-	err := script.Perform(0, []*script.Event{send1, recv1, send2, close, close2});
+	appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup()
+	defer close(requestChan)
+	defer close(controlChan)
+	defer close(recordChan)
+
+	send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeChangeCipherSpec, 0, 0, []byte{1}}})
+	recv1 := script.NewEvent("recv 1", []*script.Event{send1}, script.Recv{handshakeChan, changeCipherSpec{}})
+	send2 := script.NewEvent("send 2", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{false, "", 42}})
+	close := script.NewEvent("close 1", []*script.Event{send2}, script.Closed{appDataChan})
+	close2 := script.NewEvent("close 2", []*script.Event{send2}, script.Closed{handshakeChan})
+
+	err := script.Perform(0, []*script.Event{send1, recv1, send2, close, close2})
 	if err != nil {
 		t.Errorf("Got error: %s", err)
 	}
diff --git a/src/pkg/crypto/tls/record_read.go b/src/pkg/crypto/tls/record_read.go
index 518a1361b..0ddd884a4 100644
--- a/src/pkg/crypto/tls/record_read.go
+++ b/src/pkg/crypto/tls/record_read.go
@@ -9,34 +9,34 @@ package tls
 // it's outbound channel. On error, it closes its outbound channel.
 
 import (
-	"io";
-	"bufio";
+	"io"
+	"bufio"
 )
 
 // recordReader loops, reading TLS records from source and writing them to the
 // given channel. The channel is closed on EOF or on error.
 func recordReader(c chan<- *record, source io.Reader) {
-	defer close(c);
-	buf := bufio.NewReader(source);
+	defer close(c)
+	buf := bufio.NewReader(source)
 
 	for {
-		var header [5]byte;
-		n, _ := buf.Read(header[0:]);
+		var header [5]byte
+		n, _ := buf.Read(header[0:])
 		if n != 5 {
 			return
 		}
 
-		recordLength := int(header[3])<<8 | int(header[4]);
+		recordLength := int(header[3])<<8 | int(header[4])
 		if recordLength > maxTLSCiphertext {
 			return
 		}
 
-		payload := make([]byte, recordLength);
-		n, _ = buf.Read(payload);
+		payload := make([]byte, recordLength)
+		n, _ = buf.Read(payload)
 		if n != recordLength {
 			return
 		}
 
-		c <- &record{recordType(header[0]), header[1], header[2], payload};
+		c <- &record{recordType(header[0]), header[1], header[2], payload}
 	}
 }
diff --git a/src/pkg/crypto/tls/record_read_test.go b/src/pkg/crypto/tls/record_read_test.go
index ce1a8e6b4..f897599ad 100644
--- a/src/pkg/crypto/tls/record_read_test.go
+++ b/src/pkg/crypto/tls/record_read_test.go
@@ -5,9 +5,9 @@
 package tls
 
 import (
-	"bytes";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"testing"
+	"testing/iotest"
 )
 
 func matchRecord(r1, r2 *record) bool {
@@ -20,12 +20,12 @@ func matchRecord(r1, r2 *record) bool {
 	return r1.contentType == r2.contentType &&
 		r1.major == r2.major &&
 		r1.minor == r2.minor &&
-		bytes.Compare(r1.payload, r2.payload) == 0;
+		bytes.Compare(r1.payload, r2.payload) == 0
 }
 
 type recordReaderTest struct {
-	in	[]byte;
-	out	[]*record;
+	in  []byte
+	out []*record
 }
 
 var recordReaderTests = []recordReaderTest{
@@ -42,31 +42,31 @@ var recordReaderTests = []recordReaderTest{
 
 func TestRecordReader(t *testing.T) {
 	for i, test := range recordReaderTests {
-		buf := bytes.NewBuffer(test.in);
-		c := make(chan *record);
-		go recordReader(c, buf);
-		matchRecordReaderOutput(t, i, test, c);
+		buf := bytes.NewBuffer(test.in)
+		c := make(chan *record)
+		go recordReader(c, buf)
+		matchRecordReaderOutput(t, i, test, c)
 
-		buf = bytes.NewBuffer(test.in);
-		buf2 := iotest.OneByteReader(buf);
-		c = make(chan *record);
-		go recordReader(c, buf2);
-		matchRecordReaderOutput(t, i*2, test, c);
+		buf = bytes.NewBuffer(test.in)
+		buf2 := iotest.OneByteReader(buf)
+		c = make(chan *record)
+		go recordReader(c, buf2)
+		matchRecordReaderOutput(t, i*2, test, c)
 	}
 }
 
 func matchRecordReaderOutput(t *testing.T, i int, test recordReaderTest, c <-chan *record) {
 	for j, r1 := range test.out {
-		r2 := <-c;
+		r2 := <-c
 		if r2 == nil {
-			t.Errorf("#%d truncated after %d values", i, j);
-			break;
+			t.Errorf("#%d truncated after %d values", i, j)
+			break
 		}
 		if !matchRecord(r1, r2) {
 			t.Errorf("#%d (%d) got:%#v want:%#v", i, j, r2, r1)
 		}
 	}
-	<-c;
+	<-c
 	if !closed(c) {
 		t.Errorf("#%d: channel didn't close", i)
 	}
diff --git a/src/pkg/crypto/tls/record_write.go b/src/pkg/crypto/tls/record_write.go
index f55a214c3..5f3fb5b16 100644
--- a/src/pkg/crypto/tls/record_write.go
+++ b/src/pkg/crypto/tls/record_write.go
@@ -5,9 +5,9 @@
 package tls
 
 import (
-	"fmt";
-	"hash";
-	"io";
+	"fmt"
+	"hash"
+	"io"
 )
 
 // writerEnableApplicationData is a message which instructs recordWriter to
@@ -17,14 +17,14 @@ type writerEnableApplicationData struct{}
 // writerChangeCipherSpec updates the encryption and MAC functions and resets
 // the sequence count.
 type writerChangeCipherSpec struct {
-	encryptor	encryptor;
-	mac		hash.Hash;
+	encryptor encryptor
+	mac       hash.Hash
 }
 
 // writerSetVersion sets the version number bytes that we included in the
 // record header for future records.
 type writerSetVersion struct {
-	major, minor uint8;
+	major, minor uint8
 }
 
 // A recordWriter accepts messages from the handshake processor and
@@ -32,37 +32,37 @@ type writerSetVersion struct {
 // writing. It doesn't read from the application data channel until the
 // handshake processor has signaled that the handshake is complete.
 type recordWriter struct {
-	writer		io.Writer;
-	encryptor	encryptor;
-	mac		hash.Hash;
-	seqNum		uint64;
-	major, minor	uint8;
-	shutdown	bool;
-	appChan		<-chan []byte;
-	controlChan	<-chan interface{};
-	header		[13]byte;
+	writer       io.Writer
+	encryptor    encryptor
+	mac          hash.Hash
+	seqNum       uint64
+	major, minor uint8
+	shutdown     bool
+	appChan      <-chan []byte
+	controlChan  <-chan interface{}
+	header       [13]byte
 }
 
 func (w *recordWriter) loop(writer io.Writer, appChan <-chan []byte, controlChan <-chan interface{}) {
-	w.writer = writer;
-	w.encryptor = nop{};
-	w.mac = nop{};
-	w.appChan = appChan;
-	w.controlChan = controlChan;
+	w.writer = writer
+	w.encryptor = nop{}
+	w.mac = nop{}
+	w.appChan = appChan
+	w.controlChan = controlChan
 
 	for !w.shutdown {
-		msg := <-controlChan;
+		msg := <-controlChan
 		if _, ok := msg.(writerEnableApplicationData); ok {
 			break
 		}
-		w.processControlMessage(msg);
+		w.processControlMessage(msg)
 	}
 
 	for !w.shutdown {
 		// Always process control messages first.
 		if controlMsg, ok := <-controlChan; ok {
-			w.processControlMessage(controlMsg);
-			continue;
+			w.processControlMessage(controlMsg)
+			continue
 		}
 
 		select {
@@ -89,58 +89,58 @@ func (w *recordWriter) loop(writer io.Writer, appChan <-chan []byte, controlChan
 
 // fillMACHeader generates a MAC header. See RFC 4346, section 6.2.3.1.
 func fillMACHeader(header *[13]byte, seqNum uint64, length int, r *record) {
-	header[0] = uint8(seqNum >> 56);
-	header[1] = uint8(seqNum >> 48);
-	header[2] = uint8(seqNum >> 40);
-	header[3] = uint8(seqNum >> 32);
-	header[4] = uint8(seqNum >> 24);
-	header[5] = uint8(seqNum >> 16);
-	header[6] = uint8(seqNum >> 8);
-	header[7] = uint8(seqNum);
-	header[8] = uint8(r.contentType);
-	header[9] = r.major;
-	header[10] = r.minor;
-	header[11] = uint8(length >> 8);
-	header[12] = uint8(length);
+	header[0] = uint8(seqNum >> 56)
+	header[1] = uint8(seqNum >> 48)
+	header[2] = uint8(seqNum >> 40)
+	header[3] = uint8(seqNum >> 32)
+	header[4] = uint8(seqNum >> 24)
+	header[5] = uint8(seqNum >> 16)
+	header[6] = uint8(seqNum >> 8)
+	header[7] = uint8(seqNum)
+	header[8] = uint8(r.contentType)
+	header[9] = r.major
+	header[10] = r.minor
+	header[11] = uint8(length >> 8)
+	header[12] = uint8(length)
 }
 
 func (w *recordWriter) writeRecord(r *record) {
-	w.mac.Reset();
+	w.mac.Reset()
 
-	fillMACHeader(&w.header, w.seqNum, len(r.payload), r);
+	fillMACHeader(&w.header, w.seqNum, len(r.payload), r)
 
-	w.mac.Write(w.header[0:13]);
-	w.mac.Write(r.payload);
-	macBytes := w.mac.Sum();
+	w.mac.Write(w.header[0:13])
+	w.mac.Write(r.payload)
+	macBytes := w.mac.Sum()
 
-	w.encryptor.XORKeyStream(r.payload);
-	w.encryptor.XORKeyStream(macBytes);
+	w.encryptor.XORKeyStream(r.payload)
+	w.encryptor.XORKeyStream(macBytes)
 
-	length := len(r.payload) + len(macBytes);
-	w.header[11] = uint8(length >> 8);
-	w.header[12] = uint8(length);
-	w.writer.Write(w.header[8:13]);
-	w.writer.Write(r.payload);
-	w.writer.Write(macBytes);
+	length := len(r.payload) + len(macBytes)
+	w.header[11] = uint8(length >> 8)
+	w.header[12] = uint8(length)
+	w.writer.Write(w.header[8:13])
+	w.writer.Write(r.payload)
+	w.writer.Write(macBytes)
 
-	w.seqNum++;
+	w.seqNum++
 }
 
 func (w *recordWriter) processControlMessage(controlMsg interface{}) {
 	if controlMsg == nil {
-		w.shutdown = true;
-		return;
+		w.shutdown = true
+		return
 	}
 
 	switch msg := controlMsg.(type) {
 	case writerChangeCipherSpec:
-		w.writeRecord(&record{recordTypeChangeCipherSpec, w.major, w.minor, []byte{0x01}});
-		w.encryptor = msg.encryptor;
-		w.mac = msg.mac;
-		w.seqNum = 0;
+		w.writeRecord(&record{recordTypeChangeCipherSpec, w.major, w.minor, []byte{0x01}})
+		w.encryptor = msg.encryptor
+		w.mac = msg.mac
+		w.seqNum = 0
 	case writerSetVersion:
-		w.major = msg.major;
-		w.minor = msg.minor;
+		w.major = msg.major
+		w.minor = msg.minor
 	case alert:
 		w.writeRecord(&record{recordTypeAlert, w.major, w.minor, []byte{byte(msg.level), byte(msg.error)}})
 	case handshakeMessage:
@@ -153,18 +153,18 @@ func (w *recordWriter) processControlMessage(controlMsg interface{}) {
 
 func (w *recordWriter) processAppMessage(appMsg []byte) {
 	if closed(w.appChan) {
-		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, []byte{byte(alertCloseNotify)}});
-		w.shutdown = true;
-		return;
+		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, []byte{byte(alertCloseNotify)}})
+		w.shutdown = true
+		return
 	}
 
-	var done int;
+	var done int
 	for done < len(appMsg) {
-		todo := len(appMsg);
+		todo := len(appMsg)
 		if todo > maxTLSPlaintext {
 			todo = maxTLSPlaintext
 		}
-		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, appMsg[done : done+todo]});
-		done += todo;
+		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, appMsg[done : done+todo]})
+		done += todo
 	}
 }
diff --git a/src/pkg/crypto/tls/tls.go b/src/pkg/crypto/tls/tls.go
index c5a0f69d5..29d918e4b 100644
--- a/src/pkg/crypto/tls/tls.go
+++ b/src/pkg/crypto/tls/tls.go
@@ -6,26 +6,26 @@
 package tls
 
 import (
-	"io";
-	"os";
-	"net";
-	"time";
+	"io"
+	"os"
+	"net"
+	"time"
 )
 
 // A Conn represents a secure connection.
 type Conn struct {
-	net.Conn;
-	writeChan			chan<- []byte;
-	readChan			<-chan []byte;
-	requestChan			chan<- interface{};
-	readBuf				[]byte;
-	eof				bool;
-	readTimeout, writeTimeout	int64;
+	net.Conn
+	writeChan                 chan<- []byte
+	readChan                  <-chan []byte
+	requestChan               chan<- interface{}
+	readBuf                   []byte
+	eof                       bool
+	readTimeout, writeTimeout int64
 }
 
 func timeout(c chan<- bool, nsecs int64) {
-	time.Sleep(nsecs);
-	c <- true;
+	time.Sleep(nsecs)
+	c <- true
 }
 
 func (tls *Conn) Read(p []byte) (int, os.Error) {
@@ -34,10 +34,10 @@ func (tls *Conn) Read(p []byte) (int, os.Error) {
 			return 0, os.EOF
 		}
 
-		var timeoutChan chan bool;
+		var timeoutChan chan bool
 		if tls.readTimeout > 0 {
-			timeoutChan = make(chan bool);
-			go timeout(timeoutChan, tls.readTimeout);
+			timeoutChan = make(chan bool)
+			go timeout(timeoutChan, tls.readTimeout)
 		}
 
 		select {
@@ -53,14 +53,14 @@ func (tls *Conn) Read(p []byte) (int, os.Error) {
 			return 0, io.ErrUnexpectedEOF
 		}
 		if len(tls.readBuf) == 0 {
-			tls.eof = true;
-			return 0, os.EOF;
+			tls.eof = true
+			return 0, os.EOF
 		}
 	}
 
-	n := copy(p, tls.readBuf);
-	tls.readBuf = tls.readBuf[n:];
-	return n, nil;
+	n := copy(p, tls.readBuf)
+	tls.readBuf = tls.readBuf[n:]
+	return n, nil
 }
 
 func (tls *Conn) Write(p []byte) (int, os.Error) {
@@ -68,10 +68,10 @@ func (tls *Conn) Write(p []byte) (int, os.Error) {
 		return 0, os.EOF
 	}
 
-	var timeoutChan chan bool;
+	var timeoutChan chan bool
 	if tls.writeTimeout > 0 {
-		timeoutChan = make(chan bool);
-		go timeout(timeoutChan, tls.writeTimeout);
+		timeoutChan = make(chan bool)
+		go timeout(timeoutChan, tls.writeTimeout)
 	}
 
 	select {
@@ -80,73 +80,73 @@ func (tls *Conn) Write(p []byte) (int, os.Error) {
 		return 0, os.EAGAIN
 	}
 
-	return len(p), nil;
+	return len(p), nil
 }
 
 func (tls *Conn) Close() os.Error {
-	close(tls.writeChan);
-	close(tls.requestChan);
-	tls.eof = true;
-	return nil;
+	close(tls.writeChan)
+	close(tls.requestChan)
+	tls.eof = true
+	return nil
 }
 
 func (tls *Conn) SetTimeout(nsec int64) os.Error {
-	tls.readTimeout = nsec;
-	tls.writeTimeout = nsec;
-	return nil;
+	tls.readTimeout = nsec
+	tls.writeTimeout = nsec
+	return nil
 }
 
 func (tls *Conn) SetReadTimeout(nsec int64) os.Error {
-	tls.readTimeout = nsec;
-	return nil;
+	tls.readTimeout = nsec
+	return nil
 }
 
 func (tls *Conn) SetWriteTimeout(nsec int64) os.Error {
-	tls.writeTimeout = nsec;
-	return nil;
+	tls.writeTimeout = nsec
+	return nil
 }
 
 func (tls *Conn) GetConnectionState() ConnectionState {
-	replyChan := make(chan ConnectionState);
-	tls.requestChan <- getConnectionState{replyChan};
-	return <-replyChan;
+	replyChan := make(chan ConnectionState)
+	tls.requestChan <- getConnectionState{replyChan}
+	return <-replyChan
 }
 
 func (tls *Conn) WaitConnectionState() ConnectionState {
-	replyChan := make(chan ConnectionState);
-	tls.requestChan <- waitConnectionState{replyChan};
-	return <-replyChan;
+	replyChan := make(chan ConnectionState)
+	tls.requestChan <- waitConnectionState{replyChan}
+	return <-replyChan
 }
 
 type handshaker interface {
-	loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config);
+	loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config)
 }
 
 // Server establishes a secure connection over the given connection and acts
 // as a TLS server.
 func startTLSGoroutines(conn net.Conn, h handshaker, config *Config) *Conn {
-	tls := new(Conn);
-	tls.Conn = conn;
+	tls := new(Conn)
+	tls.Conn = conn
 
-	writeChan := make(chan []byte);
-	readChan := make(chan []byte);
-	requestChan := make(chan interface{});
+	writeChan := make(chan []byte)
+	readChan := make(chan []byte)
+	requestChan := make(chan interface{})
 
-	tls.writeChan = writeChan;
-	tls.readChan = readChan;
-	tls.requestChan = requestChan;
+	tls.writeChan = writeChan
+	tls.readChan = readChan
+	tls.requestChan = requestChan
 
-	handshakeWriterChan := make(chan interface{});
-	processorHandshakeChan := make(chan interface{});
-	handshakeProcessorChan := make(chan interface{});
-	readerProcessorChan := make(chan *record);
+	handshakeWriterChan := make(chan interface{})
+	processorHandshakeChan := make(chan interface{})
+	handshakeProcessorChan := make(chan interface{})
+	readerProcessorChan := make(chan *record)
 
-	go new(recordWriter).loop(conn, writeChan, handshakeWriterChan);
-	go recordReader(readerProcessorChan, conn);
-	go new(recordProcessor).loop(readChan, requestChan, handshakeProcessorChan, readerProcessorChan, processorHandshakeChan);
-	go h.loop(handshakeWriterChan, handshakeProcessorChan, processorHandshakeChan, config);
+	go new(recordWriter).loop(conn, writeChan, handshakeWriterChan)
+	go recordReader(readerProcessorChan, conn)
+	go new(recordProcessor).loop(readChan, requestChan, handshakeProcessorChan, readerProcessorChan, processorHandshakeChan)
+	go h.loop(handshakeWriterChan, handshakeProcessorChan, processorHandshakeChan, config)
 
-	return tls;
+	return tls
 }
 
 func Server(conn net.Conn, config *Config) *Conn {
@@ -158,28 +158,28 @@ func Client(conn net.Conn, config *Config) *Conn {
 }
 
 type Listener struct {
-	listener	net.Listener;
-	config		*Config;
+	listener net.Listener
+	config   *Config
 }
 
 func (l Listener) Accept() (c net.Conn, err os.Error) {
-	c, err = l.listener.Accept();
+	c, err = l.listener.Accept()
 	if err != nil {
 		return
 	}
 
-	c = Server(c, l.config);
-	return;
+	c = Server(c, l.config)
+	return
 }
 
-func (l Listener) Close() os.Error	{ return l.listener.Close() }
+func (l Listener) Close() os.Error { return l.listener.Close() }
 
-func (l Listener) Addr() net.Addr	{ return l.listener.Addr() }
+func (l Listener) Addr() net.Addr { return l.listener.Addr() }
 
 // NewListener creates a Listener which accepts connections from an inner
 // Listener and wraps each connection with Server.
 func NewListener(listener net.Listener, config *Config) (l Listener) {
-	l.listener = listener;
-	l.config = config;
-	return;
+	l.listener = listener
+	l.config = config
+	return
 }
diff --git a/src/pkg/crypto/x509/x509.go b/src/pkg/crypto/x509/x509.go
index 6a6239b1b..dcd12f05f 100644
--- a/src/pkg/crypto/x509/x509.go
+++ b/src/pkg/crypto/x509/x509.go
@@ -6,25 +6,25 @@
 package x509
 
 import (
-	"asn1";
-	"big";
-	"container/vector";
-	"crypto/rsa";
-	"crypto/sha1";
-	"hash";
-	"os";
-	"strings";
-	"time";
+	"asn1"
+	"big"
+	"container/vector"
+	"crypto/rsa"
+	"crypto/sha1"
+	"hash"
+	"os"
+	"strings"
+	"time"
 )
 
 // pkcs1PrivateKey is a structure which mirrors the PKCS#1 ASN.1 for an RSA private key.
 type pkcs1PrivateKey struct {
-	Version	int;
-	N	asn1.RawValue;
-	E	int;
-	D	asn1.RawValue;
-	P	asn1.RawValue;
-	Q	asn1.RawValue;
+	Version int
+	N       asn1.RawValue
+	E       int
+	D       asn1.RawValue
+	P       asn1.RawValue
+	Q       asn1.RawValue
 }
 
 // rawValueIsInteger returns true iff the given ASN.1 RawValue is an INTEGER type.
@@ -34,11 +34,11 @@ func rawValueIsInteger(raw *asn1.RawValue) bool {
 
 // ParsePKCS1PrivateKey returns an RSA private key from its ASN.1 PKCS#1 DER encoded form.
 func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) {
-	var priv pkcs1PrivateKey;
-	rest, err := asn1.Unmarshal(&priv, der);
+	var priv pkcs1PrivateKey
+	rest, err := asn1.Unmarshal(&priv, der)
 	if len(rest) > 0 {
-		err = asn1.SyntaxError{"trailing data"};
-		return;
+		err = asn1.SyntaxError{"trailing data"}
+		return
 	}
 	if err != nil {
 		return
@@ -48,8 +48,8 @@ func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) {
 		!rawValueIsInteger(&priv.D) ||
 		!rawValueIsInteger(&priv.P) ||
 		!rawValueIsInteger(&priv.Q) {
-		err = asn1.StructuralError{"tags don't match"};
-		return;
+		err = asn1.StructuralError{"tags don't match"}
+		return
 	}
 
 	key = &rsa.PrivateKey{
@@ -60,39 +60,39 @@ func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) {
 		D: new(big.Int).SetBytes(priv.D.Bytes),
 		P: new(big.Int).SetBytes(priv.P.Bytes),
 		Q: new(big.Int).SetBytes(priv.Q.Bytes),
-	};
+	}
 
-	err = key.Validate();
+	err = key.Validate()
 	if err != nil {
 		return nil, err
 	}
-	return;
+	return
 }
 
 // These structures reflect the ASN.1 structure of X.509 certificates.:
 
 type certificate struct {
-	TBSCertificate		tbsCertificate;
-	SignatureAlgorithm	algorithmIdentifier;
-	SignatureValue		asn1.BitString;
+	TBSCertificate     tbsCertificate
+	SignatureAlgorithm algorithmIdentifier
+	SignatureValue     asn1.BitString
 }
 
 type tbsCertificate struct {
-	Raw			asn1.RawContent;
-	Version			int	"optional,explicit,default:1,tag:0";
-	SerialNumber		asn1.RawValue;
-	SignatureAlgorithm	algorithmIdentifier;
-	Issuer			rdnSequence;
-	Validity		validity;
-	Subject			rdnSequence;
-	PublicKey		publicKeyInfo;
-	UniqueId		asn1.BitString	"optional,explicit,tag:1";
-	SubjectUniqueId		asn1.BitString	"optional,explicit,tag:2";
-	Extensions		[]extension	"optional,explicit,tag:3";
+	Raw                asn1.RawContent
+	Version            int "optional,explicit,default:1,tag:0"
+	SerialNumber       asn1.RawValue
+	SignatureAlgorithm algorithmIdentifier
+	Issuer             rdnSequence
+	Validity           validity
+	Subject            rdnSequence
+	PublicKey          publicKeyInfo
+	UniqueId           asn1.BitString "optional,explicit,tag:1"
+	SubjectUniqueId    asn1.BitString "optional,explicit,tag:2"
+	Extensions         []extension    "optional,explicit,tag:3"
 }
 
 type algorithmIdentifier struct {
-	Algorithm asn1.ObjectIdentifier;
+	Algorithm asn1.ObjectIdentifier
 }
 
 type rdnSequence []relativeDistinguishedName
@@ -100,55 +100,55 @@ type rdnSequence []relativeDistinguishedName
 type relativeDistinguishedName []attributeTypeAndValue
 
 type attributeTypeAndValue struct {
-	Type	asn1.ObjectIdentifier;
-	Value	interface{};
+	Type  asn1.ObjectIdentifier
+	Value interface{}
 }
 
 type validity struct {
-	NotBefore, NotAfter *time.Time;
+	NotBefore, NotAfter *time.Time
 }
 
 type publicKeyInfo struct {
-	Algorithm	algorithmIdentifier;
-	PublicKey	asn1.BitString;
+	Algorithm algorithmIdentifier
+	PublicKey asn1.BitString
 }
 
 type extension struct {
-	Id		asn1.ObjectIdentifier;
-	Critical	bool	"optional";
-	Value		[]byte;
+	Id       asn1.ObjectIdentifier
+	Critical bool "optional"
+	Value    []byte
 }
 
 // RFC 5280,  4.2.1.1
 type authKeyId struct {
-	Id []byte "optional,tag:0";
+	Id []byte "optional,tag:0"
 }
 
 type SignatureAlgorithm int
 
 const (
-	UnknownSignatureAlgorithm	SignatureAlgorithm	= iota;
-	MD2WithRSA;
-	MD5WithRSA;
-	SHA1WithRSA;
-	SHA256WithRSA;
-	SHA384WithRSA;
-	SHA512WithRSA;
+	UnknownSignatureAlgorithm SignatureAlgorithm = iota
+	MD2WithRSA
+	MD5WithRSA
+	SHA1WithRSA
+	SHA256WithRSA
+	SHA384WithRSA
+	SHA512WithRSA
 )
 
 type PublicKeyAlgorithm int
 
 const (
-	UnknownPublicKeyAlgorithm	PublicKeyAlgorithm	= iota;
-	RSA;
+	UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota
+	RSA
 )
 
 // Name represents an X.509 distinguished name. This only includes the common
 // elements of a DN.  Additional elements in the name are ignored.
 type Name struct {
-	Country, Organization, OrganizationalUnit	string;
-	CommonName, SerialNumber, Locality		string;
-	Province, StreetAddress, PostalCode		string;
+	Country, Organization, OrganizationalUnit string
+	CommonName, SerialNumber, Locality        string
+	Province, StreetAddress, PostalCode       string
 }
 
 func (n *Name) fillFromRDNSequence(rdns *rdnSequence) {
@@ -156,13 +156,13 @@ func (n *Name) fillFromRDNSequence(rdns *rdnSequence) {
 		if len(rdn) == 0 {
 			continue
 		}
-		atv := rdn[0];
-		value, ok := atv.Value.(string);
+		atv := rdn[0]
+		value, ok := atv.Value.(string)
 		if !ok {
 			continue
 		}
 
-		t := atv.Type;
+		t := atv.Type
 		if len(t) == 4 && t[0] == 2 && t[1] == 5 && t[2] == 4 {
 			switch t[3] {
 			case 3:
@@ -207,7 +207,7 @@ func getSignatureAlgorithmFromOID(oid []int) SignatureAlgorithm {
 		}
 	}
 
-	return UnknownSignatureAlgorithm;
+	return UnknownSignatureAlgorithm
 }
 
 func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm {
@@ -219,7 +219,7 @@ func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm {
 		}
 	}
 
-	return UnknownPublicKeyAlgorithm;
+	return UnknownPublicKeyAlgorithm
 }
 
 // KeyUsage represents the set of actions that are valid for a given key. It's
@@ -227,43 +227,43 @@ func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm {
 type KeyUsage int
 
 const (
-	KeyUsageDigitalSignature	KeyUsage	= 1 << iota;
-	KeyUsageContentCommitment;
-	KeyUsageKeyEncipherment;
-	KeyUsageDataEncipherment;
-	KeyUsageKeyAgreement;
-	KeyUsageCertSign;
-	KeyUsageCRLSign;
-	KeyUsageEncipherOnly;
-	KeyUsageDecipherOnly;
+	KeyUsageDigitalSignature KeyUsage = 1 << iota
+	KeyUsageContentCommitment
+	KeyUsageKeyEncipherment
+	KeyUsageDataEncipherment
+	KeyUsageKeyAgreement
+	KeyUsageCertSign
+	KeyUsageCRLSign
+	KeyUsageEncipherOnly
+	KeyUsageDecipherOnly
 )
 
 // A Certificate represents an X.509 certificate.
 type Certificate struct {
-	Raw			[]byte;	// Raw ASN.1 DER contents.
-	Signature		[]byte;
-	SignatureAlgorithm	SignatureAlgorithm;
+	Raw                []byte // Raw ASN.1 DER contents.
+	Signature          []byte
+	SignatureAlgorithm SignatureAlgorithm
 
-	PublicKeyAlgorithm	PublicKeyAlgorithm;
-	PublicKey		interface{};
+	PublicKeyAlgorithm PublicKeyAlgorithm
+	PublicKey          interface{}
 
-	Version			int;
-	SerialNumber		[]byte;
-	Issuer			Name;
-	Subject			Name;
-	NotBefore, NotAfter	*time.Time;	// Validity bounds.
-	KeyUsage		KeyUsage;
+	Version             int
+	SerialNumber        []byte
+	Issuer              Name
+	Subject             Name
+	NotBefore, NotAfter *time.Time // Validity bounds.
+	KeyUsage            KeyUsage
 
-	BasicConstraintsValid	bool;	// if true then the next two fields are valid.
-	IsCA			bool;
-	MaxPathLen		int;
+	BasicConstraintsValid bool // if true then the next two fields are valid.
+	IsCA                  bool
+	MaxPathLen            int
 
-	SubjectKeyId	[]byte;
-	AuthorityKeyId	[]byte;
+	SubjectKeyId   []byte
+	AuthorityKeyId []byte
 
 	// Subject Alternate Name values
-	DNSNames	[]string;
-	EmailAddresses	[]string;
+	DNSNames       []string
+	EmailAddresses []string
 }
 
 // UnsupportedAlgorithmError results from attempting to perform an operation
@@ -306,26 +306,26 @@ func (c *Certificate) CheckSignatureFrom(parent *Certificate) (err os.Error) {
 
 	// TODO(agl): don't ignore the path length constraint.
 
-	var h hash.Hash;
-	var hashType rsa.PKCS1v15Hash;
+	var h hash.Hash
+	var hashType rsa.PKCS1v15Hash
 
 	switch c.SignatureAlgorithm {
 	case SHA1WithRSA:
-		h = sha1.New();
-		hashType = rsa.HashSHA1;
+		h = sha1.New()
+		hashType = rsa.HashSHA1
 	default:
 		return UnsupportedAlgorithmError{}
 	}
 
-	pub, ok := parent.PublicKey.(*rsa.PublicKey);
+	pub, ok := parent.PublicKey.(*rsa.PublicKey)
 	if !ok {
 		return UnsupportedAlgorithmError{}
 	}
 
-	h.Write(c.Raw);
-	digest := h.Sum();
+	h.Write(c.Raw)
+	digest := h.Sum()
 
-	return rsa.VerifyPKCS1v15(pub, hashType, digest, c.Signature);
+	return rsa.VerifyPKCS1v15(pub, hashType, digest, c.Signature)
 }
 
 func matchHostnames(pattern, host string) bool {
@@ -333,8 +333,8 @@ func matchHostnames(pattern, host string) bool {
 		return false
 	}
 
-	patternParts := strings.Split(pattern, ".", 0);
-	hostParts := strings.Split(host, ".", 0);
+	patternParts := strings.Split(pattern, ".", 0)
+	hostParts := strings.Split(host, ".", 0)
 
 	if len(patternParts) != len(hostParts) {
 		return false
@@ -349,7 +349,7 @@ func matchHostnames(pattern, host string) bool {
 		}
 	}
 
-	return true;
+	return true
 }
 
 // IsValidForHost returns true iff c is a valid certificate for the given host.
@@ -361,10 +361,10 @@ func (c *Certificate) IsValidForHost(h string) bool {
 			}
 		}
 		// If Subject Alt Name is given, we ignore the common name.
-		return false;
+		return false
 	}
 
-	return matchHostnames(c.Subject.CommonName, h);
+	return matchHostnames(c.Subject.CommonName, h)
 }
 
 type UnhandledCriticalExtension struct{}
@@ -374,20 +374,20 @@ func (h UnhandledCriticalExtension) String() string {
 }
 
 type basicConstraints struct {
-	IsCA		bool	"optional";
-	MaxPathLen	int	"optional";
+	IsCA       bool "optional"
+	MaxPathLen int  "optional"
 }
 
 type rsaPublicKey struct {
-	N	asn1.RawValue;
-	E	int;
+	N asn1.RawValue
+	E int
 }
 
 func parsePublicKey(algo PublicKeyAlgorithm, asn1Data []byte) (interface{}, os.Error) {
 	switch algo {
 	case RSA:
-		p := new(rsaPublicKey);
-		_, err := asn1.Unmarshal(p, asn1Data);
+		p := new(rsaPublicKey)
+		_, err := asn1.Unmarshal(p, asn1Data)
 		if err != nil {
 			return nil, err
 		}
@@ -399,79 +399,79 @@ func parsePublicKey(algo PublicKeyAlgorithm, asn1Data []byte) (interface{}, os.E
 		pub := &rsa.PublicKey{
 			E: p.E,
 			N: new(big.Int).SetBytes(p.N.Bytes),
-		};
-		return pub, nil;
+		}
+		return pub, nil
 	default:
 		return nil, nil
 	}
 
-	panic("unreachable");
+	panic("unreachable")
 }
 
 func appendString(in []string, v string) (out []string) {
 	if cap(in)-len(in) < 1 {
-		out = make([]string, len(in)+1, len(in)*2+1);
+		out = make([]string, len(in)+1, len(in)*2+1)
 		for i, v := range in {
 			out[i] = v
 		}
 	} else {
 		out = in[0 : len(in)+1]
 	}
-	out[len(in)] = v;
-	return out;
+	out[len(in)] = v
+	return out
 }
 
 func parseCertificate(in *certificate) (*Certificate, os.Error) {
-	out := new(Certificate);
-	out.Raw = in.TBSCertificate.Raw;
+	out := new(Certificate)
+	out.Raw = in.TBSCertificate.Raw
 
-	out.Signature = in.SignatureValue.RightAlign();
+	out.Signature = in.SignatureValue.RightAlign()
 	out.SignatureAlgorithm =
-		getSignatureAlgorithmFromOID(in.TBSCertificate.SignatureAlgorithm.Algorithm);
+		getSignatureAlgorithmFromOID(in.TBSCertificate.SignatureAlgorithm.Algorithm)
 
 	out.PublicKeyAlgorithm =
-		getPublicKeyAlgorithmFromOID(in.TBSCertificate.PublicKey.Algorithm.Algorithm);
-	var err os.Error;
-	out.PublicKey, err = parsePublicKey(out.PublicKeyAlgorithm, in.TBSCertificate.PublicKey.PublicKey.RightAlign());
+		getPublicKeyAlgorithmFromOID(in.TBSCertificate.PublicKey.Algorithm.Algorithm)
+	var err os.Error
+	out.PublicKey, err = parsePublicKey(out.PublicKeyAlgorithm, in.TBSCertificate.PublicKey.PublicKey.RightAlign())
 	if err != nil {
 		return nil, err
 	}
 
-	out.Version = in.TBSCertificate.Version;
-	out.SerialNumber = in.TBSCertificate.SerialNumber.Bytes;
-	out.Issuer.fillFromRDNSequence(&in.TBSCertificate.Issuer);
-	out.Subject.fillFromRDNSequence(&in.TBSCertificate.Subject);
-	out.NotBefore = in.TBSCertificate.Validity.NotBefore;
-	out.NotAfter = in.TBSCertificate.Validity.NotAfter;
+	out.Version = in.TBSCertificate.Version
+	out.SerialNumber = in.TBSCertificate.SerialNumber.Bytes
+	out.Issuer.fillFromRDNSequence(&in.TBSCertificate.Issuer)
+	out.Subject.fillFromRDNSequence(&in.TBSCertificate.Subject)
+	out.NotBefore = in.TBSCertificate.Validity.NotBefore
+	out.NotAfter = in.TBSCertificate.Validity.NotAfter
 
 	for _, e := range in.TBSCertificate.Extensions {
 		if len(e.Id) == 4 && e.Id[0] == 2 && e.Id[1] == 5 && e.Id[2] == 29 {
 			switch e.Id[3] {
 			case 15:
 				// RFC 5280, 4.2.1.3
-				var usageBits asn1.BitString;
-				_, err := asn1.Unmarshal(&usageBits, e.Value);
+				var usageBits asn1.BitString
+				_, err := asn1.Unmarshal(&usageBits, e.Value)
 
 				if err == nil {
-					var usage int;
+					var usage int
 					for i := 0; i < 9; i++ {
 						if usageBits.At(i) != 0 {
 							usage |= 1 << uint(i)
 						}
 					}
-					out.KeyUsage = KeyUsage(usage);
-					continue;
+					out.KeyUsage = KeyUsage(usage)
+					continue
 				}
 			case 19:
 				// RFC 5280, 4.2.1.9
-				var constriants basicConstraints;
-				_, err := asn1.Unmarshal(&constriants, e.Value);
+				var constriants basicConstraints
+				_, err := asn1.Unmarshal(&constriants, e.Value)
 
 				if err == nil {
-					out.BasicConstraintsValid = true;
-					out.IsCA = constriants.IsCA;
-					out.MaxPathLen = constriants.MaxPathLen;
-					continue;
+					out.BasicConstraintsValid = true
+					out.IsCA = constriants.IsCA
+					out.MaxPathLen = constriants.MaxPathLen
+					continue
 				}
 			case 17:
 				// RFC 5280, 4.2.1.6
@@ -490,8 +490,8 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) {
 				//      uniformResourceIdentifier       [6]     IA5String,
 				//      iPAddress                       [7]     OCTET STRING,
 				//      registeredID                    [8]     OBJECT IDENTIFIER }
-				var seq asn1.RawValue;
-				_, err := asn1.Unmarshal(&seq, e.Value);
+				var seq asn1.RawValue
+				_, err := asn1.Unmarshal(&seq, e.Value)
 				if err != nil {
 					return nil, err
 				}
@@ -499,22 +499,22 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) {
 					return nil, asn1.StructuralError{"bad SAN sequence"}
 				}
 
-				parsedName := false;
+				parsedName := false
 
-				rest := seq.Bytes;
+				rest := seq.Bytes
 				for len(rest) > 0 {
-					var v asn1.RawValue;
-					rest, err = asn1.Unmarshal(&v, rest);
+					var v asn1.RawValue
+					rest, err = asn1.Unmarshal(&v, rest)
 					if err != nil {
 						return nil, err
 					}
 					switch v.Tag {
 					case 1:
-						out.EmailAddresses = appendString(out.EmailAddresses, string(v.Bytes));
-						parsedName = true;
+						out.EmailAddresses = appendString(out.EmailAddresses, string(v.Bytes))
+						parsedName = true
 					case 2:
-						out.DNSNames = appendString(out.DNSNames, string(v.Bytes));
-						parsedName = true;
+						out.DNSNames = appendString(out.DNSNames, string(v.Bytes))
+						parsedName = true
 					}
 				}
 
@@ -526,18 +526,18 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) {
 
 			case 35:
 				// RFC 5280, 4.2.1.1
-				var a authKeyId;
-				_, err = asn1.Unmarshal(&a, e.Value);
+				var a authKeyId
+				_, err = asn1.Unmarshal(&a, e.Value)
 				if err != nil {
 					return nil, err
 				}
-				out.AuthorityKeyId = a.Id;
-				continue;
+				out.AuthorityKeyId = a.Id
+				continue
 
 			case 14:
 				// RFC 5280, 4.2.1.2
-				out.SubjectKeyId = e.Value;
-				continue;
+				out.SubjectKeyId = e.Value
+				continue
 			}
 		}
 
@@ -546,13 +546,13 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) {
 		}
 	}
 
-	return out, nil;
+	return out, nil
 }
 
 // ParseCertificate parses a single certificate from the given ASN.1 DER data.
 func ParseCertificate(asn1Data []byte) (*Certificate, os.Error) {
-	var cert certificate;
-	rest, err := asn1.Unmarshal(&cert, asn1Data);
+	var cert certificate
+	rest, err := asn1.Unmarshal(&cert, asn1Data)
 	if err != nil {
 		return nil, err
 	}
@@ -560,32 +560,32 @@ func ParseCertificate(asn1Data []byte) (*Certificate, os.Error) {
 		return nil, asn1.SyntaxError{"trailing data"}
 	}
 
-	return parseCertificate(&cert);
+	return parseCertificate(&cert)
 }
 
 // ParseCertificates parses one or more certificates from the given ASN.1 DER
 // data. The certificates must be concatenated with no intermediate padding.
 func ParseCertificates(asn1Data []byte) ([]*Certificate, os.Error) {
-	v := new(vector.Vector);
+	v := new(vector.Vector)
 
 	for len(asn1Data) > 0 {
-		cert := new(certificate);
-		var err os.Error;
-		asn1Data, err = asn1.Unmarshal(cert, asn1Data);
+		cert := new(certificate)
+		var err os.Error
+		asn1Data, err = asn1.Unmarshal(cert, asn1Data)
 		if err != nil {
 			return nil, err
 		}
-		v.Push(cert);
+		v.Push(cert)
 	}
 
-	ret := make([]*Certificate, v.Len());
+	ret := make([]*Certificate, v.Len())
 	for i := 0; i < v.Len(); i++ {
-		cert, err := parseCertificate(v.At(i).(*certificate));
+		cert, err := parseCertificate(v.At(i).(*certificate))
 		if err != nil {
 			return nil, err
 		}
-		ret[i] = cert;
+		ret[i] = cert
 	}
 
-	return ret, nil;
+	return ret, nil
 }
diff --git a/src/pkg/crypto/x509/x509_test.go b/src/pkg/crypto/x509/x509_test.go
index c6a63253f..796807b4b 100644
--- a/src/pkg/crypto/x509/x509_test.go
+++ b/src/pkg/crypto/x509/x509_test.go
@@ -5,18 +5,18 @@
 package x509
 
 import (
-	"big";
-	"crypto/rsa";
-	"encoding/hex";
-	"encoding/pem";
-	"reflect";
-	"strings";
-	"testing";
+	"big"
+	"crypto/rsa"
+	"encoding/hex"
+	"encoding/pem"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 func TestParsePKCS1PrivateKey(t *testing.T) {
-	block, _ := pem.Decode(strings.Bytes(pemPrivateKey));
-	priv, err := ParsePKCS1PrivateKey(block.Bytes);
+	block, _ := pem.Decode(strings.Bytes(pemPrivateKey))
+	priv, err := ParsePKCS1PrivateKey(block.Bytes)
 	if err != nil {
 		t.Errorf("Failed to parse private key: %s", err)
 	}
@@ -37,9 +37,9 @@ tAboUGBxTDq3ZroNism3DaMIbKPyYrAqhKov1h5V
 `
 
 func bigFromString(s string) *big.Int {
-	ret := new(big.Int);
-	ret.SetString(s, 10);
-	return ret;
+	ret := new(big.Int)
+	ret.SetString(s, 10)
+	return ret
 }
 
 var rsaPrivateKey = &rsa.PrivateKey{
@@ -53,8 +53,8 @@ var rsaPrivateKey = &rsa.PrivateKey{
 }
 
 type matchHostnamesTest struct {
-	pattern, host	string;
-	ok		bool;
+	pattern, host string
+	ok            bool
 }
 
 var matchHostnamesTests = []matchHostnamesTest{
@@ -72,7 +72,7 @@ var matchHostnamesTests = []matchHostnamesTest{
 
 func TestMatchHostnames(t *testing.T) {
 	for i, test := range matchHostnamesTests {
-		r := matchHostnames(test.pattern, test.host);
+		r := matchHostnames(test.pattern, test.host)
 		if r != test.ok {
 			t.Errorf("#%d mismatch got: %t want: %t", i, r, test.ok)
 		}
@@ -80,17 +80,17 @@ func TestMatchHostnames(t *testing.T) {
 }
 
 func TestCertificateParse(t *testing.T) {
-	s, _ := hex.DecodeString(certBytes);
-	certs, err := ParseCertificates(s);
+	s, _ := hex.DecodeString(certBytes)
+	certs, err := ParseCertificates(s)
 	if err != nil {
 		t.Error(err)
 	}
 	if len(certs) != 2 {
-		t.Errorf("Wrong number of certs: got %d want 2", len(certs));
-		return;
+		t.Errorf("Wrong number of certs: got %d want 2", len(certs))
+		return
 	}
 
-	err = certs[0].CheckSignatureFrom(certs[1]);
+	err = certs[0].CheckSignatureFrom(certs[1])
 	if err != nil {
 		t.Error(err)
 	}
diff --git a/src/pkg/crypto/xtea/block.go b/src/pkg/crypto/xtea/block.go
index 7cf768153..dfb82e1e2 100644
--- a/src/pkg/crypto/xtea/block.go
+++ b/src/pkg/crypto/xtea/block.go
@@ -17,50 +17,50 @@ const numRounds = 64
 // blockToUint32 reads an 8 byte slice into two uint32s.
 // The block is treated as big endian.
 func blockToUint32(src []byte) (uint32, uint32) {
-	r0 := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]);
-	r1 := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]);
-	return r0, r1;
+	r0 := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+	r1 := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7])
+	return r0, r1
 }
 
 // uint32ToBlock writes two unint32s into an 8 byte data block.
 // Values are written as big endian.
 func uint32ToBlock(v0, v1 uint32, dst []byte) {
-	dst[0] = byte(v0 >> 24);
-	dst[1] = byte(v0 >> 16);
-	dst[2] = byte(v0 >> 8);
-	dst[3] = byte(v0);
-	dst[4] = byte(v1 >> 24);
-	dst[5] = byte(v1 >> 16);
-	dst[6] = byte(v1 >> 8);
-	dst[7] = byte(v1 >> 0);
+	dst[0] = byte(v0 >> 24)
+	dst[1] = byte(v0 >> 16)
+	dst[2] = byte(v0 >> 8)
+	dst[3] = byte(v0)
+	dst[4] = byte(v1 >> 24)
+	dst[5] = byte(v1 >> 16)
+	dst[6] = byte(v1 >> 8)
+	dst[7] = byte(v1 >> 0)
 }
 
 // encryptBlock encrypts a single 8 byte block using XTEA.
 func encryptBlock(c *Cipher, src, dst []byte) {
-	v0, v1 := blockToUint32(src);
+	v0, v1 := blockToUint32(src)
 
 	// Two rounds of XTEA applied per loop
 	for i := 0; i < numRounds; {
-		v0 += ((v1<<4 ^ v1>>5) + v1) ^ c.table[i];
-		i++;
-		v1 += ((v0<<4 ^ v0>>5) + v0) ^ c.table[i];
-		i++;
+		v0 += ((v1<<4 ^ v1>>5) + v1) ^ c.table[i]
+		i++
+		v1 += ((v0<<4 ^ v0>>5) + v0) ^ c.table[i]
+		i++
 	}
 
-	uint32ToBlock(v0, v1, dst);
+	uint32ToBlock(v0, v1, dst)
 }
 
 // decryptBlock decrypt a single 8 byte block using XTEA.
 func decryptBlock(c *Cipher, src, dst []byte) {
-	v0, v1 := blockToUint32(src);
+	v0, v1 := blockToUint32(src)
 
 	// Two rounds of XTEA applied per loop
 	for i := numRounds; i > 0; {
-		i--;
-		v1 -= ((v0<<4 ^ v0>>5) + v0) ^ c.table[i];
-		i--;
-		v0 -= ((v1<<4 ^ v1>>5) + v1) ^ c.table[i];
+		i--
+		v1 -= ((v0<<4 ^ v0>>5) + v0) ^ c.table[i]
+		i--
+		v0 -= ((v1<<4 ^ v1>>5) + v1) ^ c.table[i]
 	}
 
-	uint32ToBlock(v0, v1, dst);
+	uint32ToBlock(v0, v1, dst)
 }
diff --git a/src/pkg/crypto/xtea/cipher.go b/src/pkg/crypto/xtea/cipher.go
index 71545b5ac..4fb3acbef 100644
--- a/src/pkg/crypto/xtea/cipher.go
+++ b/src/pkg/crypto/xtea/cipher.go
@@ -9,8 +9,8 @@ package xtea
 // For details, see http://www.cix.co.uk/~klockstone/xtea.pdf
 
 import (
-	"os";
-	"strconv";
+	"os"
+	"strconv"
 )
 
 // The XTEA block size in bytes.
@@ -19,7 +19,7 @@ const BlockSize = 8
 // A Cipher is an instance of an XTEA cipher using a particular key.
 // table contains a series of precalculated values that are used each round.
 type Cipher struct {
-	table [64]uint32;
+	table [64]uint32
 }
 
 type KeySizeError int
@@ -32,7 +32,7 @@ func (k KeySizeError) String() string {
 // The key argument should be the XTEA key.
 // XTEA only supports 128 bit (16 byte) keys.
 func NewCipher(key []byte) (*Cipher, os.Error) {
-	k := len(key);
+	k := len(key)
 	switch k {
 	default:
 		return nil, KeySizeError(k)
@@ -40,25 +40,25 @@ func NewCipher(key []byte) (*Cipher, os.Error) {
 		break
 	}
 
-	c := new(Cipher);
-	initCipher(c, key);
+	c := new(Cipher)
+	initCipher(c, key)
 
-	return c, nil;
+	return c, nil
 }
 
 // BlockSize returns the XTEA block size, 8 bytes.
 // It is necessary to satisfy the Key interface in the
 // package "crypto/modes".
-func (c *Cipher) BlockSize() int	{ return BlockSize }
+func (c *Cipher) BlockSize() int { return BlockSize }
 
 // Encrypt encrypts the 8 byte buffer src using the key and stores the result in dst.
 // Note that for amounts of data larger than a block,
 // it is not safe to just call Encrypt on successive blocks;
 // instead, use an encryption mode like XTEACBC (see modes.go).
-func (c *Cipher) Encrypt(src, dst []byte)	{ encryptBlock(c, src, dst) }
+func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c, src, dst) }
 
 // Decrypt decrypts the 8 byte buffer src using the key k and stores the result in dst.
-func (c *Cipher) Decrypt(src, dst []byte)	{ decryptBlock(c, src, dst) }
+func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c, src, dst) }
 
 // Reset zeros the table, so that it will no longer appear in the process's memory.
 func (c *Cipher) Reset() {
@@ -71,22 +71,22 @@ func (c *Cipher) Reset() {
 // of precalculated values that are based on the key.
 func initCipher(c *Cipher, key []byte) {
 	// Load the key into four uint32s
-	var k [4]uint32;
+	var k [4]uint32
 	for i := 0; i < len(k); i++ {
-		j := i << 2;	// Multiply by 4
-		k[i] = uint32(key[j+0])<<24 | uint32(key[j+1])<<16 | uint32(key[j+2])<<8 | uint32(key[j+3]);
+		j := i << 2 // Multiply by 4
+		k[i] = uint32(key[j+0])<<24 | uint32(key[j+1])<<16 | uint32(key[j+2])<<8 | uint32(key[j+3])
 	}
 
 	// Precalculate the table
-	const delta = 0x9E3779B9;
-	var sum uint32 = 0;
+	const delta = 0x9E3779B9
+	var sum uint32 = 0
 
 	// Two rounds of XTEA applied per loop
 	for i := 0; i < numRounds; {
-		c.table[i] = sum + k[sum&3];
-		i++;
-		sum += delta;
-		c.table[i] = sum + k[(sum>>11)&3];
-		i++;
+		c.table[i] = sum + k[sum&3]
+		i++
+		sum += delta
+		c.table[i] = sum + k[(sum>>11)&3]
+		i++
 	}
 }
diff --git a/src/pkg/crypto/xtea/xtea_test.go b/src/pkg/crypto/xtea/xtea_test.go
index 26221c4b4..94756f79f 100644
--- a/src/pkg/crypto/xtea/xtea_test.go
+++ b/src/pkg/crypto/xtea/xtea_test.go
@@ -5,7 +5,7 @@
 package xtea
 
 import (
-	"testing";
+	"testing"
 )
 
 // A sample test key for when we just want to initialise a cipher
@@ -14,20 +14,20 @@ var testKey = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
 // Test that the block size for XTEA is correct
 func TestBlocksize(t *testing.T) {
 	if BlockSize != 8 {
-		t.Errorf("BlockSize constant - expected 8, got %d", BlockSize);
-		return;
+		t.Errorf("BlockSize constant - expected 8, got %d", BlockSize)
+		return
 	}
 
-	c, err := NewCipher(testKey);
+	c, err := NewCipher(testKey)
 	if err != nil {
-		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err);
-		return;
+		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err)
+		return
 	}
 
-	result := c.BlockSize();
+	result := c.BlockSize()
 	if result != 8 {
-		t.Errorf("BlockSize function - expected 8, gotr %d", result);
-		return;
+		t.Errorf("BlockSize function - expected 8, gotr %d", result)
+		return
 	}
 }
 
@@ -45,16 +45,16 @@ var testTable = []uint32{
 
 // Test that the cipher context is initialised correctly
 func TestCipherInit(t *testing.T) {
-	c, err := NewCipher(testKey);
+	c, err := NewCipher(testKey)
 	if err != nil {
-		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err);
-		return;
+		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err)
+		return
 	}
 
 	for i := 0; i < len(c.table); i++ {
 		if c.table[i] != testTable[i] {
-			t.Errorf("NewCipher() failed to initialise Cipher.table[%d] correctly. Expected %08X, got %08X", i, testTable[i], c.table[i]);
-			break;
+			t.Errorf("NewCipher() failed to initialise Cipher.table[%d] correctly. Expected %08X, got %08X", i, testTable[i], c.table[i])
+			break
 		}
 	}
 }
@@ -65,17 +65,17 @@ func TestInvalidKeySize(t *testing.T) {
 	key := []byte{
 		0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
 		0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
-	};
+	}
 
-	_, err := NewCipher(key);
+	_, err := NewCipher(key)
 	if err == nil {
 		t.Errorf("Invalid key size %d didn't result in an error.", len(key))
 	}
 
 	// Test a short key
-	key = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
+	key = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}
 
-	_, err = NewCipher(key);
+	_, err = NewCipher(key)
 	if err == nil {
 		t.Errorf("Invalid key size %d didn't result in an error.", len(key))
 	}
@@ -83,51 +83,51 @@ func TestInvalidKeySize(t *testing.T) {
 
 // Test that we can correctly decode some bytes we have encoded
 func TestEncodeDecode(t *testing.T) {
-	original := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
-	input := original;
-	output := make([]byte, BlockSize);
+	original := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}
+	input := original
+	output := make([]byte, BlockSize)
 
-	c, err := NewCipher(testKey);
+	c, err := NewCipher(testKey)
 	if err != nil {
-		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err);
-		return;
+		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err)
+		return
 	}
 
 	// Encrypt the input block
-	c.Encrypt(input, output);
+	c.Encrypt(input, output)
 
 	// Check that the output does not match the input
-	differs := false;
+	differs := false
 	for i := 0; i < len(input); i++ {
 		if output[i] != input[i] {
-			differs = true;
-			break;
+			differs = true
+			break
 		}
 	}
 	if differs == false {
-		t.Error("Cipher.Encrypt: Failed to encrypt the input block.");
-		return;
+		t.Error("Cipher.Encrypt: Failed to encrypt the input block.")
+		return
 	}
 
 	// Decrypt the block we just encrypted
-	input = output;
-	output = make([]byte, BlockSize);
-	c.Decrypt(input, output);
+	input = output
+	output = make([]byte, BlockSize)
+	c.Decrypt(input, output)
 
 	// Check that the output from decrypt matches our initial input
 	for i := 0; i < len(input); i++ {
 		if output[i] != original[i] {
-			t.Errorf("Decrypted byte %d differed. Expected %02X, got %02X\n", i, original[i], output[i]);
-			return;
+			t.Errorf("Decrypted byte %d differed. Expected %02X, got %02X\n", i, original[i], output[i])
+			return
 		}
 	}
 }
 
 // Test Vectors
 type CryptTest struct {
-	key		[]byte;
-	plainText	[]byte;
-	cipherText	[]byte;
+	key        []byte
+	plainText  []byte
+	cipherText []byte
 }
 
 var CryptTests = []CryptTest{
@@ -189,19 +189,19 @@ var CryptTests = []CryptTest{
 // Test encryption
 func TestCipherEncrypt(t *testing.T) {
 	for i, tt := range CryptTests {
-		c, err := NewCipher(tt.key);
+		c, err := NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err);
-			continue;
+			t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err)
+			continue
 		}
 
-		out := make([]byte, len(tt.plainText));
-		c.Encrypt(tt.plainText, out);
+		out := make([]byte, len(tt.plainText))
+		c.Encrypt(tt.plainText, out)
 
 		for j := 0; j < len(out); j++ {
 			if out[j] != tt.cipherText[j] {
-				t.Errorf("Cipher.Encrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.cipherText[j]);
-				break;
+				t.Errorf("Cipher.Encrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.cipherText[j])
+				break
 			}
 		}
 	}
@@ -210,19 +210,19 @@ func TestCipherEncrypt(t *testing.T) {
 // Test decryption
 func TestCipherDecrypt(t *testing.T) {
 	for i, tt := range CryptTests {
-		c, err := NewCipher(tt.key);
+		c, err := NewCipher(tt.key)
 		if err != nil {
-			t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err);
-			continue;
+			t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err)
+			continue
 		}
 
-		out := make([]byte, len(tt.cipherText));
-		c.Decrypt(tt.cipherText, out);
+		out := make([]byte, len(tt.cipherText))
+		c.Decrypt(tt.cipherText, out)
 
 		for j := 0; j < len(out); j++ {
 			if out[j] != tt.plainText[j] {
-				t.Errorf("Cipher.Decrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.plainText[j]);
-				break;
+				t.Errorf("Cipher.Decrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.plainText[j])
+				break
 			}
 		}
 	}
@@ -230,17 +230,17 @@ func TestCipherDecrypt(t *testing.T) {
 
 // Test resetting the cipher context
 func TestReset(t *testing.T) {
-	c, err := NewCipher(testKey);
+	c, err := NewCipher(testKey)
 	if err != nil {
-		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err);
-		return;
+		t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err)
+		return
 	}
 
-	c.Reset();
+	c.Reset()
 	for i := 0; i < len(c.table); i++ {
 		if c.table[i] != 0 {
-			t.Errorf("Cipher.Reset: Failed to clear Cipher.table[%d]. expected 0, got %08X", i, c.table[i]);
-			return;
+			t.Errorf("Cipher.Reset: Failed to clear Cipher.table[%d]. expected 0, got %08X", i, c.table[i])
+			return
 		}
 	}
 }