message: copy in fmt formatting

Only added // +build ignore at top of file.

There turns out to be too many little interactions and
subtle differences between fmt and message to
comfortably rely on fmt.

Down the road we can look into reusing some
of the fmt code again or moving it to a different
package.

Change-Id: I908ba8b6a8f79f940a7eb4d5581715e2056fded5
Reviewed-on: https://go-review.googlesource.com/45092
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Nigel Tao <nigeltao@golang.org>
diff --git a/message/fmt_test.go b/message/fmt_test.go
new file mode 100644
index 0000000..7f2db5e
--- /dev/null
+++ b/message/fmt_test.go
@@ -0,0 +1,1814 @@
+// +build ignore
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt_test
+
+import (
+	"bytes"
+	. "fmt"
+	"internal/race"
+	"math"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+	"unicode"
+)
+
+type (
+	renamedBool       bool
+	renamedInt        int
+	renamedInt8       int8
+	renamedInt16      int16
+	renamedInt32      int32
+	renamedInt64      int64
+	renamedUint       uint
+	renamedUint8      uint8
+	renamedUint16     uint16
+	renamedUint32     uint32
+	renamedUint64     uint64
+	renamedUintptr    uintptr
+	renamedString     string
+	renamedBytes      []byte
+	renamedFloat32    float32
+	renamedFloat64    float64
+	renamedComplex64  complex64
+	renamedComplex128 complex128
+)
+
+func TestFmtInterface(t *testing.T) {
+	var i1 interface{}
+	i1 = "abc"
+	s := Sprintf("%s", i1)
+	if s != "abc" {
+		t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
+	}
+}
+
+var (
+	NaN    = math.NaN()
+	posInf = math.Inf(1)
+	negInf = math.Inf(-1)
+
+	intVar = 0
+
+	array  = [5]int{1, 2, 3, 4, 5}
+	iarray = [4]interface{}{1, "hello", 2.5, nil}
+	slice  = array[:]
+	islice = iarray[:]
+)
+
+type A struct {
+	i int
+	j uint
+	s string
+	x []int
+}
+
+type I int
+
+func (i I) String() string { return Sprintf("<%d>", int(i)) }
+
+type B struct {
+	I I
+	j int
+}
+
+type C struct {
+	i int
+	B
+}
+
+type F int
+
+func (f F) Format(s State, c rune) {
+	Fprintf(s, "<%c=F(%d)>", c, int(f))
+}
+
+type G int
+
+func (g G) GoString() string {
+	return Sprintf("GoString(%d)", int(g))
+}
+
+type S struct {
+	F F // a struct field that Formats
+	G G // a struct field that GoStrings
+}
+
+type SI struct {
+	I interface{}
+}
+
+// P is a type with a String method with pointer receiver for testing %p.
+type P int
+
+var pValue P
+
+func (p *P) String() string {
+	return "String(p)"
+}
+
+var barray = [5]renamedUint8{1, 2, 3, 4, 5}
+var bslice = barray[:]
+
+type byteStringer byte
+
+func (byteStringer) String() string {
+	return "X"
+}
+
+var byteStringerSlice = []byteStringer{'h', 'e', 'l', 'l', 'o'}
+
+type byteFormatter byte
+
+func (byteFormatter) Format(f State, _ rune) {
+	Fprint(f, "X")
+}
+
+var byteFormatterSlice = []byteFormatter{'h', 'e', 'l', 'l', 'o'}
+
+var fmtTests = []struct {
+	fmt string
+	val interface{}
+	out string
+}{
+	{"%d", 12345, "12345"},
+	{"%v", 12345, "12345"},
+	{"%t", true, "true"},
+
+	// basic string
+	{"%s", "abc", "abc"},
+	{"%q", "abc", `"abc"`},
+	{"%x", "abc", "616263"},
+	{"%x", "\xff\xf0\x0f\xff", "fff00fff"},
+	{"%X", "\xff\xf0\x0f\xff", "FFF00FFF"},
+	{"%x", "", ""},
+	{"% x", "", ""},
+	{"%#x", "", ""},
+	{"%# x", "", ""},
+	{"%x", "xyz", "78797a"},
+	{"%X", "xyz", "78797A"},
+	{"% x", "xyz", "78 79 7a"},
+	{"% X", "xyz", "78 79 7A"},
+	{"%#x", "xyz", "0x78797a"},
+	{"%#X", "xyz", "0X78797A"},
+	{"%# x", "xyz", "0x78 0x79 0x7a"},
+	{"%# X", "xyz", "0X78 0X79 0X7A"},
+
+	// basic bytes
+	{"%s", []byte("abc"), "abc"},
+	{"%s", [3]byte{'a', 'b', 'c'}, "abc"},
+	{"%s", &[3]byte{'a', 'b', 'c'}, "&abc"},
+	{"%q", []byte("abc"), `"abc"`},
+	{"%x", []byte("abc"), "616263"},
+	{"%x", []byte("\xff\xf0\x0f\xff"), "fff00fff"},
+	{"%X", []byte("\xff\xf0\x0f\xff"), "FFF00FFF"},
+	{"%x", []byte(""), ""},
+	{"% x", []byte(""), ""},
+	{"%#x", []byte(""), ""},
+	{"%# x", []byte(""), ""},
+	{"%x", []byte("xyz"), "78797a"},
+	{"%X", []byte("xyz"), "78797A"},
+	{"% x", []byte("xyz"), "78 79 7a"},
+	{"% X", []byte("xyz"), "78 79 7A"},
+	{"%#x", []byte("xyz"), "0x78797a"},
+	{"%#X", []byte("xyz"), "0X78797A"},
+	{"%# x", []byte("xyz"), "0x78 0x79 0x7a"},
+	{"%# X", []byte("xyz"), "0X78 0X79 0X7A"},
+
+	// escaped strings
+	{"%q", "", `""`},
+	{"%#q", "", "``"},
+	{"%q", "\"", `"\""`},
+	{"%#q", "\"", "`\"`"},
+	{"%q", "`", `"` + "`" + `"`},
+	{"%#q", "`", `"` + "`" + `"`},
+	{"%q", "\n", `"\n"`},
+	{"%#q", "\n", `"\n"`},
+	{"%q", `\n`, `"\\n"`},
+	{"%#q", `\n`, "`\\n`"},
+	{"%q", "abc", `"abc"`},
+	{"%#q", "abc", "`abc`"},
+	{"%q", "日本語", `"日本語"`},
+	{"%+q", "日本語", `"\u65e5\u672c\u8a9e"`},
+	{"%#q", "日本語", "`日本語`"},
+	{"%#+q", "日本語", "`日本語`"},
+	{"%q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
+	{"%+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
+	{"%#q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
+	{"%#+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
+	{"%q", "☺", `"☺"`},
+	{"% q", "☺", `"☺"`}, // The space modifier should have no effect.
+	{"%+q", "☺", `"\u263a"`},
+	{"%#q", "☺", "`☺`"},
+	{"%#+q", "☺", "`☺`"},
+	{"%10q", "⌘", `       "⌘"`},
+	{"%+10q", "⌘", `  "\u2318"`},
+	{"%-10q", "⌘", `"⌘"       `},
+	{"%+-10q", "⌘", `"\u2318"  `},
+	{"%010q", "⌘", `0000000"⌘"`},
+	{"%+010q", "⌘", `00"\u2318"`},
+	{"%-010q", "⌘", `"⌘"       `}, // 0 has no effect when - is present.
+	{"%+-010q", "⌘", `"\u2318"  `},
+	{"%#8q", "\n", `    "\n"`},
+	{"%#+8q", "\r", `    "\r"`},
+	{"%#-8q", "\t", "`	`     "},
+	{"%#+-8q", "\b", `"\b"    `},
+	{"%q", "abc\xffdef", `"abc\xffdef"`},
+	{"%+q", "abc\xffdef", `"abc\xffdef"`},
+	{"%#q", "abc\xffdef", `"abc\xffdef"`},
+	{"%#+q", "abc\xffdef", `"abc\xffdef"`},
+	// Runes that are not printable.
+	{"%q", "\U0010ffff", `"\U0010ffff"`},
+	{"%+q", "\U0010ffff", `"\U0010ffff"`},
+	{"%#q", "\U0010ffff", "`􏿿`"},
+	{"%#+q", "\U0010ffff", "`􏿿`"},
+	// Runes that are not valid.
+	{"%q", string(0x110000), `"�"`},
+	{"%+q", string(0x110000), `"\ufffd"`},
+	{"%#q", string(0x110000), "`�`"},
+	{"%#+q", string(0x110000), "`�`"},
+
+	// characters
+	{"%c", uint('x'), "x"},
+	{"%c", 0xe4, "ä"},
+	{"%c", 0x672c, "本"},
+	{"%c", '日', "日"},
+	{"%.0c", '⌘', "⌘"}, // Specifying precision should have no effect.
+	{"%3c", '⌘', "  ⌘"},
+	{"%-3c", '⌘', "⌘  "},
+	// Runes that are not printable.
+	{"%c", '\U00000e00', "\u0e00"},
+	{"%c", '\U0010ffff', "\U0010ffff"},
+	// Runes that are not valid.
+	{"%c", -1, "�"},
+	{"%c", 0xDC80, "�"},
+	{"%c", rune(0x110000), "�"},
+	{"%c", int64(0xFFFFFFFFF), "�"},
+	{"%c", uint64(0xFFFFFFFFF), "�"},
+
+	// escaped characters
+	{"%q", uint(0), `'\x00'`},
+	{"%+q", uint(0), `'\x00'`},
+	{"%q", '"', `'"'`},
+	{"%+q", '"', `'"'`},
+	{"%q", '\'', `'\''`},
+	{"%+q", '\'', `'\''`},
+	{"%q", '`', "'`'"},
+	{"%+q", '`', "'`'"},
+	{"%q", 'x', `'x'`},
+	{"%+q", 'x', `'x'`},
+	{"%q", 'ÿ', `'ÿ'`},
+	{"%+q", 'ÿ', `'\u00ff'`},
+	{"%q", '\n', `'\n'`},
+	{"%+q", '\n', `'\n'`},
+	{"%q", '☺', `'☺'`},
+	{"%+q", '☺', `'\u263a'`},
+	{"% q", '☺', `'☺'`},  // The space modifier should have no effect.
+	{"%.0q", '☺', `'☺'`}, // Specifying precision should have no effect.
+	{"%10q", '⌘', `       '⌘'`},
+	{"%+10q", '⌘', `  '\u2318'`},
+	{"%-10q", '⌘', `'⌘'       `},
+	{"%+-10q", '⌘', `'\u2318'  `},
+	{"%010q", '⌘', `0000000'⌘'`},
+	{"%+010q", '⌘', `00'\u2318'`},
+	{"%-010q", '⌘', `'⌘'       `}, // 0 has no effect when - is present.
+	{"%+-010q", '⌘', `'\u2318'  `},
+	// Runes that are not printable.
+	{"%q", '\U00000e00', `'\u0e00'`},
+	{"%q", '\U0010ffff', `'\U0010ffff'`},
+	// Runes that are not valid.
+	{"%q", int32(-1), "%!q(int32=-1)"},
+	{"%q", 0xDC80, `'�'`},
+	{"%q", rune(0x110000), "%!q(int32=1114112)"},
+	{"%q", int64(0xFFFFFFFFF), "%!q(int64=68719476735)"},
+	{"%q", uint64(0xFFFFFFFFF), "%!q(uint64=68719476735)"},
+
+	// width
+	{"%5s", "abc", "  abc"},
+	{"%2s", "\u263a", " ☺"},
+	{"%-5s", "abc", "abc  "},
+	{"%-8q", "abc", `"abc"   `},
+	{"%05s", "abc", "00abc"},
+	{"%08q", "abc", `000"abc"`},
+	{"%5s", "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz"},
+	{"%.5s", "abcdefghijklmnopqrstuvwxyz", "abcde"},
+	{"%.0s", "日本語日本語", ""},
+	{"%.5s", "日本語日本語", "日本語日本"},
+	{"%.10s", "日本語日本語", "日本語日本語"},
+	{"%.5s", []byte("日本語日本語"), "日本語日本"},
+	{"%.5q", "abcdefghijklmnopqrstuvwxyz", `"abcde"`},
+	{"%.5x", "abcdefghijklmnopqrstuvwxyz", "6162636465"},
+	{"%.5q", []byte("abcdefghijklmnopqrstuvwxyz"), `"abcde"`},
+	{"%.5x", []byte("abcdefghijklmnopqrstuvwxyz"), "6162636465"},
+	{"%.3q", "日本語日本語", `"日本語"`},
+	{"%.3q", []byte("日本語日本語"), `"日本語"`},
+	{"%.1q", "日本語", `"日"`},
+	{"%.1q", []byte("日本語"), `"日"`},
+	{"%.1x", "日本語", "e6"},
+	{"%.1X", []byte("日本語"), "E6"},
+	{"%10.1q", "日本語日本語", `       "日"`},
+	{"%10v", nil, "     <nil>"},
+	{"%-10v", nil, "<nil>     "},
+
+	// integers
+	{"%d", uint(12345), "12345"},
+	{"%d", int(-12345), "-12345"},
+	{"%d", ^uint8(0), "255"},
+	{"%d", ^uint16(0), "65535"},
+	{"%d", ^uint32(0), "4294967295"},
+	{"%d", ^uint64(0), "18446744073709551615"},
+	{"%d", int8(-1 << 7), "-128"},
+	{"%d", int16(-1 << 15), "-32768"},
+	{"%d", int32(-1 << 31), "-2147483648"},
+	{"%d", int64(-1 << 63), "-9223372036854775808"},
+	{"%.d", 0, ""},
+	{"%.0d", 0, ""},
+	{"%6.0d", 0, "      "},
+	{"%06.0d", 0, "      "},
+	{"% d", 12345, " 12345"},
+	{"%+d", 12345, "+12345"},
+	{"%+d", -12345, "-12345"},
+	{"%b", 7, "111"},
+	{"%b", -6, "-110"},
+	{"%b", ^uint32(0), "11111111111111111111111111111111"},
+	{"%b", ^uint64(0), "1111111111111111111111111111111111111111111111111111111111111111"},
+	{"%b", int64(-1 << 63), zeroFill("-1", 63, "")},
+	{"%o", 01234, "1234"},
+	{"%#o", 01234, "01234"},
+	{"%o", ^uint32(0), "37777777777"},
+	{"%o", ^uint64(0), "1777777777777777777777"},
+	{"%#X", 0, "0X0"},
+	{"%x", 0x12abcdef, "12abcdef"},
+	{"%X", 0x12abcdef, "12ABCDEF"},
+	{"%x", ^uint32(0), "ffffffff"},
+	{"%X", ^uint64(0), "FFFFFFFFFFFFFFFF"},
+	{"%.20b", 7, "00000000000000000111"},
+	{"%10d", 12345, "     12345"},
+	{"%10d", -12345, "    -12345"},
+	{"%+10d", 12345, "    +12345"},
+	{"%010d", 12345, "0000012345"},
+	{"%010d", -12345, "-000012345"},
+	{"%20.8d", 1234, "            00001234"},
+	{"%20.8d", -1234, "           -00001234"},
+	{"%020.8d", 1234, "            00001234"},
+	{"%020.8d", -1234, "           -00001234"},
+	{"%-20.8d", 1234, "00001234            "},
+	{"%-20.8d", -1234, "-00001234           "},
+	{"%-#20.8x", 0x1234abc, "0x01234abc          "},
+	{"%-#20.8X", 0x1234abc, "0X01234ABC          "},
+	{"%-#20.8o", 01234, "00001234            "},
+
+	// Test correct f.intbuf overflow checks.
+	{"%068d", 1, zeroFill("", 68, "1")},
+	{"%068d", -1, zeroFill("-", 67, "1")},
+	{"%#.68x", 42, zeroFill("0x", 68, "2a")},
+	{"%.68d", -42, zeroFill("-", 68, "42")},
+	{"%+.68d", 42, zeroFill("+", 68, "42")},
+	{"% .68d", 42, zeroFill(" ", 68, "42")},
+	{"% +.68d", 42, zeroFill("+", 68, "42")},
+
+	// unicode format
+	{"%U", 0, "U+0000"},
+	{"%U", -1, "U+FFFFFFFFFFFFFFFF"},
+	{"%U", '\n', `U+000A`},
+	{"%#U", '\n', `U+000A`},
+	{"%+U", 'x', `U+0078`},       // Plus flag should have no effect.
+	{"%# U", 'x', `U+0078 'x'`},  // Space flag should have no effect.
+	{"%#.2U", 'x', `U+0078 'x'`}, // Precisions below 4 should print 4 digits.
+	{"%U", '\u263a', `U+263A`},
+	{"%#U", '\u263a', `U+263A '☺'`},
+	{"%U", '\U0001D6C2', `U+1D6C2`},
+	{"%#U", '\U0001D6C2', `U+1D6C2 '𝛂'`},
+	{"%#14.6U", '⌘', "  U+002318 '⌘'"},
+	{"%#-14.6U", '⌘', "U+002318 '⌘'  "},
+	{"%#014.6U", '⌘', "  U+002318 '⌘'"},
+	{"%#-014.6U", '⌘', "U+002318 '⌘'  "},
+	{"%.68U", uint(42), zeroFill("U+", 68, "2A")},
+	{"%#.68U", '日', zeroFill("U+", 68, "65E5") + " '日'"},
+
+	// floats
+	{"%+.3e", 0.0, "+0.000e+00"},
+	{"%+.3e", 1.0, "+1.000e+00"},
+	{"%+.3f", -1.0, "-1.000"},
+	{"%+.3F", -1.0, "-1.000"},
+	{"%+.3F", float32(-1.0), "-1.000"},
+	{"%+07.2f", 1.0, "+001.00"},
+	{"%+07.2f", -1.0, "-001.00"},
+	{"%-07.2f", 1.0, "1.00   "},
+	{"%-07.2f", -1.0, "-1.00  "},
+	{"%+-07.2f", 1.0, "+1.00  "},
+	{"%+-07.2f", -1.0, "-1.00  "},
+	{"%-+07.2f", 1.0, "+1.00  "},
+	{"%-+07.2f", -1.0, "-1.00  "},
+	{"%+10.2f", +1.0, "     +1.00"},
+	{"%+10.2f", -1.0, "     -1.00"},
+	{"% .3E", -1.0, "-1.000E+00"},
+	{"% .3e", 1.0, " 1.000e+00"},
+	{"%+.3g", 0.0, "+0"},
+	{"%+.3g", 1.0, "+1"},
+	{"%+.3g", -1.0, "-1"},
+	{"% .3g", -1.0, "-1"},
+	{"% .3g", 1.0, " 1"},
+	{"%b", float32(1.0), "8388608p-23"},
+	{"%b", 1.0, "4503599627370496p-52"},
+	// Test sharp flag used with floats.
+	{"%#g", 1e-323, "1.00000e-323"},
+	{"%#g", -1.0, "-1.00000"},
+	{"%#g", 1.1, "1.10000"},
+	{"%#g", 123456.0, "123456."},
+	{"%#g", 1234567.0, "1.234567e+06"},
+	{"%#g", 1230000.0, "1.23000e+06"},
+	{"%#g", 1000000.0, "1.00000e+06"},
+	{"%#.0f", 1.0, "1."},
+	{"%#.0e", 1.0, "1.e+00"},
+	{"%#.0g", 1.0, "1."},
+	{"%#.0g", 1100000.0, "1.e+06"},
+	{"%#.4f", 1.0, "1.0000"},
+	{"%#.4e", 1.0, "1.0000e+00"},
+	{"%#.4g", 1.0, "1.000"},
+	{"%#.4g", 100000.0, "1.000e+05"},
+	{"%#.0f", 123.0, "123."},
+	{"%#.0e", 123.0, "1.e+02"},
+	{"%#.0g", 123.0, "1.e+02"},
+	{"%#.4f", 123.0, "123.0000"},
+	{"%#.4e", 123.0, "1.2300e+02"},
+	{"%#.4g", 123.0, "123.0"},
+	{"%#.4g", 123000.0, "1.230e+05"},
+	{"%#9.4g", 1.0, "    1.000"},
+	// The sharp flag has no effect for binary float format.
+	{"%#b", 1.0, "4503599627370496p-52"},
+	// Precision has no effect for binary float format.
+	{"%.4b", float32(1.0), "8388608p-23"},
+	{"%.4b", -1.0, "-4503599627370496p-52"},
+	// Test correct f.intbuf boundary checks.
+	{"%.68f", 1.0, zeroFill("1.", 68, "")},
+	{"%.68f", -1.0, zeroFill("-1.", 68, "")},
+	// float infinites and NaNs
+	{"%f", posInf, "+Inf"},
+	{"%.1f", negInf, "-Inf"},
+	{"% f", NaN, " NaN"},
+	{"%20f", posInf, "                +Inf"},
+	{"% 20F", posInf, "                 Inf"},
+	{"% 20e", negInf, "                -Inf"},
+	{"%+20E", negInf, "                -Inf"},
+	{"% +20g", negInf, "                -Inf"},
+	{"%+-20G", posInf, "+Inf                "},
+	{"%20e", NaN, "                 NaN"},
+	{"% +20E", NaN, "                +NaN"},
+	{"% -20g", NaN, " NaN                "},
+	{"%+-20G", NaN, "+NaN                "},
+	// Zero padding does not apply to infinities and NaN.
+	{"%+020e", posInf, "                +Inf"},
+	{"%-020f", negInf, "-Inf                "},
+	{"%-020E", NaN, "NaN                 "},
+
+	// complex values
+	{"%.f", 0i, "(0+0i)"},
+	{"% .f", 0i, "( 0+0i)"},
+	{"%+.f", 0i, "(+0+0i)"},
+	{"% +.f", 0i, "(+0+0i)"},
+	{"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"},
+	{"%+.3f", 0i, "(+0.000+0.000i)"},
+	{"%+.3g", 0i, "(+0+0i)"},
+	{"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"},
+	{"%+.3f", 1 + 2i, "(+1.000+2.000i)"},
+	{"%+.3g", 1 + 2i, "(+1+2i)"},
+	{"%.3e", 0i, "(0.000e+00+0.000e+00i)"},
+	{"%.3f", 0i, "(0.000+0.000i)"},
+	{"%.3F", 0i, "(0.000+0.000i)"},
+	{"%.3F", complex64(0i), "(0.000+0.000i)"},
+	{"%.3g", 0i, "(0+0i)"},
+	{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
+	{"%.3f", 1 + 2i, "(1.000+2.000i)"},
+	{"%.3g", 1 + 2i, "(1+2i)"},
+	{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
+	{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
+	{"%.3g", -1 - 2i, "(-1-2i)"},
+	{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
+	{"%+.3g", 1 + 2i, "(+1+2i)"},
+	{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
+	{"%#g", 1 + 2i, "(1.00000+2.00000i)"},
+	{"%#g", 123456 + 789012i, "(123456.+789012.i)"},
+	{"%#g", 1e-10i, "(0.00000+1.00000e-10i)"},
+	{"%#g", -1e10 - 1.11e100i, "(-1.00000e+10-1.11000e+100i)"},
+	{"%#.0f", 1.23 + 1.0i, "(1.+1.i)"},
+	{"%#.0e", 1.23 + 1.0i, "(1.e+00+1.e+00i)"},
+	{"%#.0g", 1.23 + 1.0i, "(1.+1.i)"},
+	{"%#.0g", 0 + 100000i, "(0.+1.e+05i)"},
+	{"%#.0g", 1230000 + 0i, "(1.e+06+0.i)"},
+	{"%#.4f", 1 + 1.23i, "(1.0000+1.2300i)"},
+	{"%#.4e", 123 + 1i, "(1.2300e+02+1.0000e+00i)"},
+	{"%#.4g", 123 + 1.23i, "(123.0+1.230i)"},
+	{"%#12.5g", 0 + 100000i, "(      0.0000 +1.0000e+05i)"},
+	{"%#12.5g", 1230000 - 0i, "(  1.2300e+06     +0.0000i)"},
+	{"%b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
+	{"%b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
+	// The sharp flag has no effect for binary complex format.
+	{"%#b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
+	// Precision has no effect for binary complex format.
+	{"%.4b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
+	{"%.4b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
+	// complex infinites and NaNs
+	{"%f", complex(posInf, posInf), "(+Inf+Infi)"},
+	{"%f", complex(negInf, negInf), "(-Inf-Infi)"},
+	{"%f", complex(NaN, NaN), "(NaN+NaNi)"},
+	{"%.1f", complex(posInf, posInf), "(+Inf+Infi)"},
+	{"% f", complex(posInf, posInf), "( Inf+Infi)"},
+	{"% f", complex(negInf, negInf), "(-Inf-Infi)"},
+	{"% f", complex(NaN, NaN), "( NaN+NaNi)"},
+	{"%8e", complex(posInf, posInf), "(    +Inf    +Infi)"},
+	{"% 8E", complex(posInf, posInf), "(     Inf    +Infi)"},
+	{"%+8f", complex(negInf, negInf), "(    -Inf    -Infi)"},
+	{"% +8g", complex(negInf, negInf), "(    -Inf    -Infi)"},
+	{"% -8G", complex(NaN, NaN), "( NaN    +NaN    i)"},
+	{"%+-8b", complex(NaN, NaN), "(+NaN    +NaN    i)"},
+	// Zero padding does not apply to infinities and NaN.
+	{"%08f", complex(posInf, posInf), "(    +Inf    +Infi)"},
+	{"%-08g", complex(negInf, negInf), "(-Inf    -Inf    i)"},
+	{"%-08G", complex(NaN, NaN), "(NaN     +NaN    i)"},
+
+	// old test/fmt_test.go
+	{"%e", 1.0, "1.000000e+00"},
+	{"%e", 1234.5678e3, "1.234568e+06"},
+	{"%e", 1234.5678e-8, "1.234568e-05"},
+	{"%e", -7.0, "-7.000000e+00"},
+	{"%e", -1e-9, "-1.000000e-09"},
+	{"%f", 1234.5678e3, "1234567.800000"},
+	{"%f", 1234.5678e-8, "0.000012"},
+	{"%f", -7.0, "-7.000000"},
+	{"%f", -1e-9, "-0.000000"},
+	{"%g", 1234.5678e3, "1.2345678e+06"},
+	{"%g", float32(1234.5678e3), "1.2345678e+06"},
+	{"%g", 1234.5678e-8, "1.2345678e-05"},
+	{"%g", -7.0, "-7"},
+	{"%g", -1e-9, "-1e-09"},
+	{"%g", float32(-1e-9), "-1e-09"},
+	{"%E", 1.0, "1.000000E+00"},
+	{"%E", 1234.5678e3, "1.234568E+06"},
+	{"%E", 1234.5678e-8, "1.234568E-05"},
+	{"%E", -7.0, "-7.000000E+00"},
+	{"%E", -1e-9, "-1.000000E-09"},
+	{"%G", 1234.5678e3, "1.2345678E+06"},
+	{"%G", float32(1234.5678e3), "1.2345678E+06"},
+	{"%G", 1234.5678e-8, "1.2345678E-05"},
+	{"%G", -7.0, "-7"},
+	{"%G", -1e-9, "-1E-09"},
+	{"%G", float32(-1e-9), "-1E-09"},
+	{"%20.5s", "qwertyuiop", "               qwert"},
+	{"%.5s", "qwertyuiop", "qwert"},
+	{"%-20.5s", "qwertyuiop", "qwert               "},
+	{"%20c", 'x', "                   x"},
+	{"%-20c", 'x', "x                   "},
+	{"%20.6e", 1.2345e3, "        1.234500e+03"},
+	{"%20.6e", 1.2345e-3, "        1.234500e-03"},
+	{"%20e", 1.2345e3, "        1.234500e+03"},
+	{"%20e", 1.2345e-3, "        1.234500e-03"},
+	{"%20.8e", 1.2345e3, "      1.23450000e+03"},
+	{"%20f", 1.23456789e3, "         1234.567890"},
+	{"%20f", 1.23456789e-3, "            0.001235"},
+	{"%20f", 12345678901.23456789, "  12345678901.234568"},
+	{"%-20f", 1.23456789e3, "1234.567890         "},
+	{"%20.8f", 1.23456789e3, "       1234.56789000"},
+	{"%20.8f", 1.23456789e-3, "          0.00123457"},
+	{"%g", 1.23456789e3, "1234.56789"},
+	{"%g", 1.23456789e-3, "0.00123456789"},
+	{"%g", 1.23456789e20, "1.23456789e+20"},
+
+	// arrays
+	{"%v", array, "[1 2 3 4 5]"},
+	{"%v", iarray, "[1 hello 2.5 <nil>]"},
+	{"%v", barray, "[1 2 3 4 5]"},
+	{"%v", &array, "&[1 2 3 4 5]"},
+	{"%v", &iarray, "&[1 hello 2.5 <nil>]"},
+	{"%v", &barray, "&[1 2 3 4 5]"},
+
+	// slices
+	{"%v", slice, "[1 2 3 4 5]"},
+	{"%v", islice, "[1 hello 2.5 <nil>]"},
+	{"%v", bslice, "[1 2 3 4 5]"},
+	{"%v", &slice, "&[1 2 3 4 5]"},
+	{"%v", &islice, "&[1 hello 2.5 <nil>]"},
+	{"%v", &bslice, "&[1 2 3 4 5]"},
+
+	// byte arrays and slices with %b,%c,%d,%o,%U and %v
+	{"%b", [3]byte{65, 66, 67}, "[1000001 1000010 1000011]"},
+	{"%c", [3]byte{65, 66, 67}, "[A B C]"},
+	{"%d", [3]byte{65, 66, 67}, "[65 66 67]"},
+	{"%o", [3]byte{65, 66, 67}, "[101 102 103]"},
+	{"%U", [3]byte{65, 66, 67}, "[U+0041 U+0042 U+0043]"},
+	{"%v", [3]byte{65, 66, 67}, "[65 66 67]"},
+	{"%v", [1]byte{123}, "[123]"},
+	{"%012v", []byte{}, "[]"},
+	{"%#012v", []byte{}, "[]byte{}"},
+	{"%6v", []byte{1, 11, 111}, "[     1     11    111]"},
+	{"%06v", []byte{1, 11, 111}, "[000001 000011 000111]"},
+	{"%-6v", []byte{1, 11, 111}, "[1      11     111   ]"},
+	{"%-06v", []byte{1, 11, 111}, "[1      11     111   ]"},
+	{"%#v", []byte{1, 11, 111}, "[]byte{0x1, 0xb, 0x6f}"},
+	{"%#6v", []byte{1, 11, 111}, "[]byte{   0x1,    0xb,   0x6f}"},
+	{"%#06v", []byte{1, 11, 111}, "[]byte{0x000001, 0x00000b, 0x00006f}"},
+	{"%#-6v", []byte{1, 11, 111}, "[]byte{0x1   , 0xb   , 0x6f  }"},
+	{"%#-06v", []byte{1, 11, 111}, "[]byte{0x1   , 0xb   , 0x6f  }"},
+	// f.space should and f.plus should not have an effect with %v.
+	{"% v", []byte{1, 11, 111}, "[ 1  11  111]"},
+	{"%+v", [3]byte{1, 11, 111}, "[1 11 111]"},
+	{"%# -6v", []byte{1, 11, 111}, "[]byte{ 0x1  ,  0xb  ,  0x6f }"},
+	{"%#+-6v", [3]byte{1, 11, 111}, "[3]uint8{0x1   , 0xb   , 0x6f  }"},
+	// f.space and f.plus should have an effect with %d.
+	{"% d", []byte{1, 11, 111}, "[ 1  11  111]"},
+	{"%+d", [3]byte{1, 11, 111}, "[+1 +11 +111]"},
+	{"%# -6d", []byte{1, 11, 111}, "[ 1      11     111  ]"},
+	{"%#+-6d", [3]byte{1, 11, 111}, "[+1     +11    +111  ]"},
+
+	// floates with %v
+	{"%v", 1.2345678, "1.2345678"},
+	{"%v", float32(1.2345678), "1.2345678"},
+
+	// complexes with %v
+	{"%v", 1 + 2i, "(1+2i)"},
+	{"%v", complex64(1 + 2i), "(1+2i)"},
+
+	// structs
+	{"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`},
+	{"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`},
+
+	// +v on structs with Stringable items
+	{"%+v", B{1, 2}, `{I:<1> j:2}`},
+	{"%+v", C{1, B{2, 3}}, `{i:1 B:{I:<2> j:3}}`},
+
+	// other formats on Stringable items
+	{"%s", I(23), `<23>`},
+	{"%q", I(23), `"<23>"`},
+	{"%x", I(23), `3c32333e`},
+	{"%#x", I(23), `0x3c32333e`},
+	{"%# x", I(23), `0x3c 0x32 0x33 0x3e`},
+	// Stringer applies only to string formats.
+	{"%d", I(23), `23`},
+	// Stringer applies to the extracted value.
+	{"%s", reflect.ValueOf(I(23)), `<23>`},
+
+	// go syntax
+	{"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`},
+	{"%#v", new(byte), "(*uint8)(0xPTR)"},
+	{"%#v", TestFmtInterface, "(func(*testing.T))(0xPTR)"},
+	{"%#v", make(chan int), "(chan int)(0xPTR)"},
+	{"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
+	{"%#v", 1000000000, "1000000000"},
+	{"%#v", map[string]int{"a": 1}, `map[string]int{"a":1}`},
+	{"%#v", map[string]B{"a": {1, 2}}, `map[string]fmt_test.B{"a":fmt_test.B{I:1, j:2}}`},
+	{"%#v", []string{"a", "b"}, `[]string{"a", "b"}`},
+	{"%#v", SI{}, `fmt_test.SI{I:interface {}(nil)}`},
+	{"%#v", []int(nil), `[]int(nil)`},
+	{"%#v", []int{}, `[]int{}`},
+	{"%#v", array, `[5]int{1, 2, 3, 4, 5}`},
+	{"%#v", &array, `&[5]int{1, 2, 3, 4, 5}`},
+	{"%#v", iarray, `[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
+	{"%#v", &iarray, `&[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
+	{"%#v", map[int]byte(nil), `map[int]uint8(nil)`},
+	{"%#v", map[int]byte{}, `map[int]uint8{}`},
+	{"%#v", "foo", `"foo"`},
+	{"%#v", barray, `[5]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
+	{"%#v", bslice, `[]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
+	{"%#v", []int32(nil), "[]int32(nil)"},
+	{"%#v", 1.2345678, "1.2345678"},
+	{"%#v", float32(1.2345678), "1.2345678"},
+	// Only print []byte and []uint8 as type []byte if they appear at the top level.
+	{"%#v", []byte(nil), "[]byte(nil)"},
+	{"%#v", []uint8(nil), "[]byte(nil)"},
+	{"%#v", []byte{}, "[]byte{}"},
+	{"%#v", []uint8{}, "[]byte{}"},
+	{"%#v", reflect.ValueOf([]byte{}), "[]uint8{}"},
+	{"%#v", reflect.ValueOf([]uint8{}), "[]uint8{}"},
+	{"%#v", &[]byte{}, "&[]uint8{}"},
+	{"%#v", &[]byte{}, "&[]uint8{}"},
+	{"%#v", [3]byte{}, "[3]uint8{0x0, 0x0, 0x0}"},
+	{"%#v", [3]uint8{}, "[3]uint8{0x0, 0x0, 0x0}"},
+
+	// slices with other formats
+	{"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`},
+	{"%x", []int{1, 2, 15}, `[1 2 f]`},
+	{"%d", []int{1, 2, 15}, `[1 2 15]`},
+	{"%d", []byte{1, 2, 15}, `[1 2 15]`},
+	{"%q", []string{"a", "b"}, `["a" "b"]`},
+	{"% 02x", []byte{1}, "01"},
+	{"% 02x", []byte{1, 2, 3}, "01 02 03"},
+
+	// Padding with byte slices.
+	{"%2x", []byte{}, "  "},
+	{"%#2x", []byte{}, "  "},
+	{"% 02x", []byte{}, "00"},
+	{"%# 02x", []byte{}, "00"},
+	{"%-2x", []byte{}, "  "},
+	{"%-02x", []byte{}, "  "},
+	{"%8x", []byte{0xab}, "      ab"},
+	{"% 8x", []byte{0xab}, "      ab"},
+	{"%#8x", []byte{0xab}, "    0xab"},
+	{"%# 8x", []byte{0xab}, "    0xab"},
+	{"%08x", []byte{0xab}, "000000ab"},
+	{"% 08x", []byte{0xab}, "000000ab"},
+	{"%#08x", []byte{0xab}, "00000xab"},
+	{"%# 08x", []byte{0xab}, "00000xab"},
+	{"%10x", []byte{0xab, 0xcd}, "      abcd"},
+	{"% 10x", []byte{0xab, 0xcd}, "     ab cd"},
+	{"%#10x", []byte{0xab, 0xcd}, "    0xabcd"},
+	{"%# 10x", []byte{0xab, 0xcd}, " 0xab 0xcd"},
+	{"%010x", []byte{0xab, 0xcd}, "000000abcd"},
+	{"% 010x", []byte{0xab, 0xcd}, "00000ab cd"},
+	{"%#010x", []byte{0xab, 0xcd}, "00000xabcd"},
+	{"%# 010x", []byte{0xab, 0xcd}, "00xab 0xcd"},
+	{"%-10X", []byte{0xab}, "AB        "},
+	{"% -010X", []byte{0xab}, "AB        "},
+	{"%#-10X", []byte{0xab, 0xcd}, "0XABCD    "},
+	{"%# -010X", []byte{0xab, 0xcd}, "0XAB 0XCD "},
+	// Same for strings
+	{"%2x", "", "  "},
+	{"%#2x", "", "  "},
+	{"% 02x", "", "00"},
+	{"%# 02x", "", "00"},
+	{"%-2x", "", "  "},
+	{"%-02x", "", "  "},
+	{"%8x", "\xab", "      ab"},
+	{"% 8x", "\xab", "      ab"},
+	{"%#8x", "\xab", "    0xab"},
+	{"%# 8x", "\xab", "    0xab"},
+	{"%08x", "\xab", "000000ab"},
+	{"% 08x", "\xab", "000000ab"},
+	{"%#08x", "\xab", "00000xab"},
+	{"%# 08x", "\xab", "00000xab"},
+	{"%10x", "\xab\xcd", "      abcd"},
+	{"% 10x", "\xab\xcd", "     ab cd"},
+	{"%#10x", "\xab\xcd", "    0xabcd"},
+	{"%# 10x", "\xab\xcd", " 0xab 0xcd"},
+	{"%010x", "\xab\xcd", "000000abcd"},
+	{"% 010x", "\xab\xcd", "00000ab cd"},
+	{"%#010x", "\xab\xcd", "00000xabcd"},
+	{"%# 010x", "\xab\xcd", "00xab 0xcd"},
+	{"%-10X", "\xab", "AB        "},
+	{"% -010X", "\xab", "AB        "},
+	{"%#-10X", "\xab\xcd", "0XABCD    "},
+	{"%# -010X", "\xab\xcd", "0XAB 0XCD "},
+
+	// renamings
+	{"%v", renamedBool(true), "true"},
+	{"%d", renamedBool(true), "%!d(fmt_test.renamedBool=true)"},
+	{"%o", renamedInt(8), "10"},
+	{"%d", renamedInt8(-9), "-9"},
+	{"%v", renamedInt16(10), "10"},
+	{"%v", renamedInt32(-11), "-11"},
+	{"%X", renamedInt64(255), "FF"},
+	{"%v", renamedUint(13), "13"},
+	{"%o", renamedUint8(14), "16"},
+	{"%X", renamedUint16(15), "F"},
+	{"%d", renamedUint32(16), "16"},
+	{"%X", renamedUint64(17), "11"},
+	{"%o", renamedUintptr(18), "22"},
+	{"%x", renamedString("thing"), "7468696e67"},
+	{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},
+	{"%q", renamedBytes([]byte("hello")), `"hello"`},
+	{"%x", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "68656c6c6f"},
+	{"%X", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "68656C6C6F"},
+	{"%s", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "hello"},
+	{"%q", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, `"hello"`},
+	{"%v", renamedFloat32(22), "22"},
+	{"%v", renamedFloat64(33), "33"},
+	{"%v", renamedComplex64(3 + 4i), "(3+4i)"},
+	{"%v", renamedComplex128(4 - 3i), "(4-3i)"},
+
+	// Formatter
+	{"%x", F(1), "<x=F(1)>"},
+	{"%x", G(2), "2"},
+	{"%+v", S{F(4), G(5)}, "{F:<v=F(4)> G:5}"},
+
+	// GoStringer
+	{"%#v", G(6), "GoString(6)"},
+	{"%#v", S{F(7), G(8)}, "fmt_test.S{F:<v=F(7)>, G:GoString(8)}"},
+
+	// %T
+	{"%T", byte(0), "uint8"},
+	{"%T", reflect.ValueOf(nil), "reflect.Value"},
+	{"%T", (4 - 3i), "complex128"},
+	{"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"},
+	{"%T", intVar, "int"},
+	{"%6T", &intVar, "  *int"},
+	{"%10T", nil, "     <nil>"},
+	{"%-10T", nil, "<nil>     "},
+
+	// %p with pointers
+	{"%p", (*int)(nil), "0x0"},
+	{"%#p", (*int)(nil), "0"},
+	{"%p", &intVar, "0xPTR"},
+	{"%#p", &intVar, "PTR"},
+	{"%p", &array, "0xPTR"},
+	{"%p", &slice, "0xPTR"},
+	{"%8.2p", (*int)(nil), "    0x00"},
+	{"%-20.16p", &intVar, "0xPTR  "},
+	// %p on non-pointers
+	{"%p", make(chan int), "0xPTR"},
+	{"%p", make(map[int]int), "0xPTR"},
+	{"%p", func() {}, "0xPTR"},
+	{"%p", 27, "%!p(int=27)"},  // not a pointer at all
+	{"%p", nil, "%!p(<nil>)"},  // nil on its own has no type ...
+	{"%#p", nil, "%!p(<nil>)"}, // ... and hence is not a pointer type.
+	// pointers with specified base
+	{"%b", &intVar, "PTR_b"},
+	{"%d", &intVar, "PTR_d"},
+	{"%o", &intVar, "PTR_o"},
+	{"%x", &intVar, "PTR_x"},
+	{"%X", &intVar, "PTR_X"},
+	// %v on pointers
+	{"%v", nil, "<nil>"},
+	{"%#v", nil, "<nil>"},
+	{"%v", (*int)(nil), "<nil>"},
+	{"%#v", (*int)(nil), "(*int)(nil)"},
+	{"%v", &intVar, "0xPTR"},
+	{"%#v", &intVar, "(*int)(0xPTR)"},
+	{"%8.2v", (*int)(nil), "   <nil>"},
+	{"%-20.16v", &intVar, "0xPTR  "},
+	// string method on pointer
+	{"%s", &pValue, "String(p)"}, // String method...
+	{"%p", &pValue, "0xPTR"},     // ... is not called with %p.
+
+	// %d on Stringer should give integer if possible
+	{"%s", time.Time{}.Month(), "January"},
+	{"%d", time.Time{}.Month(), "1"},
+
+	// erroneous things
+	{"", nil, "%!(EXTRA <nil>)"},
+	{"", 2, "%!(EXTRA int=2)"},
+	{"no args", "hello", "no args%!(EXTRA string=hello)"},
+	{"%s %", "hello", "hello %!(NOVERB)"},
+	{"%s %.2", "hello", "hello %!(NOVERB)"},
+	{"%017091901790959340919092959340919017929593813360", 0, "%!(NOVERB)%!(EXTRA int=0)"},
+	{"%184467440737095516170v", 0, "%!(NOVERB)%!(EXTRA int=0)"},
+	// Extra argument errors should format without flags set.
+	{"%010.2", "12345", "%!(NOVERB)%!(EXTRA string=12345)"},
+
+	// The "<nil>" show up because maps are printed by
+	// first obtaining a list of keys and then looking up
+	// each key. Since NaNs can be map keys but cannot
+	// be fetched directly, the lookup fails and returns a
+	// zero reflect.Value, which formats as <nil>.
+	// This test is just to check that it shows the two NaNs at all.
+	{"%v", map[float64]int{NaN: 1, NaN: 2}, "map[NaN:<nil> NaN:<nil>]"},
+
+	// Comparison of padding rules with C printf.
+	/*
+		C program:
+		#include <stdio.h>
+
+		char *format[] = {
+			"[%.2f]",
+			"[% .2f]",
+			"[%+.2f]",
+			"[%7.2f]",
+			"[% 7.2f]",
+			"[%+7.2f]",
+			"[% +7.2f]",
+			"[%07.2f]",
+			"[% 07.2f]",
+			"[%+07.2f]",
+			"[% +07.2f]"
+		};
+
+		int main(void) {
+			int i;
+			for(i = 0; i < 11; i++) {
+				printf("%s: ", format[i]);
+				printf(format[i], 1.0);
+				printf(" ");
+				printf(format[i], -1.0);
+				printf("\n");
+			}
+		}
+
+		Output:
+			[%.2f]: [1.00] [-1.00]
+			[% .2f]: [ 1.00] [-1.00]
+			[%+.2f]: [+1.00] [-1.00]
+			[%7.2f]: [   1.00] [  -1.00]
+			[% 7.2f]: [   1.00] [  -1.00]
+			[%+7.2f]: [  +1.00] [  -1.00]
+			[% +7.2f]: [  +1.00] [  -1.00]
+			[%07.2f]: [0001.00] [-001.00]
+			[% 07.2f]: [ 001.00] [-001.00]
+			[%+07.2f]: [+001.00] [-001.00]
+			[% +07.2f]: [+001.00] [-001.00]
+
+	*/
+	{"%.2f", 1.0, "1.00"},
+	{"%.2f", -1.0, "-1.00"},
+	{"% .2f", 1.0, " 1.00"},
+	{"% .2f", -1.0, "-1.00"},
+	{"%+.2f", 1.0, "+1.00"},
+	{"%+.2f", -1.0, "-1.00"},
+	{"%7.2f", 1.0, "   1.00"},
+	{"%7.2f", -1.0, "  -1.00"},
+	{"% 7.2f", 1.0, "   1.00"},
+	{"% 7.2f", -1.0, "  -1.00"},
+	{"%+7.2f", 1.0, "  +1.00"},
+	{"%+7.2f", -1.0, "  -1.00"},
+	{"% +7.2f", 1.0, "  +1.00"},
+	{"% +7.2f", -1.0, "  -1.00"},
+	{"%07.2f", 1.0, "0001.00"},
+	{"%07.2f", -1.0, "-001.00"},
+	{"% 07.2f", 1.0, " 001.00"},
+	{"% 07.2f", -1.0, "-001.00"},
+	{"%+07.2f", 1.0, "+001.00"},
+	{"%+07.2f", -1.0, "-001.00"},
+	{"% +07.2f", 1.0, "+001.00"},
+	{"% +07.2f", -1.0, "-001.00"},
+
+	// Complex numbers: exhaustively tested in TestComplexFormatting.
+	{"%7.2f", 1 + 2i, "(   1.00  +2.00i)"},
+	{"%+07.2f", -1 - 2i, "(-001.00-002.00i)"},
+
+	// Use spaces instead of zero if padding to the right.
+	{"%0-5s", "abc", "abc  "},
+	{"%-05.1f", 1.0, "1.0  "},
+
+	// float and complex formatting should not change the padding width
+	// for other elements. See issue 14642.
+	{"%06v", []interface{}{+10.0, 10}, "[000010 000010]"},
+	{"%06v", []interface{}{-10.0, 10}, "[-00010 000010]"},
+	{"%06v", []interface{}{+10.0 + 10i, 10}, "[(000010+00010i) 000010]"},
+	{"%06v", []interface{}{-10.0 + 10i, 10}, "[(-00010+00010i) 000010]"},
+
+	// integer formatting should not alter padding for other elements.
+	{"%03.6v", []interface{}{1, 2.0, "x"}, "[000001 002 00x]"},
+	{"%03.0v", []interface{}{0, 2.0, "x"}, "[    002 000]"},
+
+	// Complex fmt used to leave the plus flag set for future entries in the array
+	// causing +2+0i and +3+0i instead of 2+0i and 3+0i.
+	{"%v", []complex64{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
+	{"%v", []complex128{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
+
+	// Incomplete format specification caused crash.
+	{"%.", 3, "%!.(int=3)"},
+
+	// Padding for complex numbers. Has been bad, then fixed, then bad again.
+	{"%+10.2f", +104.66 + 440.51i, "(   +104.66   +440.51i)"},
+	{"%+10.2f", -104.66 + 440.51i, "(   -104.66   +440.51i)"},
+	{"%+10.2f", +104.66 - 440.51i, "(   +104.66   -440.51i)"},
+	{"%+10.2f", -104.66 - 440.51i, "(   -104.66   -440.51i)"},
+	{"%+010.2f", +104.66 + 440.51i, "(+000104.66+000440.51i)"},
+	{"%+010.2f", -104.66 + 440.51i, "(-000104.66+000440.51i)"},
+	{"%+010.2f", +104.66 - 440.51i, "(+000104.66-000440.51i)"},
+	{"%+010.2f", -104.66 - 440.51i, "(-000104.66-000440.51i)"},
+
+	// []T where type T is a byte with a Stringer method.
+	{"%v", byteStringerSlice, "[X X X X X]"},
+	{"%s", byteStringerSlice, "hello"},
+	{"%q", byteStringerSlice, "\"hello\""},
+	{"%x", byteStringerSlice, "68656c6c6f"},
+	{"%X", byteStringerSlice, "68656C6C6F"},
+	{"%#v", byteStringerSlice, "[]fmt_test.byteStringer{0x68, 0x65, 0x6c, 0x6c, 0x6f}"},
+
+	// And the same for Formatter.
+	{"%v", byteFormatterSlice, "[X X X X X]"},
+	{"%s", byteFormatterSlice, "hello"},
+	{"%q", byteFormatterSlice, "\"hello\""},
+	{"%x", byteFormatterSlice, "68656c6c6f"},
+	{"%X", byteFormatterSlice, "68656C6C6F"},
+	// This next case seems wrong, but the docs say the Formatter wins here.
+	{"%#v", byteFormatterSlice, "[]fmt_test.byteFormatter{X, X, X, X, X}"},
+
+	// reflect.Value handled specially in Go 1.5, making it possible to
+	// see inside non-exported fields (which cannot be accessed with Interface()).
+	// Issue 8965.
+	{"%v", reflect.ValueOf(A{}).Field(0).String(), "<int Value>"}, // Equivalent to the old way.
+	{"%v", reflect.ValueOf(A{}).Field(0), "0"},                    // Sees inside the field.
+
+	// verbs apply to the extracted value too.
+	{"%s", reflect.ValueOf("hello"), "hello"},
+	{"%q", reflect.ValueOf("hello"), `"hello"`},
+	{"%#04x", reflect.ValueOf(256), "0x0100"},
+
+	// invalid reflect.Value doesn't crash.
+	{"%v", reflect.Value{}, "<invalid reflect.Value>"},
+	{"%v", &reflect.Value{}, "<invalid Value>"},
+	{"%v", SI{reflect.Value{}}, "{<invalid Value>}"},
+
+	// Tests to check that not supported verbs generate an error string.
+	{"%☠", nil, "%!☠(<nil>)"},
+	{"%☠", interface{}(nil), "%!☠(<nil>)"},
+	{"%☠", int(0), "%!☠(int=0)"},
+	{"%☠", uint(0), "%!☠(uint=0)"},
+	{"%☠", []byte{0, 1}, "[%!☠(uint8=0) %!☠(uint8=1)]"},
+	{"%☠", []uint8{0, 1}, "[%!☠(uint8=0) %!☠(uint8=1)]"},
+	{"%☠", [1]byte{0}, "[%!☠(uint8=0)]"},
+	{"%☠", [1]uint8{0}, "[%!☠(uint8=0)]"},
+	{"%☠", "hello", "%!☠(string=hello)"},
+	{"%☠", 1.2345678, "%!☠(float64=1.2345678)"},
+	{"%☠", float32(1.2345678), "%!☠(float32=1.2345678)"},
+	{"%☠", 1.2345678 + 1.2345678i, "%!☠(complex128=(1.2345678+1.2345678i))"},
+	{"%☠", complex64(1.2345678 + 1.2345678i), "%!☠(complex64=(1.2345678+1.2345678i))"},
+	{"%☠", &intVar, "%!☠(*int=0xPTR)"},
+	{"%☠", make(chan int), "%!☠(chan int=0xPTR)"},
+	{"%☠", func() {}, "%!☠(func()=0xPTR)"},
+	{"%☠", reflect.ValueOf(renamedInt(0)), "%!☠(fmt_test.renamedInt=0)"},
+	{"%☠", SI{renamedInt(0)}, "{%!☠(fmt_test.renamedInt=0)}"},
+	{"%☠", &[]interface{}{I(1), G(2)}, "&[%!☠(fmt_test.I=1) %!☠(fmt_test.G=2)]"},
+	{"%☠", SI{&[]interface{}{I(1), G(2)}}, "{%!☠(*[]interface {}=&[1 2])}"},
+	{"%☠", reflect.Value{}, "<invalid reflect.Value>"},
+	{"%☠", map[float64]int{NaN: 1}, "map[%!☠(float64=NaN):%!☠(<nil>)]"},
+}
+
+// zeroFill generates zero-filled strings of the specified width. The length
+// of the suffix (but not the prefix) is compensated for in the width calculation.
+func zeroFill(prefix string, width int, suffix string) string {
+	return prefix + strings.Repeat("0", width-len(suffix)) + suffix
+}
+
+func TestSprintf(t *testing.T) {
+	for _, tt := range fmtTests {
+		s := Sprintf(tt.fmt, tt.val)
+		i := strings.Index(tt.out, "PTR")
+		if i >= 0 && i < len(s) {
+			var pattern, chars string
+			switch {
+			case strings.HasPrefix(tt.out[i:], "PTR_b"):
+				pattern = "PTR_b"
+				chars = "01"
+			case strings.HasPrefix(tt.out[i:], "PTR_o"):
+				pattern = "PTR_o"
+				chars = "01234567"
+			case strings.HasPrefix(tt.out[i:], "PTR_d"):
+				pattern = "PTR_d"
+				chars = "0123456789"
+			case strings.HasPrefix(tt.out[i:], "PTR_x"):
+				pattern = "PTR_x"
+				chars = "0123456789abcdef"
+			case strings.HasPrefix(tt.out[i:], "PTR_X"):
+				pattern = "PTR_X"
+				chars = "0123456789ABCDEF"
+			default:
+				pattern = "PTR"
+				chars = "0123456789abcdefABCDEF"
+			}
+			p := s[:i] + pattern
+			for j := i; j < len(s); j++ {
+				if !strings.ContainsRune(chars, rune(s[j])) {
+					p += s[j:]
+					break
+				}
+			}
+			s = p
+		}
+		if s != tt.out {
+			if _, ok := tt.val.(string); ok {
+				// Don't requote the already-quoted strings.
+				// It's too confusing to read the errors.
+				t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
+			} else {
+				t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
+			}
+		}
+	}
+}
+
+// TestComplexFormatting checks that a complex always formats to the same
+// thing as if done by hand with two singleton prints.
+func TestComplexFormatting(t *testing.T) {
+	var yesNo = []bool{true, false}
+	var values = []float64{1, 0, -1, posInf, negInf, NaN}
+	for _, plus := range yesNo {
+		for _, zero := range yesNo {
+			for _, space := range yesNo {
+				for _, char := range "fFeEgG" {
+					realFmt := "%"
+					if zero {
+						realFmt += "0"
+					}
+					if space {
+						realFmt += " "
+					}
+					if plus {
+						realFmt += "+"
+					}
+					realFmt += "10.2"
+					realFmt += string(char)
+					// Imaginary part always has a sign, so force + and ignore space.
+					imagFmt := "%"
+					if zero {
+						imagFmt += "0"
+					}
+					imagFmt += "+"
+					imagFmt += "10.2"
+					imagFmt += string(char)
+					for _, realValue := range values {
+						for _, imagValue := range values {
+							one := Sprintf(realFmt, complex(realValue, imagValue))
+							two := Sprintf("("+realFmt+imagFmt+"i)", realValue, imagValue)
+							if one != two {
+								t.Error(f, one, two)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+type SE []interface{} // slice of empty; notational compactness.
+
+var reorderTests = []struct {
+	fmt string
+	val SE
+	out string
+}{
+	{"%[1]d", SE{1}, "1"},
+	{"%[2]d", SE{2, 1}, "1"},
+	{"%[2]d %[1]d", SE{1, 2}, "2 1"},
+	{"%[2]*[1]d", SE{2, 5}, "    2"},
+	{"%6.2f", SE{12.0}, " 12.00"}, // Explicit version of next line.
+	{"%[3]*.[2]*[1]f", SE{12.0, 2, 6}, " 12.00"},
+	{"%[1]*.[2]*[3]f", SE{6, 2, 12.0}, " 12.00"},
+	{"%10f", SE{12.0}, " 12.000000"},
+	{"%[1]*[3]f", SE{10, 99, 12.0}, " 12.000000"},
+	{"%.6f", SE{12.0}, "12.000000"}, // Explicit version of next line.
+	{"%.[1]*[3]f", SE{6, 99, 12.0}, "12.000000"},
+	{"%6.f", SE{12.0}, "    12"}, //  // Explicit version of next line; empty precision means zero.
+	{"%[1]*.[3]f", SE{6, 3, 12.0}, "    12"},
+	// An actual use! Print the same arguments twice.
+	{"%d %d %d %#[1]o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015"},
+
+	// Erroneous cases.
+	{"%[d", SE{2, 1}, "%!d(BADINDEX)"},
+	{"%]d", SE{2, 1}, "%!](int=2)d%!(EXTRA int=1)"},
+	{"%[]d", SE{2, 1}, "%!d(BADINDEX)"},
+	{"%[-3]d", SE{2, 1}, "%!d(BADINDEX)"},
+	{"%[99]d", SE{2, 1}, "%!d(BADINDEX)"},
+	{"%[3]", SE{2, 1}, "%!(NOVERB)"},
+	{"%[1].2d", SE{5, 6}, "%!d(BADINDEX)"},
+	{"%[1]2d", SE{2, 1}, "%!d(BADINDEX)"},
+	{"%3.[2]d", SE{7}, "%!d(BADINDEX)"},
+	{"%.[2]d", SE{7}, "%!d(BADINDEX)"},
+	{"%d %d %d %#[1]o %#o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015 %!o(MISSING)"},
+	{"%[5]d %[2]d %d", SE{1, 2, 3}, "%!d(BADINDEX) 2 3"},
+	{"%d %[3]d %d", SE{1, 2}, "1 %!d(BADINDEX) 2"}, // Erroneous index does not affect sequence.
+	{"%.[]", SE{}, "%!](BADINDEX)"},                // Issue 10675
+	{"%.-3d", SE{42}, "%!-(int=42)3d"},             // TODO: Should this set return better error messages?
+	{"%2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
+	{"%-2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
+	{"%.2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
+}
+
+func TestReorder(t *testing.T) {
+	for _, tt := range reorderTests {
+		s := Sprintf(tt.fmt, tt.val...)
+		if s != tt.out {
+			t.Errorf("Sprintf(%q, %v) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
+		} else {
+		}
+	}
+}
+
+func BenchmarkSprintfPadding(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%16f", 1.0)
+		}
+	})
+}
+
+func BenchmarkSprintfEmpty(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("")
+		}
+	})
+}
+
+func BenchmarkSprintfString(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%s", "hello")
+		}
+	})
+}
+
+func BenchmarkSprintfTruncateString(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%.3s", "日本語日本語日本語")
+		}
+	})
+}
+
+func BenchmarkSprintfQuoteString(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%q", "日本語日本語日本語")
+		}
+	})
+}
+
+func BenchmarkSprintfInt(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%d", 5)
+		}
+	})
+}
+
+func BenchmarkSprintfIntInt(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%d %d", 5, 6)
+		}
+	})
+}
+
+func BenchmarkSprintfPrefixedInt(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("This is some meaningless prefix text that needs to be scanned %d", 6)
+		}
+	})
+}
+
+func BenchmarkSprintfFloat(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%g", 5.23184)
+		}
+	})
+}
+
+func BenchmarkSprintfComplex(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%f", 5.23184+5.23184i)
+		}
+	})
+}
+
+func BenchmarkSprintfBoolean(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%t", true)
+		}
+	})
+}
+
+func BenchmarkSprintfHexString(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("% #x", "0123456789abcdef")
+		}
+	})
+}
+
+func BenchmarkSprintfHexBytes(b *testing.B) {
+	data := []byte("0123456789abcdef")
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("% #x", data)
+		}
+	})
+}
+
+func BenchmarkSprintfBytes(b *testing.B) {
+	data := []byte("0123456789abcdef")
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%v", data)
+		}
+	})
+}
+
+func BenchmarkSprintfStringer(b *testing.B) {
+	stringer := I(12345)
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%v", stringer)
+		}
+	})
+}
+
+func BenchmarkSprintfStructure(b *testing.B) {
+	s := &[]interface{}{SI{12345}, map[int]string{0: "hello"}}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			Sprintf("%#v", s)
+		}
+	})
+}
+
+func BenchmarkManyArgs(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		var buf bytes.Buffer
+		for pb.Next() {
+			buf.Reset()
+			Fprintf(&buf, "%2d/%2d/%2d %d:%d:%d %s %s\n", 3, 4, 5, 11, 12, 13, "hello", "world")
+		}
+	})
+}
+
+func BenchmarkFprintInt(b *testing.B) {
+	var buf bytes.Buffer
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		Fprint(&buf, 123456)
+	}
+}
+
+func BenchmarkFprintfBytes(b *testing.B) {
+	data := []byte(string("0123456789"))
+	var buf bytes.Buffer
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		Fprintf(&buf, "%s", data)
+	}
+}
+
+func BenchmarkFprintIntNoAlloc(b *testing.B) {
+	var x interface{} = 123456
+	var buf bytes.Buffer
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		Fprint(&buf, x)
+	}
+}
+
+var mallocBuf bytes.Buffer
+var mallocPointer *int // A pointer so we know the interface value won't allocate.
+
+var mallocTest = []struct {
+	count int
+	desc  string
+	fn    func()
+}{
+	{0, `Sprintf("")`, func() { Sprintf("") }},
+	{1, `Sprintf("xxx")`, func() { Sprintf("xxx") }},
+	{2, `Sprintf("%x")`, func() { Sprintf("%x", 7) }},
+	{2, `Sprintf("%s")`, func() { Sprintf("%s", "hello") }},
+	{3, `Sprintf("%x %x")`, func() { Sprintf("%x %x", 7, 112) }},
+	{2, `Sprintf("%g")`, func() { Sprintf("%g", float32(3.14159)) }}, // TODO: Can this be 1?
+	{1, `Fprintf(buf, "%s")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%s", "hello") }},
+	// If the interface value doesn't need to allocate, amortized allocation overhead should be zero.
+	{0, `Fprintf(buf, "%x %x %x")`, func() {
+		mallocBuf.Reset()
+		Fprintf(&mallocBuf, "%x %x %x", mallocPointer, mallocPointer, mallocPointer)
+	}},
+}
+
+var _ bytes.Buffer
+
+func TestCountMallocs(t *testing.T) {
+	switch {
+	case testing.Short():
+		t.Skip("skipping malloc count in short mode")
+	case runtime.GOMAXPROCS(0) > 1:
+		t.Skip("skipping; GOMAXPROCS>1")
+	case race.Enabled:
+		t.Skip("skipping malloc count under race detector")
+	}
+	for _, mt := range mallocTest {
+		mallocs := testing.AllocsPerRun(100, mt.fn)
+		if got, max := mallocs, float64(mt.count); got > max {
+			t.Errorf("%s: got %v allocs, want <=%v", mt.desc, got, max)
+		}
+	}
+}
+
+type flagPrinter struct{}
+
+func (flagPrinter) Format(f State, c rune) {
+	s := "%"
+	for i := 0; i < 128; i++ {
+		if f.Flag(i) {
+			s += string(i)
+		}
+	}
+	if w, ok := f.Width(); ok {
+		s += Sprintf("%d", w)
+	}
+	if p, ok := f.Precision(); ok {
+		s += Sprintf(".%d", p)
+	}
+	s += string(c)
+	io.WriteString(f, "["+s+"]")
+}
+
+var flagtests = []struct {
+	in  string
+	out string
+}{
+	{"%a", "[%a]"},
+	{"%-a", "[%-a]"},
+	{"%+a", "[%+a]"},
+	{"%#a", "[%#a]"},
+	{"% a", "[% a]"},
+	{"%0a", "[%0a]"},
+	{"%1.2a", "[%1.2a]"},
+	{"%-1.2a", "[%-1.2a]"},
+	{"%+1.2a", "[%+1.2a]"},
+	{"%-+1.2a", "[%+-1.2a]"},
+	{"%-+1.2abc", "[%+-1.2a]bc"},
+	{"%-1.2abc", "[%-1.2a]bc"},
+}
+
+func TestFlagParser(t *testing.T) {
+	var flagprinter flagPrinter
+	for _, tt := range flagtests {
+		s := Sprintf(tt.in, &flagprinter)
+		if s != tt.out {
+			t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
+		}
+	}
+}
+
+func TestStructPrinter(t *testing.T) {
+	type T struct {
+		a string
+		b string
+		c int
+	}
+	var s T
+	s.a = "abc"
+	s.b = "def"
+	s.c = 123
+	var tests = []struct {
+		fmt string
+		out string
+	}{
+		{"%v", "{abc def 123}"},
+		{"%+v", "{a:abc b:def c:123}"},
+		{"%#v", `fmt_test.T{a:"abc", b:"def", c:123}`},
+	}
+	for _, tt := range tests {
+		out := Sprintf(tt.fmt, s)
+		if out != tt.out {
+			t.Errorf("Sprintf(%q, s) = %#q, want %#q", tt.fmt, out, tt.out)
+		}
+		// The same but with a pointer.
+		out = Sprintf(tt.fmt, &s)
+		if out != "&"+tt.out {
+			t.Errorf("Sprintf(%q, &s) = %#q, want %#q", tt.fmt, out, "&"+tt.out)
+		}
+	}
+}
+
+func TestSlicePrinter(t *testing.T) {
+	slice := []int{}
+	s := Sprint(slice)
+	if s != "[]" {
+		t.Errorf("empty slice printed as %q not %q", s, "[]")
+	}
+	slice = []int{1, 2, 3}
+	s = Sprint(slice)
+	if s != "[1 2 3]" {
+		t.Errorf("slice: got %q expected %q", s, "[1 2 3]")
+	}
+	s = Sprint(&slice)
+	if s != "&[1 2 3]" {
+		t.Errorf("&slice: got %q expected %q", s, "&[1 2 3]")
+	}
+}
+
+// presentInMap checks map printing using substrings so we don't depend on the
+// print order.
+func presentInMap(s string, a []string, t *testing.T) {
+	for i := 0; i < len(a); i++ {
+		loc := strings.Index(s, a[i])
+		if loc < 0 {
+			t.Errorf("map print: expected to find %q in %q", a[i], s)
+		}
+		// make sure the match ends here
+		loc += len(a[i])
+		if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
+			t.Errorf("map print: %q not properly terminated in %q", a[i], s)
+		}
+	}
+}
+
+func TestMapPrinter(t *testing.T) {
+	m0 := make(map[int]string)
+	s := Sprint(m0)
+	if s != "map[]" {
+		t.Errorf("empty map printed as %q not %q", s, "map[]")
+	}
+	m1 := map[int]string{1: "one", 2: "two", 3: "three"}
+	a := []string{"1:one", "2:two", "3:three"}
+	presentInMap(Sprintf("%v", m1), a, t)
+	presentInMap(Sprint(m1), a, t)
+	// Pointer to map prints the same but with initial &.
+	if !strings.HasPrefix(Sprint(&m1), "&") {
+		t.Errorf("no initial & for address of map")
+	}
+	presentInMap(Sprintf("%v", &m1), a, t)
+	presentInMap(Sprint(&m1), a, t)
+}
+
+func TestEmptyMap(t *testing.T) {
+	const emptyMapStr = "map[]"
+	var m map[string]int
+	s := Sprint(m)
+	if s != emptyMapStr {
+		t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
+	}
+	m = make(map[string]int)
+	s = Sprint(m)
+	if s != emptyMapStr {
+		t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
+	}
+}
+
+// TestBlank checks that Sprint (and hence Print, Fprint) puts spaces in the
+// right places, that is, between arg pairs in which neither is a string.
+func TestBlank(t *testing.T) {
+	got := Sprint("<", 1, ">:", 1, 2, 3, "!")
+	expect := "<1>:1 2 3!"
+	if got != expect {
+		t.Errorf("got %q expected %q", got, expect)
+	}
+}
+
+// TestBlankln checks that Sprintln (and hence Println, Fprintln) puts spaces in
+// the right places, that is, between all arg pairs.
+func TestBlankln(t *testing.T) {
+	got := Sprintln("<", 1, ">:", 1, 2, 3, "!")
+	expect := "< 1 >: 1 2 3 !\n"
+	if got != expect {
+		t.Errorf("got %q expected %q", got, expect)
+	}
+}
+
+// TestFormatterPrintln checks Formatter with Sprint, Sprintln, Sprintf.
+func TestFormatterPrintln(t *testing.T) {
+	f := F(1)
+	expect := "<v=F(1)>\n"
+	s := Sprint(f, "\n")
+	if s != expect {
+		t.Errorf("Sprint wrong with Formatter: expected %q got %q", expect, s)
+	}
+	s = Sprintln(f)
+	if s != expect {
+		t.Errorf("Sprintln wrong with Formatter: expected %q got %q", expect, s)
+	}
+	s = Sprintf("%v\n", f)
+	if s != expect {
+		t.Errorf("Sprintf wrong with Formatter: expected %q got %q", expect, s)
+	}
+}
+
+func args(a ...interface{}) []interface{} { return a }
+
+var startests = []struct {
+	fmt string
+	in  []interface{}
+	out string
+}{
+	{"%*d", args(4, 42), "  42"},
+	{"%-*d", args(4, 42), "42  "},
+	{"%*d", args(-4, 42), "42  "},
+	{"%-*d", args(-4, 42), "42  "},
+	{"%.*d", args(4, 42), "0042"},
+	{"%*.*d", args(8, 4, 42), "    0042"},
+	{"%0*d", args(4, 42), "0042"},
+	// Some non-int types for width. (Issue 10732).
+	{"%0*d", args(uint(4), 42), "0042"},
+	{"%0*d", args(uint64(4), 42), "0042"},
+	{"%0*d", args('\x04', 42), "0042"},
+	{"%0*d", args(uintptr(4), 42), "0042"},
+
+	// erroneous
+	{"%*d", args(nil, 42), "%!(BADWIDTH)42"},
+	{"%*d", args(int(1e7), 42), "%!(BADWIDTH)42"},
+	{"%*d", args(int(-1e7), 42), "%!(BADWIDTH)42"},
+	{"%.*d", args(nil, 42), "%!(BADPREC)42"},
+	{"%.*d", args(-1, 42), "%!(BADPREC)42"},
+	{"%.*d", args(int(1e7), 42), "%!(BADPREC)42"},
+	{"%.*d", args(uint(1e7), 42), "%!(BADPREC)42"},
+	{"%.*d", args(uint64(1<<63), 42), "%!(BADPREC)42"},   // Huge negative (-inf).
+	{"%.*d", args(uint64(1<<64-1), 42), "%!(BADPREC)42"}, // Small negative (-1).
+	{"%*d", args(5, "foo"), "%!d(string=  foo)"},
+	{"%*% %d", args(20, 5), "% 5"},
+	{"%*", args(4), "%!(NOVERB)"},
+}
+
+func TestWidthAndPrecision(t *testing.T) {
+	for i, tt := range startests {
+		s := Sprintf(tt.fmt, tt.in...)
+		if s != tt.out {
+			t.Errorf("#%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
+		}
+	}
+}
+
+// PanicS is a type that panics in String.
+type PanicS struct {
+	message interface{}
+}
+
+// Value receiver.
+func (p PanicS) String() string {
+	panic(p.message)
+}
+
+// PanicGo is a type that panics in GoString.
+type PanicGo struct {
+	message interface{}
+}
+
+// Value receiver.
+func (p PanicGo) GoString() string {
+	panic(p.message)
+}
+
+// PanicF is a type that panics in Format.
+type PanicF struct {
+	message interface{}
+}
+
+// Value receiver.
+func (p PanicF) Format(f State, c rune) {
+	panic(p.message)
+}
+
+var panictests = []struct {
+	fmt string
+	in  interface{}
+	out string
+}{
+	// String
+	{"%s", (*PanicS)(nil), "<nil>"}, // nil pointer special case
+	{"%s", PanicS{io.ErrUnexpectedEOF}, "%!s(PANIC=unexpected EOF)"},
+	{"%s", PanicS{3}, "%!s(PANIC=3)"},
+	// GoString
+	{"%#v", (*PanicGo)(nil), "<nil>"}, // nil pointer special case
+	{"%#v", PanicGo{io.ErrUnexpectedEOF}, "%!v(PANIC=unexpected EOF)"},
+	{"%#v", PanicGo{3}, "%!v(PANIC=3)"},
+	// Issue 18282. catchPanic should not clear fmtFlags permanently.
+	{"%#v", []interface{}{PanicGo{3}, PanicGo{3}}, "[]interface {}{%!v(PANIC=3), %!v(PANIC=3)}"},
+	// Format
+	{"%s", (*PanicF)(nil), "<nil>"}, // nil pointer special case
+	{"%s", PanicF{io.ErrUnexpectedEOF}, "%!s(PANIC=unexpected EOF)"},
+	{"%s", PanicF{3}, "%!s(PANIC=3)"},
+}
+
+func TestPanics(t *testing.T) {
+	for i, tt := range panictests {
+		s := Sprintf(tt.fmt, tt.in)
+		if s != tt.out {
+			t.Errorf("%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
+		}
+	}
+}
+
+// recurCount tests that erroneous String routine doesn't cause fatal recursion.
+var recurCount = 0
+
+type Recur struct {
+	i      int
+	failed *bool
+}
+
+func (r *Recur) String() string {
+	if recurCount++; recurCount > 10 {
+		*r.failed = true
+		return "FAIL"
+	}
+	// This will call badVerb. Before the fix, that would cause us to recur into
+	// this routine to print %!p(value). Now we don't call the user's method
+	// during an error.
+	return Sprintf("recur@%p value: %d", r, r.i)
+}
+
+func TestBadVerbRecursion(t *testing.T) {
+	failed := false
+	r := &Recur{3, &failed}
+	Sprintf("recur@%p value: %d\n", &r, r.i)
+	if failed {
+		t.Error("fail with pointer")
+	}
+	failed = false
+	r = &Recur{4, &failed}
+	Sprintf("recur@%p, value: %d\n", r, r.i)
+	if failed {
+		t.Error("fail with value")
+	}
+}
+
+func TestIsSpace(t *testing.T) {
+	// This tests the internal isSpace function.
+	// IsSpace = isSpace is defined in export_test.go.
+	for i := rune(0); i <= unicode.MaxRune; i++ {
+		if IsSpace(i) != unicode.IsSpace(i) {
+			t.Errorf("isSpace(%U) = %v, want %v", i, IsSpace(i), unicode.IsSpace(i))
+		}
+	}
+}
+
+func TestNilDoesNotBecomeTyped(t *testing.T) {
+	type A struct{}
+	type B struct{}
+	var a *A = nil
+	var b B = B{}
+	got := Sprintf("%s %s %s %s %s", nil, a, nil, b, nil) // go vet should complain about this line.
+	const expect = "%!s(<nil>) %!s(*fmt_test.A=<nil>) %!s(<nil>) {} %!s(<nil>)"
+	if got != expect {
+		t.Errorf("expected:\n\t%q\ngot:\n\t%q", expect, got)
+	}
+}
+
+var formatterFlagTests = []struct {
+	in  string
+	val interface{}
+	out string
+}{
+	// scalar values with the (unused by fmt) 'a' verb.
+	{"%a", flagPrinter{}, "[%a]"},
+	{"%-a", flagPrinter{}, "[%-a]"},
+	{"%+a", flagPrinter{}, "[%+a]"},
+	{"%#a", flagPrinter{}, "[%#a]"},
+	{"% a", flagPrinter{}, "[% a]"},
+	{"%0a", flagPrinter{}, "[%0a]"},
+	{"%1.2a", flagPrinter{}, "[%1.2a]"},
+	{"%-1.2a", flagPrinter{}, "[%-1.2a]"},
+	{"%+1.2a", flagPrinter{}, "[%+1.2a]"},
+	{"%-+1.2a", flagPrinter{}, "[%+-1.2a]"},
+	{"%-+1.2abc", flagPrinter{}, "[%+-1.2a]bc"},
+	{"%-1.2abc", flagPrinter{}, "[%-1.2a]bc"},
+
+	// composite values with the 'a' verb
+	{"%a", [1]flagPrinter{}, "[[%a]]"},
+	{"%-a", [1]flagPrinter{}, "[[%-a]]"},
+	{"%+a", [1]flagPrinter{}, "[[%+a]]"},
+	{"%#a", [1]flagPrinter{}, "[[%#a]]"},
+	{"% a", [1]flagPrinter{}, "[[% a]]"},
+	{"%0a", [1]flagPrinter{}, "[[%0a]]"},
+	{"%1.2a", [1]flagPrinter{}, "[[%1.2a]]"},
+	{"%-1.2a", [1]flagPrinter{}, "[[%-1.2a]]"},
+	{"%+1.2a", [1]flagPrinter{}, "[[%+1.2a]]"},
+	{"%-+1.2a", [1]flagPrinter{}, "[[%+-1.2a]]"},
+	{"%-+1.2abc", [1]flagPrinter{}, "[[%+-1.2a]]bc"},
+	{"%-1.2abc", [1]flagPrinter{}, "[[%-1.2a]]bc"},
+
+	// simple values with the 'v' verb
+	{"%v", flagPrinter{}, "[%v]"},
+	{"%-v", flagPrinter{}, "[%-v]"},
+	{"%+v", flagPrinter{}, "[%+v]"},
+	{"%#v", flagPrinter{}, "[%#v]"},
+	{"% v", flagPrinter{}, "[% v]"},
+	{"%0v", flagPrinter{}, "[%0v]"},
+	{"%1.2v", flagPrinter{}, "[%1.2v]"},
+	{"%-1.2v", flagPrinter{}, "[%-1.2v]"},
+	{"%+1.2v", flagPrinter{}, "[%+1.2v]"},
+	{"%-+1.2v", flagPrinter{}, "[%+-1.2v]"},
+	{"%-+1.2vbc", flagPrinter{}, "[%+-1.2v]bc"},
+	{"%-1.2vbc", flagPrinter{}, "[%-1.2v]bc"},
+
+	// composite values with the 'v' verb.
+	{"%v", [1]flagPrinter{}, "[[%v]]"},
+	{"%-v", [1]flagPrinter{}, "[[%-v]]"},
+	{"%+v", [1]flagPrinter{}, "[[%+v]]"},
+	{"%#v", [1]flagPrinter{}, "[1]fmt_test.flagPrinter{[%#v]}"},
+	{"% v", [1]flagPrinter{}, "[[% v]]"},
+	{"%0v", [1]flagPrinter{}, "[[%0v]]"},
+	{"%1.2v", [1]flagPrinter{}, "[[%1.2v]]"},
+	{"%-1.2v", [1]flagPrinter{}, "[[%-1.2v]]"},
+	{"%+1.2v", [1]flagPrinter{}, "[[%+1.2v]]"},
+	{"%-+1.2v", [1]flagPrinter{}, "[[%+-1.2v]]"},
+	{"%-+1.2vbc", [1]flagPrinter{}, "[[%+-1.2v]]bc"},
+	{"%-1.2vbc", [1]flagPrinter{}, "[[%-1.2v]]bc"},
+}
+
+func TestFormatterFlags(t *testing.T) {
+	for _, tt := range formatterFlagTests {
+		s := Sprintf(tt.in, tt.val)
+		if s != tt.out {
+			t.Errorf("Sprintf(%q, %T) = %q, want %q", tt.in, tt.val, s, tt.out)
+		}
+	}
+}
+
+func TestParsenum(t *testing.T) {
+	testCases := []struct {
+		s          string
+		start, end int
+		num        int
+		isnum      bool
+		newi       int
+	}{
+		{"a123", 0, 4, 0, false, 0},
+		{"1234", 1, 1, 0, false, 1},
+		{"123a", 0, 4, 123, true, 3},
+		{"12a3", 0, 4, 12, true, 2},
+		{"1234", 0, 4, 1234, true, 4},
+		{"1a234", 1, 3, 0, false, 1},
+	}
+	for _, tt := range testCases {
+		num, isnum, newi := Parsenum(tt.s, tt.start, tt.end)
+		if num != tt.num || isnum != tt.isnum || newi != tt.newi {
+			t.Errorf("parsenum(%q, %d, %d) = %d, %v, %d, want %d, %v, %d", tt.s, tt.start, tt.end, num, isnum, newi, tt.num, tt.isnum, tt.newi)
+		}
+	}
+}
diff --git a/message/format.go b/message/format.go
new file mode 100644
index 0000000..f80082b
--- /dev/null
+++ b/message/format.go
@@ -0,0 +1,539 @@
+// +build ignore
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"strconv"
+	"unicode/utf8"
+)
+
+const (
+	ldigits = "0123456789abcdefx"
+	udigits = "0123456789ABCDEFX"
+)
+
+const (
+	signed   = true
+	unsigned = false
+)
+
+// flags placed in a separate struct for easy clearing.
+type fmtFlags struct {
+	widPresent  bool
+	precPresent bool
+	minus       bool
+	plus        bool
+	sharp       bool
+	space       bool
+	zero        bool
+
+	// For the formats %+v %#v, we set the plusV/sharpV flags
+	// and clear the plus/sharp flags since %+v and %#v are in effect
+	// different, flagless formats set at the top level.
+	plusV  bool
+	sharpV bool
+}
+
+// A fmt is the raw formatter used by Printf etc.
+// It prints into a buffer that must be set up separately.
+type fmt struct {
+	buf *buffer
+
+	fmtFlags
+
+	wid  int // width
+	prec int // precision
+
+	// intbuf is large enough to store %b of an int64 with a sign and
+	// avoids padding at the end of the struct on 32 bit architectures.
+	intbuf [68]byte
+}
+
+func (f *fmt) clearflags() {
+	f.fmtFlags = fmtFlags{}
+}
+
+func (f *fmt) init(buf *buffer) {
+	f.buf = buf
+	f.clearflags()
+}
+
+// writePadding generates n bytes of padding.
+func (f *fmt) writePadding(n int) {
+	if n <= 0 { // No padding bytes needed.
+		return
+	}
+	buf := *f.buf
+	oldLen := len(buf)
+	newLen := oldLen + n
+	// Make enough room for padding.
+	if newLen > cap(buf) {
+		buf = make(buffer, cap(buf)*2+n)
+		copy(buf, *f.buf)
+	}
+	// Decide which byte the padding should be filled with.
+	padByte := byte(' ')
+	if f.zero {
+		padByte = byte('0')
+	}
+	// Fill padding with padByte.
+	padding := buf[oldLen:newLen]
+	for i := range padding {
+		padding[i] = padByte
+	}
+	*f.buf = buf[:newLen]
+}
+
+// pad appends b to f.buf, padded on left (!f.minus) or right (f.minus).
+func (f *fmt) pad(b []byte) {
+	if !f.widPresent || f.wid == 0 {
+		f.buf.Write(b)
+		return
+	}
+	width := f.wid - utf8.RuneCount(b)
+	if !f.minus {
+		// left padding
+		f.writePadding(width)
+		f.buf.Write(b)
+	} else {
+		// right padding
+		f.buf.Write(b)
+		f.writePadding(width)
+	}
+}
+
+// padString appends s to f.buf, padded on left (!f.minus) or right (f.minus).
+func (f *fmt) padString(s string) {
+	if !f.widPresent || f.wid == 0 {
+		f.buf.WriteString(s)
+		return
+	}
+	width := f.wid - utf8.RuneCountInString(s)
+	if !f.minus {
+		// left padding
+		f.writePadding(width)
+		f.buf.WriteString(s)
+	} else {
+		// right padding
+		f.buf.WriteString(s)
+		f.writePadding(width)
+	}
+}
+
+// fmt_boolean formats a boolean.
+func (f *fmt) fmt_boolean(v bool) {
+	if v {
+		f.padString("true")
+	} else {
+		f.padString("false")
+	}
+}
+
+// fmt_unicode formats a uint64 as "U+0078" or with f.sharp set as "U+0078 'x'".
+func (f *fmt) fmt_unicode(u uint64) {
+	buf := f.intbuf[0:]
+
+	// With default precision set the maximum needed buf length is 18
+	// for formatting -1 with %#U ("U+FFFFFFFFFFFFFFFF") which fits
+	// into the already allocated intbuf with a capacity of 68 bytes.
+	prec := 4
+	if f.precPresent && f.prec > 4 {
+		prec = f.prec
+		// Compute space needed for "U+" , number, " '", character, "'".
+		width := 2 + prec + 2 + utf8.UTFMax + 1
+		if width > len(buf) {
+			buf = make([]byte, width)
+		}
+	}
+
+	// Format into buf, ending at buf[i]. Formatting numbers is easier right-to-left.
+	i := len(buf)
+
+	// For %#U we want to add a space and a quoted character at the end of the buffer.
+	if f.sharp && u <= utf8.MaxRune && strconv.IsPrint(rune(u)) {
+		i--
+		buf[i] = '\''
+		i -= utf8.RuneLen(rune(u))
+		utf8.EncodeRune(buf[i:], rune(u))
+		i--
+		buf[i] = '\''
+		i--
+		buf[i] = ' '
+	}
+	// Format the Unicode code point u as a hexadecimal number.
+	for u >= 16 {
+		i--
+		buf[i] = udigits[u&0xF]
+		prec--
+		u >>= 4
+	}
+	i--
+	buf[i] = udigits[u]
+	prec--
+	// Add zeros in front of the number until requested precision is reached.
+	for prec > 0 {
+		i--
+		buf[i] = '0'
+		prec--
+	}
+	// Add a leading "U+".
+	i--
+	buf[i] = '+'
+	i--
+	buf[i] = 'U'
+
+	oldZero := f.zero
+	f.zero = false
+	f.pad(buf[i:])
+	f.zero = oldZero
+}
+
+// fmt_integer formats signed and unsigned integers.
+func (f *fmt) fmt_integer(u uint64, base int, isSigned bool, digits string) {
+	negative := isSigned && int64(u) < 0
+	if negative {
+		u = -u
+	}
+
+	buf := f.intbuf[0:]
+	// The already allocated f.intbuf with a capacity of 68 bytes
+	// is large enough for integer formatting when no precision or width is set.
+	if f.widPresent || f.precPresent {
+		// Account 3 extra bytes for possible addition of a sign and "0x".
+		width := 3 + f.wid + f.prec // wid and prec are always positive.
+		if width > len(buf) {
+			// We're going to need a bigger boat.
+			buf = make([]byte, width)
+		}
+	}
+
+	// Two ways to ask for extra leading zero digits: %.3d or %03d.
+	// If both are specified the f.zero flag is ignored and
+	// padding with spaces is used instead.
+	prec := 0
+	if f.precPresent {
+		prec = f.prec
+		// Precision of 0 and value of 0 means "print nothing" but padding.
+		if prec == 0 && u == 0 {
+			oldZero := f.zero
+			f.zero = false
+			f.writePadding(f.wid)
+			f.zero = oldZero
+			return
+		}
+	} else if f.zero && f.widPresent {
+		prec = f.wid
+		if negative || f.plus || f.space {
+			prec-- // leave room for sign
+		}
+	}
+
+	// Because printing is easier right-to-left: format u into buf, ending at buf[i].
+	// We could make things marginally faster by splitting the 32-bit case out
+	// into a separate block but it's not worth the duplication, so u has 64 bits.
+	i := len(buf)
+	// Use constants for the division and modulo for more efficient code.
+	// Switch cases ordered by popularity.
+	switch base {
+	case 10:
+		for u >= 10 {
+			i--
+			next := u / 10
+			buf[i] = byte('0' + u - next*10)
+			u = next
+		}
+	case 16:
+		for u >= 16 {
+			i--
+			buf[i] = digits[u&0xF]
+			u >>= 4
+		}
+	case 8:
+		for u >= 8 {
+			i--
+			buf[i] = byte('0' + u&7)
+			u >>= 3
+		}
+	case 2:
+		for u >= 2 {
+			i--
+			buf[i] = byte('0' + u&1)
+			u >>= 1
+		}
+	default:
+		panic("fmt: unknown base; can't happen")
+	}
+	i--
+	buf[i] = digits[u]
+	for i > 0 && prec > len(buf)-i {
+		i--
+		buf[i] = '0'
+	}
+
+	// Various prefixes: 0x, -, etc.
+	if f.sharp {
+		switch base {
+		case 8:
+			if buf[i] != '0' {
+				i--
+				buf[i] = '0'
+			}
+		case 16:
+			// Add a leading 0x or 0X.
+			i--
+			buf[i] = digits[16]
+			i--
+			buf[i] = '0'
+		}
+	}
+
+	if negative {
+		i--
+		buf[i] = '-'
+	} else if f.plus {
+		i--
+		buf[i] = '+'
+	} else if f.space {
+		i--
+		buf[i] = ' '
+	}
+
+	// Left padding with zeros has already been handled like precision earlier
+	// or the f.zero flag is ignored due to an explicitly set precision.
+	oldZero := f.zero
+	f.zero = false
+	f.pad(buf[i:])
+	f.zero = oldZero
+}
+
+// truncate truncates the string to the specified precision, if present.
+func (f *fmt) truncate(s string) string {
+	if f.precPresent {
+		n := f.prec
+		for i := range s {
+			n--
+			if n < 0 {
+				return s[:i]
+			}
+		}
+	}
+	return s
+}
+
+// fmt_s formats a string.
+func (f *fmt) fmt_s(s string) {
+	s = f.truncate(s)
+	f.padString(s)
+}
+
+// fmt_sbx formats a string or byte slice as a hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sbx(s string, b []byte, digits string) {
+	length := len(b)
+	if b == nil {
+		// No byte slice present. Assume string s should be encoded.
+		length = len(s)
+	}
+	// Set length to not process more bytes than the precision demands.
+	if f.precPresent && f.prec < length {
+		length = f.prec
+	}
+	// Compute width of the encoding taking into account the f.sharp and f.space flag.
+	width := 2 * length
+	if width > 0 {
+		if f.space {
+			// Each element encoded by two hexadecimals will get a leading 0x or 0X.
+			if f.sharp {
+				width *= 2
+			}
+			// Elements will be separated by a space.
+			width += length - 1
+		} else if f.sharp {
+			// Only a leading 0x or 0X will be added for the whole string.
+			width += 2
+		}
+	} else { // The byte slice or string that should be encoded is empty.
+		if f.widPresent {
+			f.writePadding(f.wid)
+		}
+		return
+	}
+	// Handle padding to the left.
+	if f.widPresent && f.wid > width && !f.minus {
+		f.writePadding(f.wid - width)
+	}
+	// Write the encoding directly into the output buffer.
+	buf := *f.buf
+	if f.sharp {
+		// Add leading 0x or 0X.
+		buf = append(buf, '0', digits[16])
+	}
+	var c byte
+	for i := 0; i < length; i++ {
+		if f.space && i > 0 {
+			// Separate elements with a space.
+			buf = append(buf, ' ')
+			if f.sharp {
+				// Add leading 0x or 0X for each element.
+				buf = append(buf, '0', digits[16])
+			}
+		}
+		if b != nil {
+			c = b[i] // Take a byte from the input byte slice.
+		} else {
+			c = s[i] // Take a byte from the input string.
+		}
+		// Encode each byte as two hexadecimal digits.
+		buf = append(buf, digits[c>>4], digits[c&0xF])
+	}
+	*f.buf = buf
+	// Handle padding to the right.
+	if f.widPresent && f.wid > width && f.minus {
+		f.writePadding(f.wid - width)
+	}
+}
+
+// fmt_sx formats a string as a hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sx(s, digits string) {
+	f.fmt_sbx(s, nil, digits)
+}
+
+// fmt_bx formats a byte slice as a hexadecimal encoding of its bytes.
+func (f *fmt) fmt_bx(b []byte, digits string) {
+	f.fmt_sbx("", b, digits)
+}
+
+// fmt_q formats a string as a double-quoted, escaped Go string constant.
+// If f.sharp is set a raw (backquoted) string may be returned instead
+// if the string does not contain any control characters other than tab.
+func (f *fmt) fmt_q(s string) {
+	s = f.truncate(s)
+	if f.sharp && strconv.CanBackquote(s) {
+		f.padString("`" + s + "`")
+		return
+	}
+	buf := f.intbuf[:0]
+	if f.plus {
+		f.pad(strconv.AppendQuoteToASCII(buf, s))
+	} else {
+		f.pad(strconv.AppendQuote(buf, s))
+	}
+}
+
+// fmt_c formats an integer as a Unicode character.
+// If the character is not valid Unicode, it will print '\ufffd'.
+func (f *fmt) fmt_c(c uint64) {
+	r := rune(c)
+	if c > utf8.MaxRune {
+		r = utf8.RuneError
+	}
+	buf := f.intbuf[:0]
+	w := utf8.EncodeRune(buf[:utf8.UTFMax], r)
+	f.pad(buf[:w])
+}
+
+// fmt_qc formats an integer as a single-quoted, escaped Go character constant.
+// If the character is not valid Unicode, it will print '\ufffd'.
+func (f *fmt) fmt_qc(c uint64) {
+	r := rune(c)
+	if c > utf8.MaxRune {
+		r = utf8.RuneError
+	}
+	buf := f.intbuf[:0]
+	if f.plus {
+		f.pad(strconv.AppendQuoteRuneToASCII(buf, r))
+	} else {
+		f.pad(strconv.AppendQuoteRune(buf, r))
+	}
+}
+
+// fmt_float formats a float64. It assumes that verb is a valid format specifier
+// for strconv.AppendFloat and therefore fits into a byte.
+func (f *fmt) fmt_float(v float64, size int, verb rune, prec int) {
+	// Explicit precision in format specifier overrules default precision.
+	if f.precPresent {
+		prec = f.prec
+	}
+	// Format number, reserving space for leading + sign if needed.
+	num := strconv.AppendFloat(f.intbuf[:1], v, byte(verb), prec, size)
+	if num[1] == '-' || num[1] == '+' {
+		num = num[1:]
+	} else {
+		num[0] = '+'
+	}
+	// f.space means to add a leading space instead of a "+" sign unless
+	// the sign is explicitly asked for by f.plus.
+	if f.space && num[0] == '+' && !f.plus {
+		num[0] = ' '
+	}
+	// Special handling for infinities and NaN,
+	// which don't look like a number so shouldn't be padded with zeros.
+	if num[1] == 'I' || num[1] == 'N' {
+		oldZero := f.zero
+		f.zero = false
+		// Remove sign before NaN if not asked for.
+		if num[1] == 'N' && !f.space && !f.plus {
+			num = num[1:]
+		}
+		f.pad(num)
+		f.zero = oldZero
+		return
+	}
+	// The sharp flag forces printing a decimal point for non-binary formats
+	// and retains trailing zeros, which we may need to restore.
+	if f.sharp && verb != 'b' {
+		digits := 0
+		switch verb {
+		case 'v', 'g', 'G':
+			digits = prec
+			// If no precision is set explicitly use a precision of 6.
+			if digits == -1 {
+				digits = 6
+			}
+		}
+
+		// Buffer pre-allocated with enough room for
+		// exponent notations of the form "e+123".
+		var tailBuf [5]byte
+		tail := tailBuf[:0]
+
+		hasDecimalPoint := false
+		// Starting from i = 1 to skip sign at num[0].
+		for i := 1; i < len(num); i++ {
+			switch num[i] {
+			case '.':
+				hasDecimalPoint = true
+			case 'e', 'E':
+				tail = append(tail, num[i:]...)
+				num = num[:i]
+			default:
+				digits--
+			}
+		}
+		if !hasDecimalPoint {
+			num = append(num, '.')
+		}
+		for digits > 0 {
+			num = append(num, '0')
+			digits--
+		}
+		num = append(num, tail...)
+	}
+	// We want a sign if asked for and if the sign is not positive.
+	if f.plus || num[0] != '+' {
+		// If we're zero padding to the left we want the sign before the leading zeros.
+		// Achieve this by writing the sign out and then padding the unsigned number.
+		if f.zero && f.widPresent && f.wid > len(num) {
+			f.buf.WriteByte(num[0])
+			f.writePadding(f.wid - len(num))
+			f.buf.Write(num[1:])
+			return
+		}
+		f.pad(num)
+		return
+	}
+	// No sign to show and the number is positive; just print the unsigned number.
+	f.pad(num[1:])
+}
diff --git a/message/print.go b/message/print.go
new file mode 100644
index 0000000..305b7e5
--- /dev/null
+++ b/message/print.go
@@ -0,0 +1,1140 @@
+// +build ignore
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"errors"
+	"io"
+	"os"
+	"reflect"
+	"sync"
+	"unicode/utf8"
+)
+
+// Strings for use with buffer.WriteString.
+// This is less overhead than using buffer.Write with byte arrays.
+const (
+	commaSpaceString  = ", "
+	nilAngleString    = "<nil>"
+	nilParenString    = "(nil)"
+	nilString         = "nil"
+	mapString         = "map["
+	percentBangString = "%!"
+	missingString     = "(MISSING)"
+	badIndexString    = "(BADINDEX)"
+	panicString       = "(PANIC="
+	extraString       = "%!(EXTRA "
+	badWidthString    = "%!(BADWIDTH)"
+	badPrecString     = "%!(BADPREC)"
+	noVerbString      = "%!(NOVERB)"
+	invReflectString  = "<invalid reflect.Value>"
+)
+
+// State represents the printer state passed to custom formatters.
+// It provides access to the io.Writer interface plus information about
+// the flags and options for the operand's format specifier.
+type State interface {
+	// Write is the function to call to emit formatted output to be printed.
+	Write(b []byte) (n int, err error)
+	// Width returns the value of the width option and whether it has been set.
+	Width() (wid int, ok bool)
+	// Precision returns the value of the precision option and whether it has been set.
+	Precision() (prec int, ok bool)
+
+	// Flag reports whether the flag c, a character, has been set.
+	Flag(c int) bool
+}
+
+// Formatter is the interface implemented by values with a custom formatter.
+// The implementation of Format may call Sprint(f) or Fprint(f) etc.
+// to generate its output.
+type Formatter interface {
+	Format(f State, c rune)
+}
+
+// Stringer is implemented by any value that has a String method,
+// which defines the ``native'' format for that value.
+// The String method is used to print values passed as an operand
+// to any format that accepts a string or to an unformatted printer
+// such as Print.
+type Stringer interface {
+	String() string
+}
+
+// GoStringer is implemented by any value that has a GoString method,
+// which defines the Go syntax for that value.
+// The GoString method is used to print values passed as an operand
+// to a %#v format.
+type GoStringer interface {
+	GoString() string
+}
+
+// Use simple []byte instead of bytes.Buffer to avoid large dependency.
+type buffer []byte
+
+func (b *buffer) Write(p []byte) {
+	*b = append(*b, p...)
+}
+
+func (b *buffer) WriteString(s string) {
+	*b = append(*b, s...)
+}
+
+func (b *buffer) WriteByte(c byte) {
+	*b = append(*b, c)
+}
+
+func (bp *buffer) WriteRune(r rune) {
+	if r < utf8.RuneSelf {
+		*bp = append(*bp, byte(r))
+		return
+	}
+
+	b := *bp
+	n := len(b)
+	for n+utf8.UTFMax > cap(b) {
+		b = append(b, 0)
+	}
+	w := utf8.EncodeRune(b[n:n+utf8.UTFMax], r)
+	*bp = b[:n+w]
+}
+
+// pp is used to store a printer's state and is reused with sync.Pool to avoid allocations.
+type pp struct {
+	buf buffer
+
+	// arg holds the current item, as an interface{}.
+	arg interface{}
+
+	// value is used instead of arg for reflect values.
+	value reflect.Value
+
+	// fmt is used to format basic items such as integers or strings.
+	fmt fmt
+
+	// reordered records whether the format string used argument reordering.
+	reordered bool
+	// goodArgNum records whether the most recent reordering directive was valid.
+	goodArgNum bool
+	// panicking is set by catchPanic to avoid infinite panic, recover, panic, ... recursion.
+	panicking bool
+	// erroring is set when printing an error string to guard against calling handleMethods.
+	erroring bool
+}
+
+var ppFree = sync.Pool{
+	New: func() interface{} { return new(pp) },
+}
+
+// newPrinter allocates a new pp struct or grabs a cached one.
+func newPrinter() *pp {
+	p := ppFree.Get().(*pp)
+	p.panicking = false
+	p.erroring = false
+	p.fmt.init(&p.buf)
+	return p
+}
+
+// free saves used pp structs in ppFree; avoids an allocation per invocation.
+func (p *pp) free() {
+	p.buf = p.buf[:0]
+	p.arg = nil
+	p.value = reflect.Value{}
+	ppFree.Put(p)
+}
+
+func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
+
+func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
+
+func (p *pp) Flag(b int) bool {
+	switch b {
+	case '-':
+		return p.fmt.minus
+	case '+':
+		return p.fmt.plus || p.fmt.plusV
+	case '#':
+		return p.fmt.sharp || p.fmt.sharpV
+	case ' ':
+		return p.fmt.space
+	case '0':
+		return p.fmt.zero
+	}
+	return false
+}
+
+// Implement Write so we can call Fprintf on a pp (through State), for
+// recursive use in custom verbs.
+func (p *pp) Write(b []byte) (ret int, err error) {
+	p.buf.Write(b)
+	return len(b), nil
+}
+
+// These routines end in 'f' and take a format string.
+
+// Fprintf formats according to a format specifier and writes to w.
+// It returns the number of bytes written and any write error encountered.
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	p := newPrinter()
+	p.doPrintf(format, a)
+	n, err = w.Write(p.buf)
+	p.free()
+	return
+}
+
+// Printf formats according to a format specifier and writes to standard output.
+// It returns the number of bytes written and any write error encountered.
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return Fprintf(os.Stdout, format, a...)
+}
+
+// Sprintf formats according to a format specifier and returns the resulting string.
+func Sprintf(format string, a ...interface{}) string {
+	p := newPrinter()
+	p.doPrintf(format, a)
+	s := string(p.buf)
+	p.free()
+	return s
+}
+
+// Errorf formats according to a format specifier and returns the string
+// as a value that satisfies error.
+func Errorf(format string, a ...interface{}) error {
+	return errors.New(Sprintf(format, a...))
+}
+
+// These routines do not take a format string
+
+// Fprint formats using the default formats for its operands and writes to w.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	p := newPrinter()
+	p.doPrint(a)
+	n, err = w.Write(p.buf)
+	p.free()
+	return
+}
+
+// Print formats using the default formats for its operands and writes to standard output.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+func Print(a ...interface{}) (n int, err error) {
+	return Fprint(os.Stdout, a...)
+}
+
+// Sprint formats using the default formats for its operands and returns the resulting string.
+// Spaces are added between operands when neither is a string.
+func Sprint(a ...interface{}) string {
+	p := newPrinter()
+	p.doPrint(a)
+	s := string(p.buf)
+	p.free()
+	return s
+}
+
+// These routines end in 'ln', do not take a format string,
+// always add spaces between operands, and add a newline
+// after the last operand.
+
+// Fprintln formats using the default formats for its operands and writes to w.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	p := newPrinter()
+	p.doPrintln(a)
+	n, err = w.Write(p.buf)
+	p.free()
+	return
+}
+
+// Println formats using the default formats for its operands and writes to standard output.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func Println(a ...interface{}) (n int, err error) {
+	return Fprintln(os.Stdout, a...)
+}
+
+// Sprintln formats using the default formats for its operands and returns the resulting string.
+// Spaces are always added between operands and a newline is appended.
+func Sprintln(a ...interface{}) string {
+	p := newPrinter()
+	p.doPrintln(a)
+	s := string(p.buf)
+	p.free()
+	return s
+}
+
+// getField gets the i'th field of the struct value.
+// If the field is itself is an interface, return a value for
+// the thing inside the interface, not the interface itself.
+func getField(v reflect.Value, i int) reflect.Value {
+	val := v.Field(i)
+	if val.Kind() == reflect.Interface && !val.IsNil() {
+		val = val.Elem()
+	}
+	return val
+}
+
+// tooLarge reports whether the magnitude of the integer is
+// too large to be used as a formatting width or precision.
+func tooLarge(x int) bool {
+	const max int = 1e6
+	return x > max || x < -max
+}
+
+// parsenum converts ASCII to integer.  num is 0 (and isnum is false) if no number present.
+func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
+	if start >= end {
+		return 0, false, end
+	}
+	for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
+		if tooLarge(num) {
+			return 0, false, end // Overflow; crazy long number most likely.
+		}
+		num = num*10 + int(s[newi]-'0')
+		isnum = true
+	}
+	return
+}
+
+func (p *pp) unknownType(v reflect.Value) {
+	if !v.IsValid() {
+		p.buf.WriteString(nilAngleString)
+		return
+	}
+	p.buf.WriteByte('?')
+	p.buf.WriteString(v.Type().String())
+	p.buf.WriteByte('?')
+}
+
+func (p *pp) badVerb(verb rune) {
+	p.erroring = true
+	p.buf.WriteString(percentBangString)
+	p.buf.WriteRune(verb)
+	p.buf.WriteByte('(')
+	switch {
+	case p.arg != nil:
+		p.buf.WriteString(reflect.TypeOf(p.arg).String())
+		p.buf.WriteByte('=')
+		p.printArg(p.arg, 'v')
+	case p.value.IsValid():
+		p.buf.WriteString(p.value.Type().String())
+		p.buf.WriteByte('=')
+		p.printValue(p.value, 'v', 0)
+	default:
+		p.buf.WriteString(nilAngleString)
+	}
+	p.buf.WriteByte(')')
+	p.erroring = false
+}
+
+func (p *pp) fmtBool(v bool, verb rune) {
+	switch verb {
+	case 't', 'v':
+		p.fmt.fmt_boolean(v)
+	default:
+		p.badVerb(verb)
+	}
+}
+
+// fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or
+// not, as requested, by temporarily setting the sharp flag.
+func (p *pp) fmt0x64(v uint64, leading0x bool) {
+	sharp := p.fmt.sharp
+	p.fmt.sharp = leading0x
+	p.fmt.fmt_integer(v, 16, unsigned, ldigits)
+	p.fmt.sharp = sharp
+}
+
+// fmtInteger formats a signed or unsigned integer.
+func (p *pp) fmtInteger(v uint64, isSigned bool, verb rune) {
+	switch verb {
+	case 'v':
+		if p.fmt.sharpV && !isSigned {
+			p.fmt0x64(v, true)
+		} else {
+			p.fmt.fmt_integer(v, 10, isSigned, ldigits)
+		}
+	case 'd':
+		p.fmt.fmt_integer(v, 10, isSigned, ldigits)
+	case 'b':
+		p.fmt.fmt_integer(v, 2, isSigned, ldigits)
+	case 'o':
+		p.fmt.fmt_integer(v, 8, isSigned, ldigits)
+	case 'x':
+		p.fmt.fmt_integer(v, 16, isSigned, ldigits)
+	case 'X':
+		p.fmt.fmt_integer(v, 16, isSigned, udigits)
+	case 'c':
+		p.fmt.fmt_c(v)
+	case 'q':
+		if v <= utf8.MaxRune {
+			p.fmt.fmt_qc(v)
+		} else {
+			p.badVerb(verb)
+		}
+	case 'U':
+		p.fmt.fmt_unicode(v)
+	default:
+		p.badVerb(verb)
+	}
+}
+
+// fmtFloat formats a float. The default precision for each verb
+// is specified as last argument in the call to fmt_float.
+func (p *pp) fmtFloat(v float64, size int, verb rune) {
+	switch verb {
+	case 'v':
+		p.fmt.fmt_float(v, size, 'g', -1)
+	case 'b', 'g', 'G':
+		p.fmt.fmt_float(v, size, verb, -1)
+	case 'f', 'e', 'E':
+		p.fmt.fmt_float(v, size, verb, 6)
+	case 'F':
+		p.fmt.fmt_float(v, size, 'f', 6)
+	default:
+		p.badVerb(verb)
+	}
+}
+
+// fmtComplex formats a complex number v with
+// r = real(v) and j = imag(v) as (r+ji) using
+// fmtFloat for r and j formatting.
+func (p *pp) fmtComplex(v complex128, size int, verb rune) {
+	// Make sure any unsupported verbs are found before the
+	// calls to fmtFloat to not generate an incorrect error string.
+	switch verb {
+	case 'v', 'b', 'g', 'G', 'f', 'F', 'e', 'E':
+		oldPlus := p.fmt.plus
+		p.buf.WriteByte('(')
+		p.fmtFloat(real(v), size/2, verb)
+		// Imaginary part always has a sign.
+		p.fmt.plus = true
+		p.fmtFloat(imag(v), size/2, verb)
+		p.buf.WriteString("i)")
+		p.fmt.plus = oldPlus
+	default:
+		p.badVerb(verb)
+	}
+}
+
+func (p *pp) fmtString(v string, verb rune) {
+	switch verb {
+	case 'v':
+		if p.fmt.sharpV {
+			p.fmt.fmt_q(v)
+		} else {
+			p.fmt.fmt_s(v)
+		}
+	case 's':
+		p.fmt.fmt_s(v)
+	case 'x':
+		p.fmt.fmt_sx(v, ldigits)
+	case 'X':
+		p.fmt.fmt_sx(v, udigits)
+	case 'q':
+		p.fmt.fmt_q(v)
+	default:
+		p.badVerb(verb)
+	}
+}
+
+func (p *pp) fmtBytes(v []byte, verb rune, typeString string) {
+	switch verb {
+	case 'v', 'd':
+		if p.fmt.sharpV {
+			p.buf.WriteString(typeString)
+			if v == nil {
+				p.buf.WriteString(nilParenString)
+				return
+			}
+			p.buf.WriteByte('{')
+			for i, c := range v {
+				if i > 0 {
+					p.buf.WriteString(commaSpaceString)
+				}
+				p.fmt0x64(uint64(c), true)
+			}
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte('[')
+			for i, c := range v {
+				if i > 0 {
+					p.buf.WriteByte(' ')
+				}
+				p.fmt.fmt_integer(uint64(c), 10, unsigned, ldigits)
+			}
+			p.buf.WriteByte(']')
+		}
+	case 's':
+		p.fmt.fmt_s(string(v))
+	case 'x':
+		p.fmt.fmt_bx(v, ldigits)
+	case 'X':
+		p.fmt.fmt_bx(v, udigits)
+	case 'q':
+		p.fmt.fmt_q(string(v))
+	default:
+		p.printValue(reflect.ValueOf(v), verb, 0)
+	}
+}
+
+func (p *pp) fmtPointer(value reflect.Value, verb rune) {
+	var u uintptr
+	switch value.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+		u = value.Pointer()
+	default:
+		p.badVerb(verb)
+		return
+	}
+
+	switch verb {
+	case 'v':
+		if p.fmt.sharpV {
+			p.buf.WriteByte('(')
+			p.buf.WriteString(value.Type().String())
+			p.buf.WriteString(")(")
+			if u == 0 {
+				p.buf.WriteString(nilString)
+			} else {
+				p.fmt0x64(uint64(u), true)
+			}
+			p.buf.WriteByte(')')
+		} else {
+			if u == 0 {
+				p.fmt.padString(nilAngleString)
+			} else {
+				p.fmt0x64(uint64(u), !p.fmt.sharp)
+			}
+		}
+	case 'p':
+		p.fmt0x64(uint64(u), !p.fmt.sharp)
+	case 'b', 'o', 'd', 'x', 'X':
+		p.fmtInteger(uint64(u), unsigned, verb)
+	default:
+		p.badVerb(verb)
+	}
+}
+
+func (p *pp) catchPanic(arg interface{}, verb rune) {
+	if err := recover(); err != nil {
+		// If it's a nil pointer, just say "<nil>". The likeliest causes are a
+		// Stringer that fails to guard against nil or a nil pointer for a
+		// value receiver, and in either case, "<nil>" is a nice result.
+		if v := reflect.ValueOf(arg); v.Kind() == reflect.Ptr && v.IsNil() {
+			p.buf.WriteString(nilAngleString)
+			return
+		}
+		// Otherwise print a concise panic message. Most of the time the panic
+		// value will print itself nicely.
+		if p.panicking {
+			// Nested panics; the recursion in printArg cannot succeed.
+			panic(err)
+		}
+
+		oldFlags := p.fmt.fmtFlags
+		// For this output we want default behavior.
+		p.fmt.clearflags()
+
+		p.buf.WriteString(percentBangString)
+		p.buf.WriteRune(verb)
+		p.buf.WriteString(panicString)
+		p.panicking = true
+		p.printArg(err, 'v')
+		p.panicking = false
+		p.buf.WriteByte(')')
+
+		p.fmt.fmtFlags = oldFlags
+	}
+}
+
+func (p *pp) handleMethods(verb rune) (handled bool) {
+	if p.erroring {
+		return
+	}
+	// Is it a Formatter?
+	if formatter, ok := p.arg.(Formatter); ok {
+		handled = true
+		defer p.catchPanic(p.arg, verb)
+		formatter.Format(p, verb)
+		return
+	}
+
+	// If we're doing Go syntax and the argument knows how to supply it, take care of it now.
+	if p.fmt.sharpV {
+		if stringer, ok := p.arg.(GoStringer); ok {
+			handled = true
+			defer p.catchPanic(p.arg, verb)
+			// Print the result of GoString unadorned.
+			p.fmt.fmt_s(stringer.GoString())
+			return
+		}
+	} else {
+		// If a string is acceptable according to the format, see if
+		// the value satisfies one of the string-valued interfaces.
+		// Println etc. set verb to %v, which is "stringable".
+		switch verb {
+		case 'v', 's', 'x', 'X', 'q':
+			// Is it an error or Stringer?
+			// The duplication in the bodies is necessary:
+			// setting handled and deferring catchPanic
+			// must happen before calling the method.
+			switch v := p.arg.(type) {
+			case error:
+				handled = true
+				defer p.catchPanic(p.arg, verb)
+				p.fmtString(v.Error(), verb)
+				return
+
+			case Stringer:
+				handled = true
+				defer p.catchPanic(p.arg, verb)
+				p.fmtString(v.String(), verb)
+				return
+			}
+		}
+	}
+	return false
+}
+
+func (p *pp) printArg(arg interface{}, verb rune) {
+	p.arg = arg
+	p.value = reflect.Value{}
+
+	if arg == nil {
+		switch verb {
+		case 'T', 'v':
+			p.fmt.padString(nilAngleString)
+		default:
+			p.badVerb(verb)
+		}
+		return
+	}
+
+	// Special processing considerations.
+	// %T (the value's type) and %p (its address) are special; we always do them first.
+	switch verb {
+	case 'T':
+		p.fmt.fmt_s(reflect.TypeOf(arg).String())
+		return
+	case 'p':
+		p.fmtPointer(reflect.ValueOf(arg), 'p')
+		return
+	}
+
+	// Some types can be done without reflection.
+	switch f := arg.(type) {
+	case bool:
+		p.fmtBool(f, verb)
+	case float32:
+		p.fmtFloat(float64(f), 32, verb)
+	case float64:
+		p.fmtFloat(f, 64, verb)
+	case complex64:
+		p.fmtComplex(complex128(f), 64, verb)
+	case complex128:
+		p.fmtComplex(f, 128, verb)
+	case int:
+		p.fmtInteger(uint64(f), signed, verb)
+	case int8:
+		p.fmtInteger(uint64(f), signed, verb)
+	case int16:
+		p.fmtInteger(uint64(f), signed, verb)
+	case int32:
+		p.fmtInteger(uint64(f), signed, verb)
+	case int64:
+		p.fmtInteger(uint64(f), signed, verb)
+	case uint:
+		p.fmtInteger(uint64(f), unsigned, verb)
+	case uint8:
+		p.fmtInteger(uint64(f), unsigned, verb)
+	case uint16:
+		p.fmtInteger(uint64(f), unsigned, verb)
+	case uint32:
+		p.fmtInteger(uint64(f), unsigned, verb)
+	case uint64:
+		p.fmtInteger(f, unsigned, verb)
+	case uintptr:
+		p.fmtInteger(uint64(f), unsigned, verb)
+	case string:
+		p.fmtString(f, verb)
+	case []byte:
+		p.fmtBytes(f, verb, "[]byte")
+	case reflect.Value:
+		// Handle extractable values with special methods
+		// since printValue does not handle them at depth 0.
+		if f.IsValid() && f.CanInterface() {
+			p.arg = f.Interface()
+			if p.handleMethods(verb) {
+				return
+			}
+		}
+		p.printValue(f, verb, 0)
+	default:
+		// If the type is not simple, it might have methods.
+		if !p.handleMethods(verb) {
+			// Need to use reflection, since the type had no
+			// interface methods that could be used for formatting.
+			p.printValue(reflect.ValueOf(f), verb, 0)
+		}
+	}
+}
+
+// printValue is similar to printArg but starts with a reflect value, not an interface{} value.
+// It does not handle 'p' and 'T' verbs because these should have been already handled by printArg.
+func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
+	// Handle values with special methods if not already handled by printArg (depth == 0).
+	if depth > 0 && value.IsValid() && value.CanInterface() {
+		p.arg = value.Interface()
+		if p.handleMethods(verb) {
+			return
+		}
+	}
+	p.arg = nil
+	p.value = value
+
+	switch f := value; value.Kind() {
+	case reflect.Invalid:
+		if depth == 0 {
+			p.buf.WriteString(invReflectString)
+		} else {
+			switch verb {
+			case 'v':
+				p.buf.WriteString(nilAngleString)
+			default:
+				p.badVerb(verb)
+			}
+		}
+	case reflect.Bool:
+		p.fmtBool(f.Bool(), verb)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		p.fmtInteger(uint64(f.Int()), signed, verb)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		p.fmtInteger(f.Uint(), unsigned, verb)
+	case reflect.Float32:
+		p.fmtFloat(f.Float(), 32, verb)
+	case reflect.Float64:
+		p.fmtFloat(f.Float(), 64, verb)
+	case reflect.Complex64:
+		p.fmtComplex(f.Complex(), 64, verb)
+	case reflect.Complex128:
+		p.fmtComplex(f.Complex(), 128, verb)
+	case reflect.String:
+		p.fmtString(f.String(), verb)
+	case reflect.Map:
+		if p.fmt.sharpV {
+			p.buf.WriteString(f.Type().String())
+			if f.IsNil() {
+				p.buf.WriteString(nilParenString)
+				return
+			}
+			p.buf.WriteByte('{')
+		} else {
+			p.buf.WriteString(mapString)
+		}
+		keys := f.MapKeys()
+		for i, key := range keys {
+			if i > 0 {
+				if p.fmt.sharpV {
+					p.buf.WriteString(commaSpaceString)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			p.printValue(key, verb, depth+1)
+			p.buf.WriteByte(':')
+			p.printValue(f.MapIndex(key), verb, depth+1)
+		}
+		if p.fmt.sharpV {
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte(']')
+		}
+	case reflect.Struct:
+		if p.fmt.sharpV {
+			p.buf.WriteString(f.Type().String())
+		}
+		p.buf.WriteByte('{')
+		for i := 0; i < f.NumField(); i++ {
+			if i > 0 {
+				if p.fmt.sharpV {
+					p.buf.WriteString(commaSpaceString)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			if p.fmt.plusV || p.fmt.sharpV {
+				if name := f.Type().Field(i).Name; name != "" {
+					p.buf.WriteString(name)
+					p.buf.WriteByte(':')
+				}
+			}
+			p.printValue(getField(f, i), verb, depth+1)
+		}
+		p.buf.WriteByte('}')
+	case reflect.Interface:
+		value := f.Elem()
+		if !value.IsValid() {
+			if p.fmt.sharpV {
+				p.buf.WriteString(f.Type().String())
+				p.buf.WriteString(nilParenString)
+			} else {
+				p.buf.WriteString(nilAngleString)
+			}
+		} else {
+			p.printValue(value, verb, depth+1)
+		}
+	case reflect.Array, reflect.Slice:
+		switch verb {
+		case 's', 'q', 'x', 'X':
+			// Handle byte and uint8 slices and arrays special for the above verbs.
+			t := f.Type()
+			if t.Elem().Kind() == reflect.Uint8 {
+				var bytes []byte
+				if f.Kind() == reflect.Slice {
+					bytes = f.Bytes()
+				} else if f.CanAddr() {
+					bytes = f.Slice(0, f.Len()).Bytes()
+				} else {
+					// We have an array, but we cannot Slice() a non-addressable array,
+					// so we build a slice by hand. This is a rare case but it would be nice
+					// if reflection could help a little more.
+					bytes = make([]byte, f.Len())
+					for i := range bytes {
+						bytes[i] = byte(f.Index(i).Uint())
+					}
+				}
+				p.fmtBytes(bytes, verb, t.String())
+				return
+			}
+		}
+		if p.fmt.sharpV {
+			p.buf.WriteString(f.Type().String())
+			if f.Kind() == reflect.Slice && f.IsNil() {
+				p.buf.WriteString(nilParenString)
+				return
+			}
+			p.buf.WriteByte('{')
+			for i := 0; i < f.Len(); i++ {
+				if i > 0 {
+					p.buf.WriteString(commaSpaceString)
+				}
+				p.printValue(f.Index(i), verb, depth+1)
+			}
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte('[')
+			for i := 0; i < f.Len(); i++ {
+				if i > 0 {
+					p.buf.WriteByte(' ')
+				}
+				p.printValue(f.Index(i), verb, depth+1)
+			}
+			p.buf.WriteByte(']')
+		}
+	case reflect.Ptr:
+		// pointer to array or slice or struct?  ok at top level
+		// but not embedded (avoid loops)
+		if depth == 0 && f.Pointer() != 0 {
+			switch a := f.Elem(); a.Kind() {
+			case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
+				p.buf.WriteByte('&')
+				p.printValue(a, verb, depth+1)
+				return
+			}
+		}
+		fallthrough
+	case reflect.Chan, reflect.Func, reflect.UnsafePointer:
+		p.fmtPointer(f, verb)
+	default:
+		p.unknownType(f)
+	}
+}
+
+// intFromArg gets the argNumth element of a. On return, isInt reports whether the argument has integer type.
+func intFromArg(a []interface{}, argNum int) (num int, isInt bool, newArgNum int) {
+	newArgNum = argNum
+	if argNum < len(a) {
+		num, isInt = a[argNum].(int) // Almost always OK.
+		if !isInt {
+			// Work harder.
+			switch v := reflect.ValueOf(a[argNum]); v.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				n := v.Int()
+				if int64(int(n)) == n {
+					num = int(n)
+					isInt = true
+				}
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+				n := v.Uint()
+				if int64(n) >= 0 && uint64(int(n)) == n {
+					num = int(n)
+					isInt = true
+				}
+			default:
+				// Already 0, false.
+			}
+		}
+		newArgNum = argNum + 1
+		if tooLarge(num) {
+			num = 0
+			isInt = false
+		}
+	}
+	return
+}
+
+// parseArgNumber returns the value of the bracketed number, minus 1
+// (explicit argument numbers are one-indexed but we want zero-indexed).
+// The opening bracket is known to be present at format[0].
+// The returned values are the index, the number of bytes to consume
+// up to the closing paren, if present, and whether the number parsed
+// ok. The bytes to consume will be 1 if no closing paren is present.
+func parseArgNumber(format string) (index int, wid int, ok bool) {
+	// There must be at least 3 bytes: [n].
+	if len(format) < 3 {
+		return 0, 1, false
+	}
+
+	// Find closing bracket.
+	for i := 1; i < len(format); i++ {
+		if format[i] == ']' {
+			width, ok, newi := parsenum(format, 1, i)
+			if !ok || newi != i {
+				return 0, i + 1, false
+			}
+			return width - 1, i + 1, true // arg numbers are one-indexed and skip paren.
+		}
+	}
+	return 0, 1, false
+}
+
+// argNumber returns the next argument to evaluate, which is either the value of the passed-in
+// argNum or the value of the bracketed integer that begins format[i:]. It also returns
+// the new value of i, that is, the index of the next byte of the format to process.
+func (p *pp) argNumber(argNum int, format string, i int, numArgs int) (newArgNum, newi int, found bool) {
+	if len(format) <= i || format[i] != '[' {
+		return argNum, i, false
+	}
+	p.reordered = true
+	index, wid, ok := parseArgNumber(format[i:])
+	if ok && 0 <= index && index < numArgs {
+		return index, i + wid, true
+	}
+	p.goodArgNum = false
+	return argNum, i + wid, ok
+}
+
+func (p *pp) badArgNum(verb rune) {
+	p.buf.WriteString(percentBangString)
+	p.buf.WriteRune(verb)
+	p.buf.WriteString(badIndexString)
+}
+
+func (p *pp) missingArg(verb rune) {
+	p.buf.WriteString(percentBangString)
+	p.buf.WriteRune(verb)
+	p.buf.WriteString(missingString)
+}
+
+func (p *pp) doPrintf(format string, a []interface{}) {
+	end := len(format)
+	argNum := 0         // we process one argument per non-trivial format
+	afterIndex := false // previous item in format was an index like [3].
+	p.reordered = false
+formatLoop:
+	for i := 0; i < end; {
+		p.goodArgNum = true
+		lasti := i
+		for i < end && format[i] != '%' {
+			i++
+		}
+		if i > lasti {
+			p.buf.WriteString(format[lasti:i])
+		}
+		if i >= end {
+			// done processing format string
+			break
+		}
+
+		// Process one verb
+		i++
+
+		// Do we have flags?
+		p.fmt.clearflags()
+	simpleFormat:
+		for ; i < end; i++ {
+			c := format[i]
+			switch c {
+			case '#':
+				p.fmt.sharp = true
+			case '0':
+				p.fmt.zero = !p.fmt.minus // Only allow zero padding to the left.
+			case '+':
+				p.fmt.plus = true
+			case '-':
+				p.fmt.minus = true
+				p.fmt.zero = false // Do not pad with zeros to the right.
+			case ' ':
+				p.fmt.space = true
+			default:
+				// Fast path for common case of ascii lower case simple verbs
+				// without precision or width or argument indices.
+				if 'a' <= c && c <= 'z' && argNum < len(a) {
+					if c == 'v' {
+						// Go syntax
+						p.fmt.sharpV = p.fmt.sharp
+						p.fmt.sharp = false
+						// Struct-field syntax
+						p.fmt.plusV = p.fmt.plus
+						p.fmt.plus = false
+					}
+					p.printArg(a[argNum], rune(c))
+					argNum++
+					i++
+					continue formatLoop
+				}
+				// Format is more complex than simple flags and a verb or is malformed.
+				break simpleFormat
+			}
+		}
+
+		// Do we have an explicit argument index?
+		argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
+
+		// Do we have width?
+		if i < end && format[i] == '*' {
+			i++
+			p.fmt.wid, p.fmt.widPresent, argNum = intFromArg(a, argNum)
+
+			if !p.fmt.widPresent {
+				p.buf.WriteString(badWidthString)
+			}
+
+			// We have a negative width, so take its value and ensure
+			// that the minus flag is set
+			if p.fmt.wid < 0 {
+				p.fmt.wid = -p.fmt.wid
+				p.fmt.minus = true
+				p.fmt.zero = false // Do not pad with zeros to the right.
+			}
+			afterIndex = false
+		} else {
+			p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
+			if afterIndex && p.fmt.widPresent { // "%[3]2d"
+				p.goodArgNum = false
+			}
+		}
+
+		// Do we have precision?
+		if i+1 < end && format[i] == '.' {
+			i++
+			if afterIndex { // "%[3].2d"
+				p.goodArgNum = false
+			}
+			argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
+			if i < end && format[i] == '*' {
+				i++
+				p.fmt.prec, p.fmt.precPresent, argNum = intFromArg(a, argNum)
+				// Negative precision arguments don't make sense
+				if p.fmt.prec < 0 {
+					p.fmt.prec = 0
+					p.fmt.precPresent = false
+				}
+				if !p.fmt.precPresent {
+					p.buf.WriteString(badPrecString)
+				}
+				afterIndex = false
+			} else {
+				p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i, end)
+				if !p.fmt.precPresent {
+					p.fmt.prec = 0
+					p.fmt.precPresent = true
+				}
+			}
+		}
+
+		if !afterIndex {
+			argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
+		}
+
+		if i >= end {
+			p.buf.WriteString(noVerbString)
+			break
+		}
+
+		verb, w := utf8.DecodeRuneInString(format[i:])
+		i += w
+
+		switch {
+		case verb == '%': // Percent does not absorb operands and ignores f.wid and f.prec.
+			p.buf.WriteByte('%')
+		case !p.goodArgNum:
+			p.badArgNum(verb)
+		case argNum >= len(a): // No argument left over to print for the current verb.
+			p.missingArg(verb)
+		case verb == 'v':
+			// Go syntax
+			p.fmt.sharpV = p.fmt.sharp
+			p.fmt.sharp = false
+			// Struct-field syntax
+			p.fmt.plusV = p.fmt.plus
+			p.fmt.plus = false
+			fallthrough
+		default:
+			p.printArg(a[argNum], verb)
+			argNum++
+		}
+	}
+
+	// Check for extra arguments unless the call accessed the arguments
+	// out of order, in which case it's too expensive to detect if they've all
+	// been used and arguably OK if they're not.
+	if !p.reordered && argNum < len(a) {
+		p.fmt.clearflags()
+		p.buf.WriteString(extraString)
+		for i, arg := range a[argNum:] {
+			if i > 0 {
+				p.buf.WriteString(commaSpaceString)
+			}
+			if arg == nil {
+				p.buf.WriteString(nilAngleString)
+			} else {
+				p.buf.WriteString(reflect.TypeOf(arg).String())
+				p.buf.WriteByte('=')
+				p.printArg(arg, 'v')
+			}
+		}
+		p.buf.WriteByte(')')
+	}
+}
+
+func (p *pp) doPrint(a []interface{}) {
+	prevString := false
+	for argNum, arg := range a {
+		isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String
+		// Add a space between two non-string arguments.
+		if argNum > 0 && !isString && !prevString {
+			p.buf.WriteByte(' ')
+		}
+		p.printArg(arg, 'v')
+		prevString = isString
+	}
+}
+
+// doPrintln is like doPrint but always adds a space between arguments
+// and a newline after the last argument.
+func (p *pp) doPrintln(a []interface{}) {
+	for argNum, arg := range a {
+		if argNum > 0 {
+			p.buf.WriteByte(' ')
+		}
+		p.printArg(arg, 'v')
+	}
+	p.buf.WriteByte('\n')
+}