From 01b439e41ec479517fce8f49bec86c4a710f7e69 Mon Sep 17 00:00:00 2001
From: Masaaki Goshima <goccy54@gmail.com>
Date: Sat, 19 Dec 2020 22:40:03 +0900
Subject: [PATCH] Refactor buffering of encoder for improvement performance

---
 encode.go         |  158 +-
 encode_compile.go |    2 +-
 encode_string.go  |  750 +++++++--
 encode_vm.go      | 3686 ++++++++++++++++++++++-----------------------
 json.go           |    2 +-
 5 files changed, 2543 insertions(+), 2055 deletions(-)

diff --git a/encode.go b/encode.go
index 7b29967..2e94831 100644
--- a/encode.go
+++ b/encode.go
@@ -100,7 +100,8 @@ func (e *Encoder) EncodeWithOption(v interface{}, opts ...EncodeOption) error {
 			return err
 		}
 	}
-	if err := e.encode(v); err != nil {
+	var err error
+	if e.buf, err = e.encode(v); err != nil {
 		return err
 	}
 	if e.enabledIndent {
@@ -149,7 +150,8 @@ func (e *Encoder) reset() {
 }
 
 func (e *Encoder) encodeForMarshal(v interface{}) ([]byte, error) {
-	if err := e.encode(v); err != nil {
+	var err error
+	if e.buf, err = e.encode(v); err != nil {
 		return nil, err
 	}
 	if e.enabledIndent {
@@ -162,15 +164,16 @@ func (e *Encoder) encodeForMarshal(v interface{}) ([]byte, error) {
 	return copied, nil
 }
 
-func (e *Encoder) encode(v interface{}) error {
+func (e *Encoder) encode(v interface{}) ([]byte, error) {
+	b := e.buf
 	if v == nil {
-		e.encodeNull()
+		b = encodeNull(b)
 		if e.enabledIndent {
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeIndentComma(b)
 		} else {
-			e.encodeByte(',')
+			b = encodeComma(b)
 		}
-		return nil
+		return b, nil
 	}
 	header := (*interfaceHeader)(unsafe.Pointer(&v))
 	typ := header.typ
@@ -187,9 +190,9 @@ func (e *Encoder) encode(v interface{}) error {
 		ctx := codeSet.ctx.Get().(*encodeRuntimeContext)
 		p := uintptr(header.ptr)
 		ctx.init(p)
-		err := e.run(ctx, code)
+		b, err := e.run(ctx, b, code)
 		codeSet.ctx.Put(ctx)
-		return err
+		return b, err
 	}
 
 	// noescape trick for header.typ ( reflect.*rtype )
@@ -201,7 +204,7 @@ func (e *Encoder) encode(v interface{}) error {
 		withIndent: true,
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 	code, err := e.compileHead(&encodeCompileContext{
 		typ:        copiedType,
@@ -209,7 +212,7 @@ func (e *Encoder) encode(v interface{}) error {
 		withIndent: false,
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 	codeIndent = copyOpcode(codeIndent)
 	code = copyOpcode(code)
@@ -239,55 +242,56 @@ func (e *Encoder) encode(v interface{}) error {
 		c = code
 	}
 
-	if err := e.run(ctx, c); err != nil {
+	b, err = e.run(ctx, b, c)
+	if err != nil {
 		codeSet.ctx.Put(ctx)
-		return err
+		return nil, err
 	}
 	codeSet.ctx.Put(ctx)
-	return nil
+	return b, nil
 }
 
-func (e *Encoder) encodeInt(v int) {
-	e.encodeInt64(int64(v))
+func encodeInt(b []byte, v int) []byte {
+	return strconv.AppendInt(b, int64(v), 10)
 }
 
-func (e *Encoder) encodeInt8(v int8) {
-	e.encodeInt64(int64(v))
+func encodeInt8(b []byte, v int8) []byte {
+	return strconv.AppendInt(b, int64(v), 10)
 }
 
-func (e *Encoder) encodeInt16(v int16) {
-	e.encodeInt64(int64(v))
+func encodeInt16(b []byte, v int16) []byte {
+	return strconv.AppendInt(b, int64(v), 10)
 }
 
-func (e *Encoder) encodeInt32(v int32) {
-	e.encodeInt64(int64(v))
+func encodeInt32(b []byte, v int32) []byte {
+	return strconv.AppendInt(b, int64(v), 10)
 }
 
-func (e *Encoder) encodeInt64(v int64) {
-	e.buf = strconv.AppendInt(e.buf, v, 10)
+func encodeInt64(b []byte, v int64) []byte {
+	return strconv.AppendInt(b, v, 10)
 }
 
-func (e *Encoder) encodeUint(v uint) {
-	e.encodeUint64(uint64(v))
+func encodeUint(b []byte, v uint) []byte {
+	return strconv.AppendUint(b, uint64(v), 10)
 }
 
-func (e *Encoder) encodeUint8(v uint8) {
-	e.encodeUint64(uint64(v))
+func encodeUint8(b []byte, v uint8) []byte {
+	return strconv.AppendUint(b, uint64(v), 10)
 }
 
-func (e *Encoder) encodeUint16(v uint16) {
-	e.encodeUint64(uint64(v))
+func encodeUint16(b []byte, v uint16) []byte {
+	return strconv.AppendUint(b, uint64(v), 10)
 }
 
-func (e *Encoder) encodeUint32(v uint32) {
-	e.encodeUint64(uint64(v))
+func encodeUint32(b []byte, v uint32) []byte {
+	return strconv.AppendUint(b, uint64(v), 10)
 }
 
-func (e *Encoder) encodeUint64(v uint64) {
-	e.buf = strconv.AppendUint(e.buf, v, 10)
+func encodeUint64(b []byte, v uint64) []byte {
+	return strconv.AppendUint(b, v, 10)
 }
 
-func (e *Encoder) encodeFloat32(v float32) {
+func encodeFloat32(b []byte, v float32) []byte {
 	f64 := float64(v)
 	abs := math.Abs(f64)
 	fmt := byte('f')
@@ -298,10 +302,10 @@ func (e *Encoder) encodeFloat32(v float32) {
 			fmt = 'e'
 		}
 	}
-	e.buf = strconv.AppendFloat(e.buf, f64, fmt, -1, 32)
+	return strconv.AppendFloat(b, f64, fmt, -1, 32)
 }
 
-func (e *Encoder) encodeFloat64(v float64) {
+func encodeFloat64(b []byte, v float64) []byte {
 	abs := math.Abs(v)
 	fmt := byte('f')
 	// Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
@@ -310,58 +314,62 @@ func (e *Encoder) encodeFloat64(v float64) {
 			fmt = 'e'
 		}
 	}
-	e.buf = strconv.AppendFloat(e.buf, v, fmt, -1, 64)
+	return strconv.AppendFloat(b, v, fmt, -1, 64)
 }
 
-func (e *Encoder) encodeBool(v bool) {
-	e.buf = strconv.AppendBool(e.buf, v)
-}
-
-func (e *Encoder) encodeBytes(b []byte) {
-	e.buf = append(e.buf, b...)
-}
-
-func (e *Encoder) encodeNull() {
-	e.buf = append(e.buf, 'n', 'u', 'l', 'l')
-}
-
-func (e *Encoder) encodeKey(code *opcode) {
-	if e.enabledHTMLEscape {
-		e.encodeBytes(code.escapedKey)
-	} else {
-		e.encodeBytes(code.key)
+func encodeBool(b []byte, v bool) []byte {
+	if v {
+		return append(b, "true"...)
 	}
+	return append(b, "false"...)
 }
 
-func (e *Encoder) encodeString(s string) {
+func encodeBytes(dst []byte, src []byte) []byte {
+	return append(dst, src...)
+}
+
+func encodeNull(b []byte) []byte {
+	return append(b, "null"...)
+}
+
+func encodeComma(b []byte) []byte {
+	return append(b, ',')
+}
+
+func encodeIndentComma(b []byte) []byte {
+	return append(b, ',', '\n')
+}
+
+func (e *Encoder) encodeKey(b []byte, code *opcode) []byte {
 	if e.enabledHTMLEscape {
-		e.encodeEscapedString(s)
-	} else {
-		e.encodeNoEscapedString(s)
+		return append(b, code.escapedKey...)
 	}
+	return append(b, code.key...)
 }
 
-func (e *Encoder) encodeByteSlice(b []byte) {
-	encodedLen := base64.StdEncoding.EncodedLen(len(b))
-	e.encodeByte('"')
-	pos := len(e.buf)
-	remainLen := cap(e.buf[pos:])
+func (e *Encoder) encodeString(b []byte, s string) []byte {
+	if e.enabledHTMLEscape {
+		return encodeEscapedString(b, s)
+	}
+	return encodeNoEscapedString(b, s)
+}
+
+func encodeByteSlice(b []byte, src []byte) []byte {
+	encodedLen := base64.StdEncoding.EncodedLen(len(src))
+	b = append(b, '"')
+	pos := len(b)
+	remainLen := cap(b[pos:])
 	var buf []byte
 	if remainLen > encodedLen {
-		buf = e.buf[pos : pos+encodedLen]
+		buf = b[pos : pos+encodedLen]
 	} else {
 		buf = make([]byte, encodedLen)
 	}
-	base64.StdEncoding.Encode(buf, b)
-	e.encodeBytes(buf)
-	e.encodeByte('"')
+	base64.StdEncoding.Encode(buf, src)
+	return append(append(b, buf...), '"')
 }
 
-func (e *Encoder) encodeByte(b byte) {
-	e.buf = append(e.buf, b)
-}
-
-func (e *Encoder) encodeIndent(indent int) {
-	e.buf = append(e.buf, e.prefix...)
-	e.buf = append(e.buf, bytes.Repeat(e.indentStr, indent)...)
+func (e *Encoder) encodeIndent(b []byte, indent int) []byte {
+	b = append(b, e.prefix...)
+	return append(b, bytes.Repeat(e.indentStr, indent)...)
 }
diff --git a/encode_compile.go b/encode_compile.go
index dd41b56..0090afa 100644
--- a/encode_compile.go
+++ b/encode_compile.go
@@ -1007,7 +1007,7 @@ func (e *Encoder) compileStruct(ctx *encodeCompileContext, isPtr bool) (*opcode,
 
 		var buf bytes.Buffer
 		enc := NewEncoder(&buf)
-		enc.encodeEscapedString(tag.key)
+		enc.buf = encodeEscapedString(enc.buf, tag.key)
 		escapedKey := fmt.Sprintf(`%s:`, string(enc.buf))
 		enc.release()
 		fieldCode := &opcode{
diff --git a/encode_string.go b/encode_string.go
index bd3b140..5aca3a5 100644
--- a/encode_string.go
+++ b/encode_string.go
@@ -1,9 +1,352 @@
 package json
 
 import (
+	"math/bits"
+	"reflect"
 	"unicode/utf8"
+	"unsafe"
 )
 
+const (
+	lsb = 0x0101010101010101
+	msb = 0x8080808080808080
+)
+
+var needEscapeWithHTML = [256]bool{
+	'"':  true,
+	'&':  true,
+	'<':  true,
+	'>':  true,
+	'\\': true,
+	0x00: true,
+	0x01: true,
+	0x02: true,
+	0x03: true,
+	0x04: true,
+	0x05: true,
+	0x06: true,
+	0x07: true,
+	0x08: true,
+	0x09: true,
+	0x0a: true,
+	0x0b: true,
+	0x0c: true,
+	0x0d: true,
+	0x0e: true,
+	0x0f: true,
+	0x10: true,
+	0x11: true,
+	0x12: true,
+	0x13: true,
+	0x14: true,
+	0x15: true,
+	0x16: true,
+	0x17: true,
+	0x18: true,
+	0x19: true,
+	0x1a: true,
+	0x1b: true,
+	0x1c: true,
+	0x1d: true,
+	0x1e: true,
+	0x1f: true,
+	/* 0x20 - 0x7f */
+	0x80: true,
+	0x81: true,
+	0x82: true,
+	0x83: true,
+	0x84: true,
+	0x85: true,
+	0x86: true,
+	0x87: true,
+	0x88: true,
+	0x89: true,
+	0x8a: true,
+	0x8b: true,
+	0x8c: true,
+	0x8d: true,
+	0x8e: true,
+	0x8f: true,
+	0x90: true,
+	0x91: true,
+	0x92: true,
+	0x93: true,
+	0x94: true,
+	0x95: true,
+	0x96: true,
+	0x97: true,
+	0x98: true,
+	0x99: true,
+	0x9a: true,
+	0x9b: true,
+	0x9c: true,
+	0x9d: true,
+	0x9e: true,
+	0x9f: true,
+	0xa0: true,
+	0xa1: true,
+	0xa2: true,
+	0xa3: true,
+	0xa4: true,
+	0xa5: true,
+	0xa6: true,
+	0xa7: true,
+	0xa8: true,
+	0xa9: true,
+	0xaa: true,
+	0xab: true,
+	0xac: true,
+	0xad: true,
+	0xae: true,
+	0xaf: true,
+	0xb0: true,
+	0xb1: true,
+	0xb2: true,
+	0xb3: true,
+	0xb4: true,
+	0xb5: true,
+	0xb6: true,
+	0xb7: true,
+	0xb8: true,
+	0xb9: true,
+	0xba: true,
+	0xbb: true,
+	0xbc: true,
+	0xbd: true,
+	0xbe: true,
+	0xbf: true,
+	0xc0: true,
+	0xc1: true,
+	0xc2: true,
+	0xc3: true,
+	0xc4: true,
+	0xc5: true,
+	0xc6: true,
+	0xc7: true,
+	0xc8: true,
+	0xc9: true,
+	0xca: true,
+	0xcb: true,
+	0xcc: true,
+	0xcd: true,
+	0xce: true,
+	0xcf: true,
+	0xd0: true,
+	0xd1: true,
+	0xd2: true,
+	0xd3: true,
+	0xd4: true,
+	0xd5: true,
+	0xd6: true,
+	0xd7: true,
+	0xd8: true,
+	0xd9: true,
+	0xda: true,
+	0xdb: true,
+	0xdc: true,
+	0xdd: true,
+	0xde: true,
+	0xdf: true,
+	0xe0: true,
+	0xe1: true,
+	0xe2: true,
+	0xe3: true,
+	0xe4: true,
+	0xe5: true,
+	0xe6: true,
+	0xe7: true,
+	0xe8: true,
+	0xe9: true,
+	0xea: true,
+	0xeb: true,
+	0xec: true,
+	0xed: true,
+	0xee: true,
+	0xef: true,
+	0xf0: true,
+	0xf1: true,
+	0xf2: true,
+	0xf3: true,
+	0xf4: true,
+	0xf5: true,
+	0xf6: true,
+	0xf7: true,
+	0xf8: true,
+	0xf9: true,
+	0xfa: true,
+	0xfb: true,
+	0xfc: true,
+	0xfd: true,
+	0xfe: true,
+	0xff: true,
+}
+
+var needEscape = [256]bool{
+	'"':  true,
+	'\\': true,
+	0x00: true,
+	0x01: true,
+	0x02: true,
+	0x03: true,
+	0x04: true,
+	0x05: true,
+	0x06: true,
+	0x07: true,
+	0x08: true,
+	0x09: true,
+	0x0a: true,
+	0x0b: true,
+	0x0c: true,
+	0x0d: true,
+	0x0e: true,
+	0x0f: true,
+	0x10: true,
+	0x11: true,
+	0x12: true,
+	0x13: true,
+	0x14: true,
+	0x15: true,
+	0x16: true,
+	0x17: true,
+	0x18: true,
+	0x19: true,
+	0x1a: true,
+	0x1b: true,
+	0x1c: true,
+	0x1d: true,
+	0x1e: true,
+	0x1f: true,
+	/* 0x20 - 0x7f */
+	0x80: true,
+	0x81: true,
+	0x82: true,
+	0x83: true,
+	0x84: true,
+	0x85: true,
+	0x86: true,
+	0x87: true,
+	0x88: true,
+	0x89: true,
+	0x8a: true,
+	0x8b: true,
+	0x8c: true,
+	0x8d: true,
+	0x8e: true,
+	0x8f: true,
+	0x90: true,
+	0x91: true,
+	0x92: true,
+	0x93: true,
+	0x94: true,
+	0x95: true,
+	0x96: true,
+	0x97: true,
+	0x98: true,
+	0x99: true,
+	0x9a: true,
+	0x9b: true,
+	0x9c: true,
+	0x9d: true,
+	0x9e: true,
+	0x9f: true,
+	0xa0: true,
+	0xa1: true,
+	0xa2: true,
+	0xa3: true,
+	0xa4: true,
+	0xa5: true,
+	0xa6: true,
+	0xa7: true,
+	0xa8: true,
+	0xa9: true,
+	0xaa: true,
+	0xab: true,
+	0xac: true,
+	0xad: true,
+	0xae: true,
+	0xaf: true,
+	0xb0: true,
+	0xb1: true,
+	0xb2: true,
+	0xb3: true,
+	0xb4: true,
+	0xb5: true,
+	0xb6: true,
+	0xb7: true,
+	0xb8: true,
+	0xb9: true,
+	0xba: true,
+	0xbb: true,
+	0xbc: true,
+	0xbd: true,
+	0xbe: true,
+	0xbf: true,
+	0xc0: true,
+	0xc1: true,
+	0xc2: true,
+	0xc3: true,
+	0xc4: true,
+	0xc5: true,
+	0xc6: true,
+	0xc7: true,
+	0xc8: true,
+	0xc9: true,
+	0xca: true,
+	0xcb: true,
+	0xcc: true,
+	0xcd: true,
+	0xce: true,
+	0xcf: true,
+	0xd0: true,
+	0xd1: true,
+	0xd2: true,
+	0xd3: true,
+	0xd4: true,
+	0xd5: true,
+	0xd6: true,
+	0xd7: true,
+	0xd8: true,
+	0xd9: true,
+	0xda: true,
+	0xdb: true,
+	0xdc: true,
+	0xdd: true,
+	0xde: true,
+	0xdf: true,
+	0xe0: true,
+	0xe1: true,
+	0xe2: true,
+	0xe3: true,
+	0xe4: true,
+	0xe5: true,
+	0xe6: true,
+	0xe7: true,
+	0xe8: true,
+	0xe9: true,
+	0xea: true,
+	0xeb: true,
+	0xec: true,
+	0xed: true,
+	0xee: true,
+	0xef: true,
+	0xf0: true,
+	0xf1: true,
+	0xf2: true,
+	0xf3: true,
+	0xf4: true,
+	0xf5: true,
+	0xf6: true,
+	0xf7: true,
+	0xf8: true,
+	0xf9: true,
+	0xfa: true,
+	0xfb: true,
+	0xfc: true,
+	0xfd: true,
+	0xfe: true,
+	0xff: true,
+}
+
 // htmlSafeSet holds the value true if the ASCII character with the given
 // array position can be safely represented inside a JSON string, embedded
 // inside of HTML <script> tags, without any additional escaping.
@@ -345,154 +688,293 @@ var safeSet = [utf8.RuneSelf]bool{
 
 var hex = "0123456789abcdef"
 
-func (e *Encoder) encodeEscapedString(s string) {
+// escapeIndex finds the index of the first char in `s` that requires escaping.
+// A char requires escaping if it's outside of the range of [0x20, 0x7F] or if
+// it includes a double quote or backslash.
+// If no chars in `s` require escaping, the return value is -1.
+func escapeIndex(s string) int {
+	chunks := stringToUint64Slice(s)
+	for _, n := range chunks {
+		// combine masks before checking for the MSB of each byte. We include
+		// `n` in the mask to check whether any of the *input* byte MSBs were
+		// set (i.e. the byte was outside the ASCII range).
+		mask := n | below(n, 0x20) | contains(n, '"') | contains(n, '\\')
+		if (mask & msb) != 0 {
+			return bits.TrailingZeros64(mask&msb) / 8
+		}
+	}
+
 	valLen := len(s)
-	// write string, the fast path, without utf8 and escape support
-	i := 0
-	for ; i < valLen; i++ {
-		if !htmlSafeSet[s[i]] {
-			break
+	for i := len(chunks) * 8; i < valLen; i++ {
+		if needEscape[s[i]] {
+			return i
 		}
 	}
-	e.buf = append(e.buf, '"')
-	if i == valLen {
-		e.buf = append(e.buf, s...)
-		e.buf = append(e.buf, '"')
-		return
-	}
-	e.buf = append(e.buf, s[:i]...)
-	e.writeStringSlowPathWithHTMLEscaped(i, s, valLen)
+
+	return -1
 }
 
-func (e *Encoder) writeStringSlowPathWithHTMLEscaped(i int, s string, valLen int) {
-	start := i
-	// for the remaining parts, we process them char by char
-	for i < valLen {
-		if b := s[i]; b < utf8.RuneSelf {
-			if htmlSafeSet[b] {
-				i++
-				continue
-			}
-			if start < i {
-				e.buf = append(e.buf, s[start:i]...)
-			}
-			switch b {
-			case '\\', '"':
-				e.buf = append(e.buf, '\\', b)
-			case '\n':
-				e.buf = append(e.buf, '\\', 'n')
-			case '\r':
-				e.buf = append(e.buf, '\\', 'r')
-			case '\t':
-				e.buf = append(e.buf, '\\', 't')
-			default:
-				// This encodes bytes < 0x20 except for \t, \n and \r.
-				// If escapeHTML is set, it also escapes <, >, and &
-				// because they can lead to security holes when
-				// user-controlled strings are rendered into JSON
-				// and served to some browsers.
-				e.buf = append(e.buf, `\u00`...)
-				e.buf = append(e.buf, hex[b>>4], hex[b&0xF])
-			}
-			i++
-			start = i
-			continue
+// escapeIndex finds the index of the first char in `s` that requires escaping.
+// A char requires escaping if it's outside of the range of [0x20, 0x7F] or if
+// it includes a double quote or backslash.
+// Also, the chars <, > and & require escaping.
+// If no chars in `s` require escaping, the return value is -1.
+func escapeIndexWithHTMLEscape(s string) int {
+	chunks := stringToUint64Slice(s)
+	for _, n := range chunks {
+		// combine masks before checking for the MSB of each byte. We include
+		// `n` in the mask to check whether any of the *input* byte MSBs were
+		// set (i.e. the byte was outside the ASCII range).
+		mask := n | below(n, 0x20) | contains(n, '"') | contains(n, '\\') | contains(n, '<') | contains(n, '>') | contains(n, '&')
+		if (mask & msb) != 0 {
+			return bits.TrailingZeros64(mask&msb) / 8
 		}
-		c, size := utf8.DecodeRuneInString(s[i:])
-		if c == utf8.RuneError && size == 1 {
-			if start < i {
-				e.buf = append(e.buf, s[start:i]...)
-			}
-			e.buf = append(e.buf, `\ufffd`...)
-			i++
-			start = i
-			continue
-		}
-		// U+2028 is LINE SEPARATOR.
-		// U+2029 is PARAGRAPH SEPARATOR.
-		// They are both technically valid characters in JSON strings,
-		// but don't work in JSONP, which has to be evaluated as JavaScript,
-		// and can lead to security holes there. It is valid JSON to
-		// escape them, so we do so unconditionally.
-		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
-		if c == '\u2028' || c == '\u2029' {
-			if start < i {
-				e.buf = append(e.buf, s[start:i]...)
-			}
-			e.buf = append(e.buf, `\u202`...)
-			e.buf = append(e.buf, hex[c&0xF])
-			i += size
-			start = i
-			continue
-		}
-		i += size
 	}
-	if start < len(s) {
-		e.buf = append(e.buf, s[start:]...)
-	}
-	e.buf = append(e.buf, '"')
-}
 
-func (e *Encoder) encodeNoEscapedString(s string) {
 	valLen := len(s)
-
-	// write string, the fast path, without utf8 and escape support
-	i := 0
-	for ; i < valLen; i++ {
-		c := s[i]
-		if c <= 31 || c == '"' || c == '\\' {
-			break
+	for i := len(chunks) * 8; i < valLen; i++ {
+		if needEscapeWithHTML[s[i]] {
+			return i
 		}
 	}
-	e.buf = append(e.buf, '"')
-	if i == valLen {
-		e.buf = append(e.buf, s...)
-		e.buf = append(e.buf, '"')
-		return
-	}
-	e.buf = append(e.buf, s[:i]...)
-	e.writeStringSlowPath(i, s, valLen)
+
+	return -1
 }
 
-func (e *Encoder) writeStringSlowPath(i int, s string, valLen int) {
-	start := i
-	// for the remaining parts, we process them char by char
-	for i < valLen {
-		if b := s[i]; b < utf8.RuneSelf {
-			if safeSet[b] {
-				i++
-				continue
-			}
-			if start < i {
-				e.buf = append(e.buf, s[start:i]...)
-			}
-			switch b {
-			case '\\', '"':
-				e.buf = append(e.buf, '\\', b)
-			case '\n':
-				e.buf = append(e.buf, '\\', 'n')
-			case '\r':
-				e.buf = append(e.buf, '\\', 'r')
-			case '\t':
-				e.buf = append(e.buf, '\\', 't')
-			default:
-				// This encodes bytes < 0x20 except for \t, \n and \r.
-				// If escapeHTML is set, it also escapes <, >, and &
-				// because they can lead to security holes when
-				// user-controlled strings are rendered into JSON
-				// and served to some browsers.
-				e.buf = append(e.buf, []byte(`\u00`)...)
-				e.buf = append(e.buf, hex[b>>4], hex[b&0xF])
-			}
-			i++
-			start = i
+// below return a mask that can be used to determine if any of the bytes
+// in `n` are below `b`. If a byte's MSB is set in the mask then that byte was
+// below `b`. The result is only valid if `b`, and each byte in `n`, is below
+// 0x80.
+func below(n uint64, b byte) uint64 {
+	return n - expand(b)
+}
+
+// contains returns a mask that can be used to determine if any of the
+// bytes in `n` are equal to `b`. If a byte's MSB is set in the mask then
+// that byte is equal to `b`. The result is only valid if `b`, and each
+// byte in `n`, is below 0x80.
+func contains(n uint64, b byte) uint64 {
+	return (n ^ expand(b)) - lsb
+}
+
+// expand puts the specified byte into each of the 8 bytes of a uint64.
+func expand(b byte) uint64 {
+	return lsb * uint64(b)
+}
+
+func stringToUint64Slice(s string) []uint64 {
+	return *(*[]uint64)(unsafe.Pointer(&reflect.SliceHeader{
+		Data: ((*reflect.StringHeader)(unsafe.Pointer(&s))).Data,
+		Len:  len(s) / 8,
+		Cap:  len(s) / 8,
+	}))
+}
+
+func encodeEscapedString(buf []byte, s string) []byte {
+	valLen := len(s)
+	if valLen == 0 {
+		return append(buf, `""`...)
+	}
+	buf = append(buf, '"')
+	var escapeIdx int
+	if valLen >= 8 {
+		if escapeIdx = escapeIndexWithHTMLEscape(s); escapeIdx < 0 {
+			return append(append(buf, s...), '"')
+		}
+	}
+	i := 0
+	j := escapeIdx
+	for j < valLen {
+		c := s[j]
+
+		if c >= 0x20 && c <= 0x7f && c != '\\' && c != '"' && (c != '<' && c != '>' && c != '&') {
+			// fast path: most of the time, printable ascii characters are used
+			j++
 			continue
 		}
-		i++
-		continue
+
+		switch c {
+		case '\\', '"':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', c)
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\n':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 'n')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\r':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 'r')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\t':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 't')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '<', '>', '&':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u00`...)
+			buf = append(buf, hex[c>>4], hex[c&0xF])
+			i = j + 1
+			j = j + 1
+			continue
+		}
+
+		// This encodes bytes < 0x20 except for \t, \n and \r.
+		if c < 0x20 {
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u00`...)
+			buf = append(buf, hex[c>>4], hex[c&0xF])
+			i = j + 1
+			j = j + 1
+			continue
+		}
+
+		r, size := utf8.DecodeRuneInString(s[j:])
+
+		if r == utf8.RuneError && size == 1 {
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\ufffd`...)
+			i = j + size
+			j = j + size
+			continue
+		}
+
+		switch r {
+		case '\u2028', '\u2029':
+			// U+2028 is LINE SEPARATOR.
+			// U+2029 is PARAGRAPH SEPARATOR.
+			// They are both technically valid characters in JSON strings,
+			// but don't work in JSONP, which has to be evaluated as JavaScript,
+			// and can lead to security holes there. It is valid JSON to
+			// escape them, so we do so unconditionally.
+			// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u202`...)
+			buf = append(buf, hex[r&0xF])
+			i = j + size
+			j = j + size
+			continue
+		}
+
+		j += size
 	}
-	if start < len(s) {
-		e.buf = append(e.buf, s[start:]...)
-	}
-	e.buf = append(e.buf, '"')
+
+	return append(append(buf, s[i:]...), '"')
+}
+
+func encodeNoEscapedString(buf []byte, s string) []byte {
+	valLen := len(s)
+	if valLen == 0 {
+		return append(buf, `""`...)
+	}
+	buf = append(buf, '"')
+	var escapeIdx int
+	if valLen >= 8 {
+		if escapeIdx = escapeIndex(s); escapeIdx < 0 {
+			return append(append(buf, s...), '"')
+		}
+	}
+
+	i := 0
+	j := escapeIdx
+	for j < valLen {
+		c := s[j]
+
+		if c >= 0x20 && c <= 0x7f && c != '\\' && c != '"' {
+			// fast path: most of the time, printable ascii characters are used
+			j++
+			continue
+		}
+
+		switch c {
+		case '\\', '"':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', c)
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\n':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 'n')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\r':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 'r')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '\t':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, '\\', 't')
+			i = j + 1
+			j = j + 1
+			continue
+
+		case '<', '>', '&':
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u00`...)
+			buf = append(buf, hex[c>>4], hex[c&0xF])
+			i = j + 1
+			j = j + 1
+			continue
+		}
+
+		// This encodes bytes < 0x20 except for \t, \n and \r.
+		if c < 0x20 {
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u00`...)
+			buf = append(buf, hex[c>>4], hex[c&0xF])
+			i = j + 1
+			j = j + 1
+			continue
+		}
+
+		r, size := utf8.DecodeRuneInString(s[j:])
+
+		if r == utf8.RuneError && size == 1 {
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\ufffd`...)
+			i = j + size
+			j = j + size
+			continue
+		}
+
+		switch r {
+		case '\u2028', '\u2029':
+			// U+2028 is LINE SEPARATOR.
+			// U+2029 is PARAGRAPH SEPARATOR.
+			// They are both technically valid characters in JSON strings,
+			// but don't work in JSONP, which has to be evaluated as JavaScript,
+			// and can lead to security holes there. It is valid JSON to
+			// escape them, so we do so unconditionally.
+			// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+			buf = append(buf, s[i:j]...)
+			buf = append(buf, `\u202`...)
+			buf = append(buf, hex[r&0xF])
+			i = j + size
+			j = j + size
+			continue
+		}
+
+		j += size
+	}
+
+	return append(append(buf, s[i:]...), '"')
 }
diff --git a/encode_vm.go b/encode_vm.go
index 2a83ca0..0bc3cc5 100644
--- a/encode_vm.go
+++ b/encode_vm.go
@@ -49,7 +49,7 @@ func errMarshaler(code *opcode, err error) *MarshalerError {
 	}
 }
 
-func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
+func (e *Encoder) run(ctx *encodeRuntimeContext, b []byte, code *opcode) ([]byte, error) {
 	recursiveLevel := 0
 	seenPtr := map[uintptr]struct{}{}
 	ptrOffset := uintptr(0)
@@ -58,169 +58,169 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 	for {
 		switch code.op {
 		default:
-			return fmt.Errorf("failed to handle opcode. doesn't implement %s", code.op)
+			return nil, fmt.Errorf("failed to handle opcode. doesn't implement %s", code.op)
 		case opPtr, opPtrIndent:
 			ptr := load(ctxptr, code.idx)
 			code = code.next
 			store(ctxptr, code.idx, e.ptrToPtr(ptr))
 		case opInt:
-			e.encodeInt(e.ptrToInt(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeInt(b, e.ptrToInt(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opIntIndent:
-			e.encodeInt(e.ptrToInt(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt(b, e.ptrToInt(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opInt8:
-			e.encodeInt8(e.ptrToInt8(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeInt8(b, e.ptrToInt8(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opInt8Indent:
-			e.encodeInt8(e.ptrToInt8(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt8(b, e.ptrToInt8(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opInt16:
-			e.encodeInt16(e.ptrToInt16(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeInt16(b, e.ptrToInt16(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opInt16Indent:
-			e.encodeInt16(e.ptrToInt16(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt16(b, e.ptrToInt16(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opInt32:
-			e.encodeInt32(e.ptrToInt32(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeInt32(b, e.ptrToInt32(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opInt32Indent:
-			e.encodeInt32(e.ptrToInt32(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt32(b, e.ptrToInt32(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opInt64:
-			e.encodeInt64(e.ptrToInt64(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeInt64(b, e.ptrToInt64(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opInt64Indent:
-			e.encodeInt64(e.ptrToInt64(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt64(b, e.ptrToInt64(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opUint:
-			e.encodeUint(e.ptrToUint(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeUint(b, e.ptrToUint(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opUintIndent:
-			e.encodeUint(e.ptrToUint(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint(b, e.ptrToUint(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opUint8:
-			e.encodeUint8(e.ptrToUint8(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeUint8(b, e.ptrToUint8(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opUint8Indent:
-			e.encodeUint8(e.ptrToUint8(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint8(b, e.ptrToUint8(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opUint16:
-			e.encodeUint16(e.ptrToUint16(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeUint16(b, e.ptrToUint16(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opUint16Indent:
-			e.encodeUint16(e.ptrToUint16(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint16(b, e.ptrToUint16(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opUint32:
-			e.encodeUint32(e.ptrToUint32(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeUint32(b, e.ptrToUint32(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opUint32Indent:
-			e.encodeUint32(e.ptrToUint32(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint32(b, e.ptrToUint32(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opUint64:
-			e.encodeUint64(e.ptrToUint64(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeUint64(b, e.ptrToUint64(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opUint64Indent:
-			e.encodeUint64(e.ptrToUint64(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint64(b, e.ptrToUint64(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opFloat32:
-			e.encodeFloat32(e.ptrToFloat32(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeFloat32(b, e.ptrToFloat32(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opFloat32Indent:
-			e.encodeFloat32(e.ptrToFloat32(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeFloat32(b, e.ptrToFloat32(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opFloat64:
 			v := e.ptrToFloat64(load(ctxptr, code.idx))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeFloat64(v)
-			e.encodeByte(',')
+			b = encodeFloat64(b, v)
+			b = encodeComma(b)
 			code = code.next
 		case opFloat64Indent:
 			v := e.ptrToFloat64(load(ctxptr, code.idx))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeFloat64(v)
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeFloat64(b, v)
+			b = encodeIndentComma(b)
 			code = code.next
 		case opString:
-			e.encodeString(e.ptrToString(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = e.encodeString(b, e.ptrToString(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opStringIndent:
-			e.encodeString(e.ptrToString(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeString(b, e.ptrToString(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opBool:
-			e.encodeBool(e.ptrToBool(load(ctxptr, code.idx)))
-			e.encodeByte(',')
+			b = encodeBool(b, e.ptrToBool(load(ctxptr, code.idx)))
+			b = encodeComma(b)
 			code = code.next
 		case opBoolIndent:
-			e.encodeBool(e.ptrToBool(load(ctxptr, code.idx)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeBool(b, e.ptrToBool(load(ctxptr, code.idx)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opBytes:
 			ptr := load(ctxptr, code.idx)
 			slice := e.ptrToSlice(ptr)
 			if ptr == 0 || uintptr(slice.data) == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeByteSlice(e.ptrToBytes(ptr))
+				b = encodeByteSlice(b, e.ptrToBytes(ptr))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opBytesIndent:
 			ptr := load(ctxptr, code.idx)
 			slice := e.ptrToSlice(ptr)
 			if ptr == 0 || uintptr(slice.data) == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeByteSlice(e.ptrToBytes(ptr))
+				b = encodeByteSlice(b, e.ptrToBytes(ptr))
 			}
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeIndentComma(b)
 			code = code.next
 		case opInterface:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.next
 				break
 			}
 			if _, exists := seenPtr[ptr]; exists {
-				return errUnsupportedValue(code, ptr)
+				return nil, errUnsupportedValue(code, ptr)
 			}
 			seenPtr[ptr] = struct{}{}
 			v := e.ptrToInterface(code, ptr)
 			ctx.keepRefs = append(ctx.keepRefs, unsafe.Pointer(&v))
 			rv := reflect.ValueOf(v)
 			if rv.IsNil() {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.next
 				break
 			}
@@ -239,7 +239,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					indent:     code.indent,
 				}, false)
 				if err != nil {
-					return err
+					return nil, err
 				}
 				c = code
 			} else {
@@ -250,7 +250,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					indent:     code.indent,
 				})
 				if err != nil {
-					return err
+					return nil, err
 				}
 				c = code
 			}
@@ -283,21 +283,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opInterfaceIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.next
 				break
 			}
 			if _, exists := seenPtr[ptr]; exists {
-				return errUnsupportedValue(code, ptr)
+				return nil, errUnsupportedValue(code, ptr)
 			}
 			seenPtr[ptr] = struct{}{}
 			v := e.ptrToInterface(code, ptr)
 			ctx.keepRefs = append(ctx.keepRefs, unsafe.Pointer(&v))
 			rv := reflect.ValueOf(v)
 			if rv.IsNil() {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.next
 				break
 			}
@@ -316,7 +316,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					indent:     code.indent,
 				}, false)
 				if err != nil {
-					return err
+					return nil, err
 				}
 				c = code
 			} else {
@@ -327,7 +327,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					indent:     code.indent,
 				})
 				if err != nil {
-					return err
+					return nil, err
 				}
 				c = code
 			}
@@ -367,32 +367,31 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opMarshalJSON:
 			ptr := load(ctxptr, code.idx)
 			v := e.ptrToInterface(code, ptr)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
-			if len(b) == 0 {
-				return errUnexpectedEndOfJSON(
+			if len(bb) == 0 {
+				return nil, errUnexpectedEndOfJSON(
 					fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 					0,
 				)
 			}
 			var buf bytes.Buffer
-			if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-				return err
+			if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+				return nil, err
 			}
-			e.encodeBytes(buf.Bytes())
-			e.encodeByte(',')
+			b = append(append(b, buf.Bytes()...), ',')
 			code = code.next
 		case opMarshalJSONIndent:
 			ptr := load(ctxptr, code.idx)
 			v := e.ptrToInterface(code, ptr)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
-			if len(b) == 0 {
-				return errUnexpectedEndOfJSON(
+			if len(bb) == 0 {
+				return nil, errUnexpectedEndOfJSON(
 					fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 					0,
 				)
@@ -400,24 +399,24 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			var buf bytes.Buffer
 			if err := encodeWithIndent(
 				&buf,
-				b,
+				bb,
 				string(e.prefix)+string(bytes.Repeat(e.indentStr, code.indent)),
 				string(e.indentStr),
 			); err != nil {
-				return err
+				return nil, err
 			}
-			e.encodeBytes(buf.Bytes())
-			e.encodeBytes([]byte{',', '\n'})
+			b = append(b, buf.Bytes()...)
+			b = encodeIndentComma(b)
 			code = code.next
 		case opMarshalText:
 			ptr := load(ctxptr, code.idx)
 			isPtr := code.typ.Kind() == reflect.Ptr
 			p := e.ptrToUnsafePtr(ptr)
 			if p == nil {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 			} else if isPtr && *(*unsafe.Pointer)(p) == nil {
-				e.encodeBytes([]byte{'"', '"', ','})
+				b = append(b, '"', '"', ',')
 			} else {
 				if isPtr && code.typ.Elem().Implements(marshalTextType) {
 					p = *(*unsafe.Pointer)(p)
@@ -428,10 +427,10 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				}))
 				bytes, err := v.(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opMarshalTextIndent:
@@ -439,10 +438,10 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			isPtr := code.typ.Kind() == reflect.Ptr
 			p := e.ptrToUnsafePtr(ptr)
 			if p == nil {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 			} else if isPtr && *(*unsafe.Pointer)(p) == nil {
-				e.encodeBytes([]byte{'"', '"', ',', '\n'})
+				b = append(b, '"', '"', ',', '\n')
 			} else {
 				if isPtr && code.typ.Elem().Implements(marshalTextType) {
 					p = *(*unsafe.Pointer)(p)
@@ -453,29 +452,29 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				}))
 				bytes, err := v.(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opSliceHead:
 			p := load(ctxptr, code.idx)
 			slice := e.ptrToSlice(p)
 			if p == 0 || uintptr(slice.data) == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
 				store(ctxptr, code.elemIdx, 0)
 				store(ctxptr, code.length, uintptr(slice.len))
 				store(ctxptr, code.idx, uintptr(slice.data))
 				if slice.len > 0 {
-					e.encodeByte('[')
+					b = append(b, '[')
 					code = code.next
 					store(ctxptr, code.idx, uintptr(slice.data))
 				} else {
-					e.encodeBytes([]byte{'[', ']', ','})
+					b = append(b, '[', ']', ',')
 					code = code.end.next
 				}
 			}
@@ -490,17 +489,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				code = code.next
 				store(ctxptr, code.idx, data+idx*size)
 			} else {
-				last := len(e.buf) - 1
-				e.buf[last] = ']'
-				e.encodeByte(',')
+				last := len(b) - 1
+				b[last] = ']'
+				b = encodeComma(b)
 				code = code.end.next
 			}
 		case opSliceHeadIndent:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
 				slice := e.ptrToSlice(p)
@@ -508,22 +507,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				store(ctxptr, code.length, uintptr(slice.len))
 				store(ctxptr, code.idx, uintptr(slice.data))
 				if slice.len > 0 {
-					e.encodeBytes([]byte{'[', '\n'})
-					e.encodeIndent(code.indent + 1)
+					b = append(b, '[', '\n')
+					b = e.encodeIndent(b, code.indent+1)
 					code = code.next
 					store(ctxptr, code.idx, uintptr(slice.data))
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeBytes([]byte{'[', ']', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = append(b, '[', ']', '\n')
 					code = code.end.next
 				}
 			}
 		case opRootSliceHeadIndent:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
 				slice := e.ptrToSlice(p)
@@ -531,13 +530,13 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				store(ctxptr, code.length, uintptr(slice.len))
 				store(ctxptr, code.idx, uintptr(slice.data))
 				if slice.len > 0 {
-					e.encodeBytes([]byte{'[', '\n'})
-					e.encodeIndent(code.indent + 1)
+					b = append(b, '[', '\n')
+					b = e.encodeIndent(b, code.indent+1)
 					code = code.next
 					store(ctxptr, code.idx, uintptr(slice.data))
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeBytes([]byte{'[', ']', ',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = append(b, '[', ']', ',', '\n')
 					code = code.end.next
 				}
 			}
@@ -546,17 +545,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			length := load(ctxptr, code.length)
 			idx++
 			if idx < length {
-				e.encodeIndent(code.indent + 1)
+				b = e.encodeIndent(b, code.indent+1)
 				store(ctxptr, code.elemIdx, idx)
 				data := load(ctxptr, code.headIdx)
 				size := code.size
 				code = code.next
 				store(ctxptr, code.idx, data+idx*size)
 			} else {
-				e.buf = e.buf[:len(e.buf)-2]
-				e.encodeByte('\n')
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{']', ',', '\n'})
+				b = b[:len(b)-2]
+				b = append(b, '\n')
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, ']', ',', '\n')
 				code = code.end.next
 			}
 		case opRootSliceElemIndent:
@@ -564,31 +563,31 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			length := load(ctxptr, code.length)
 			idx++
 			if idx < length {
-				e.encodeIndent(code.indent + 1)
+				b = e.encodeIndent(b, code.indent+1)
 				store(ctxptr, code.elemIdx, idx)
 				code = code.next
 				data := load(ctxptr, code.headIdx)
 				store(ctxptr, code.idx, data+idx*code.size)
 			} else {
-				e.encodeByte('\n')
-				e.encodeIndent(code.indent)
-				e.encodeByte(']')
+				b = append(b, '\n')
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, ']')
 				code = code.end.next
 			}
 		case opArrayHead:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
 				if code.length > 0 {
-					e.encodeByte('[')
+					b = append(b, '[')
 					store(ctxptr, code.elemIdx, 0)
 					code = code.next
 					store(ctxptr, code.idx, p)
 				} else {
-					e.encodeBytes([]byte{'[', ']', ','})
+					b = append(b, '[', ']', ',')
 					code = code.end.next
 				}
 			}
@@ -602,28 +601,28 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				code = code.next
 				store(ctxptr, code.idx, p+idx*size)
 			} else {
-				last := len(e.buf) - 1
-				e.buf[last] = ']'
-				e.encodeByte(',')
+				last := len(b) - 1
+				b[last] = ']'
+				b = encodeComma(b)
 				code = code.end.next
 			}
 		case opArrayHeadIndent:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
 				if code.length > 0 {
-					e.encodeBytes([]byte{'[', '\n'})
-					e.encodeIndent(code.indent + 1)
+					b = append(b, '[', '\n')
+					b = e.encodeIndent(b, code.indent+1)
 					store(ctxptr, code.elemIdx, 0)
 					code = code.next
 					store(ctxptr, code.idx, p)
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeBytes([]byte{'[', ']', ',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = append(b, '[', ']', ',', '\n')
 					code = code.end.next
 				}
 			}
@@ -631,30 +630,30 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			idx := load(ctxptr, code.elemIdx)
 			idx++
 			if idx < code.length {
-				e.encodeIndent(code.indent + 1)
+				b = e.encodeIndent(b, code.indent+1)
 				store(ctxptr, code.elemIdx, idx)
 				p := load(ctxptr, code.headIdx)
 				size := code.size
 				code = code.next
 				store(ctxptr, code.idx, p+idx*size)
 			} else {
-				e.buf = e.buf[:len(e.buf)-2]
-				e.encodeByte('\n')
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{']', ',', '\n'})
+				b = b[:len(b)-2]
+				b = append(b, '\n')
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, ']', ',', '\n')
 				code = code.end.next
 			}
 		case opMapHead:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
 				uptr := e.ptrToUnsafePtr(ptr)
 				mlen := maplen(uptr)
 				if mlen > 0 {
-					e.encodeByte('{')
+					b = append(b, '{')
 					iter := mapiterinit(code.typ, uptr)
 					ctx.keepRefs = append(ctx.keepRefs, iter)
 					store(ctxptr, code.elemIdx, 0)
@@ -662,7 +661,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					store(ctxptr, code.mapIter, uintptr(iter))
 					if !e.unorderedMap {
 						pos := make([]int, 0, mlen)
-						pos = append(pos, len(e.buf))
+						pos = append(pos, len(b))
 						posPtr := unsafe.Pointer(&pos)
 						ctx.keepRefs = append(ctx.keepRefs, posPtr)
 						store(ctxptr, code.end.mapPos, uintptr(posPtr))
@@ -671,29 +670,29 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					store(ctxptr, code.next.idx, uintptr(key))
 					code = code.next
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 					code = code.end.next
 				}
 			}
 		case opMapHeadLoad:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
 				// load pointer
 				ptr = e.ptrToPtr(ptr)
 				uptr := e.ptrToUnsafePtr(ptr)
 				if ptr == 0 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 					code = code.end.next
 					break
 				}
 				mlen := maplen(uptr)
 				if mlen > 0 {
-					e.encodeByte('{')
+					b = append(b, '{')
 					iter := mapiterinit(code.typ, uptr)
 					ctx.keepRefs = append(ctx.keepRefs, iter)
 					store(ctxptr, code.elemIdx, 0)
@@ -703,14 +702,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					store(ctxptr, code.next.idx, uintptr(key))
 					if !e.unorderedMap {
 						pos := make([]int, 0, mlen)
-						pos = append(pos, len(e.buf))
+						pos = append(pos, len(b))
 						posPtr := unsafe.Pointer(&pos)
 						ctx.keepRefs = append(ctx.keepRefs, posPtr)
 						store(ctxptr, code.end.mapPos, uintptr(posPtr))
 					}
 					code = code.next
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 					code = code.end.next
 				}
 			}
@@ -727,15 +726,15 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					store(ctxptr, code.next.idx, uintptr(key))
 					code = code.next
 				} else {
-					last := len(e.buf) - 1
-					e.buf[last] = '}'
-					e.encodeByte(',')
+					last := len(b) - 1
+					b[last] = '}'
+					b = encodeComma(b)
 					code = code.end.next
 				}
 			} else {
 				ptr := load(ctxptr, code.end.mapPos)
 				posPtr := (*[]int)(*(*unsafe.Pointer)(unsafe.Pointer(&ptr)))
-				*posPtr = append(*posPtr, len(e.buf))
+				*posPtr = append(*posPtr, len(b))
 				if idx < length {
 					ptr := load(ctxptr, code.mapIter)
 					iter := e.ptrToUnsafePtr(ptr)
@@ -749,12 +748,12 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			}
 		case opMapValue:
 			if e.unorderedMap {
-				last := len(e.buf) - 1
-				e.buf[last] = ':'
+				last := len(b) - 1
+				b[last] = ':'
 			} else {
 				ptr := load(ctxptr, code.end.mapPos)
 				posPtr := (*[]int)(*(*unsafe.Pointer)(unsafe.Pointer(&ptr)))
-				*posPtr = append(*posPtr, len(e.buf))
+				*posPtr = append(*posPtr, len(b))
 			}
 			ptr := load(ctxptr, code.mapIter)
 			iter := e.ptrToUnsafePtr(ptr)
@@ -780,17 +779,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if i+1 < length {
 					endValue = pos[i*2+2]
 				} else {
-					endValue = len(e.buf)
+					endValue = len(b)
 				}
 				kvs = append(kvs, mapKV{
-					key:   string(e.buf[startKey:startValue]),
-					value: string(e.buf[startValue:endValue]),
+					key:   string(b[startKey:startValue]),
+					value: string(b[startValue:endValue]),
 				})
 			}
 			sort.Slice(kvs, func(i, j int) bool {
 				return kvs[i].key < kvs[j].key
 			})
-			buf := e.buf[pos[0]:]
+			buf := b[pos[0]:]
 			buf = buf[:0]
 			for _, kv := range kvs {
 				buf = append(buf, []byte(kv.key)...)
@@ -799,21 +798,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			}
 			buf[len(buf)-1] = '}'
 			buf = append(buf, ',')
-			e.buf = e.buf[:pos[0]]
-			e.buf = append(e.buf, buf...)
+			b = b[:pos[0]]
+			b = append(b, buf...)
 			code = code.next
 		case opMapHeadIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
 				uptr := e.ptrToUnsafePtr(ptr)
 				mlen := maplen(uptr)
 				if mlen > 0 {
-					e.encodeBytes([]byte{'{', '\n'})
+					b = append(b, '{', '\n')
 					iter := mapiterinit(code.typ, uptr)
 					ctx.keepRefs = append(ctx.keepRefs, iter)
 					store(ctxptr, code.elemIdx, 0)
@@ -822,43 +821,43 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 
 					if !e.unorderedMap {
 						pos := make([]int, 0, mlen)
-						pos = append(pos, len(e.buf))
+						pos = append(pos, len(b))
 						posPtr := unsafe.Pointer(&pos)
 						ctx.keepRefs = append(ctx.keepRefs, posPtr)
 						store(ctxptr, code.end.mapPos, uintptr(posPtr))
 					} else {
-						e.encodeIndent(code.next.indent)
+						b = e.encodeIndent(b, code.next.indent)
 					}
 
 					key := mapiterkey(iter)
 					store(ctxptr, code.next.idx, uintptr(key))
 					code = code.next
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = append(b, '{', '}', ',', '\n')
 					code = code.end.next
 				}
 			}
 		case opMapHeadLoadIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
 				code = code.end.next
 			} else {
 				// load pointer
 				ptr = e.ptrToPtr(ptr)
 				uptr := e.ptrToUnsafePtr(ptr)
 				if uintptr(uptr) == 0 {
-					e.encodeIndent(code.indent)
-					e.encodeNull()
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = encodeNull(b)
+					b = encodeIndentComma(b)
 					code = code.end.next
 					break
 				}
 				mlen := maplen(uptr)
 				if mlen > 0 {
-					e.encodeBytes([]byte{'{', '\n'})
+					b = append(b, '{', '\n')
 					iter := mapiterinit(code.typ, uptr)
 					ctx.keepRefs = append(ctx.keepRefs, iter)
 					store(ctxptr, code.elemIdx, 0)
@@ -869,18 +868,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 
 					if !e.unorderedMap {
 						pos := make([]int, 0, mlen)
-						pos = append(pos, len(e.buf))
+						pos = append(pos, len(b))
 						posPtr := unsafe.Pointer(&pos)
 						ctx.keepRefs = append(ctx.keepRefs, posPtr)
 						store(ctxptr, code.end.mapPos, uintptr(posPtr))
 					} else {
-						e.encodeIndent(code.next.indent)
+						b = e.encodeIndent(b, code.next.indent)
 					}
 
 					code = code.next
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = append(b, '{', '}', ',', '\n')
 					code = code.end.next
 				}
 			}
@@ -890,7 +889,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			idx++
 			if e.unorderedMap {
 				if idx < length {
-					e.encodeIndent(code.indent)
+					b = e.encodeIndent(b, code.indent)
 					store(ctxptr, code.elemIdx, idx)
 					ptr := load(ctxptr, code.mapIter)
 					iter := e.ptrToUnsafePtr(ptr)
@@ -898,16 +897,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					store(ctxptr, code.next.idx, uintptr(key))
 					code = code.next
 				} else {
-					last := len(e.buf) - 1
-					e.buf[last] = '\n'
-					e.encodeIndent(code.indent - 1)
-					e.encodeBytes([]byte{'}', ',', '\n'})
+					last := len(b) - 1
+					b[last] = '\n'
+					b = e.encodeIndent(b, code.indent-1)
+					b = append(b, '}', ',', '\n')
 					code = code.end.next
 				}
 			} else {
 				ptr := load(ctxptr, code.end.mapPos)
 				posPtr := (*[]int)(*(*unsafe.Pointer)(unsafe.Pointer(&ptr)))
-				*posPtr = append(*posPtr, len(e.buf))
+				*posPtr = append(*posPtr, len(b))
 				if idx < length {
 					ptr := load(ctxptr, code.mapIter)
 					iter := e.ptrToUnsafePtr(ptr)
@@ -921,11 +920,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			}
 		case opMapValueIndent:
 			if e.unorderedMap {
-				e.encodeBytes([]byte{':', ' '})
+				b = append(b, ':', ' ')
 			} else {
 				ptr := load(ctxptr, code.end.mapPos)
 				posPtr := (*[]int)(*(*unsafe.Pointer)(unsafe.Pointer(&ptr)))
-				*posPtr = append(*posPtr, len(e.buf))
+				*posPtr = append(*posPtr, len(b))
 			}
 			ptr := load(ctxptr, code.mapIter)
 			iter := e.ptrToUnsafePtr(ptr)
@@ -950,17 +949,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if i+1 < length {
 					endValue = pos[i*2+2]
 				} else {
-					endValue = len(e.buf)
+					endValue = len(b)
 				}
 				kvs = append(kvs, mapKV{
-					key:   string(e.buf[startKey:startValue]),
-					value: string(e.buf[startValue:endValue]),
+					key:   string(b[startKey:startValue]),
+					value: string(b[startValue:endValue]),
 				})
 			}
 			sort.Slice(kvs, func(i, j int) bool {
 				return kvs[i].key < kvs[j].key
 			})
-			buf := e.buf[pos[0]:]
+			buf := b[pos[0]:]
 			buf = buf[:0]
 			for _, kv := range kvs {
 				buf = append(buf, e.prefix...)
@@ -976,8 +975,8 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			buf = append(buf, e.prefix...)
 			buf = append(buf, bytes.Repeat(e.indentStr, code.indent)...)
 			buf = append(buf, '}', ',', '\n')
-			e.buf = e.buf[:pos[0]]
-			e.buf = append(e.buf, buf...)
+			b = b[:pos[0]]
+			b = append(b, buf...)
 			code = code.next
 		case opStructFieldPtrAnonymousHeadRecursive:
 			store(ctxptr, code.idx, e.ptrToPtr(load(ctxptr, code.idx)))
@@ -989,7 +988,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr != 0 {
 				if recursiveLevel > startDetectingCyclesAfter {
 					if _, exists := seenPtr[ptr]; exists {
-						return errUnsupportedValue(code, ptr)
+						return nil, errUnsupportedValue(code, ptr)
 					}
 				}
 			}
@@ -1039,7 +1038,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldPtrHead:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 				code = code.end.next
 				break
 			}
@@ -1049,16 +1048,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHead {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				if !code.anonymousKey {
-					e.encodeKey(code)
+					b = e.encodeKey(b, code)
 				}
 				p := ptr + code.offset
 				code = code.next
@@ -1075,8 +1074,8 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldPtrHeadInt:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1086,17 +1085,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadInt {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeInt(e.ptrToInt(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeInt(b, e.ptrToInt(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadInt:
@@ -1107,16 +1106,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeInt(e.ptrToInt(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt(b, e.ptrToInt(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt8:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1126,17 +1125,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadInt8 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeInt8(e.ptrToInt8(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeInt8(b, e.ptrToInt8(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadInt8:
@@ -1147,16 +1146,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeInt8(e.ptrToInt8(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt8(b, e.ptrToInt8(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt16:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1166,17 +1165,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadInt16 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeInt16(e.ptrToInt16(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeInt16(b, e.ptrToInt16(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadInt16:
@@ -1187,16 +1186,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeInt16(e.ptrToInt16(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt16(b, e.ptrToInt16(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt32:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1206,17 +1205,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadInt32 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeInt32(e.ptrToInt32(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeInt32(b, e.ptrToInt32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadInt32:
@@ -1227,16 +1226,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeInt32(e.ptrToInt32(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt32(b, e.ptrToInt32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt64:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1246,17 +1245,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadInt64 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeInt64(e.ptrToInt64(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeInt64(b, e.ptrToInt64(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadInt64:
@@ -1267,16 +1266,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeInt64(e.ptrToInt64(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt64(b, e.ptrToInt64(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1286,17 +1285,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadUint {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeUint(e.ptrToUint(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeUint(b, e.ptrToUint(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadUint:
@@ -1307,16 +1306,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeUint(e.ptrToUint(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint(b, e.ptrToUint(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint8:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1326,17 +1325,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadUint8 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeUint8(e.ptrToUint8(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeUint8(b, e.ptrToUint8(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadUint8:
@@ -1347,16 +1346,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeUint8(e.ptrToUint8(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint8(b, e.ptrToUint8(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint16:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1366,17 +1365,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadUint16 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeUint16(e.ptrToUint16(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeUint16(b, e.ptrToUint16(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadUint16:
@@ -1387,16 +1386,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeUint16(e.ptrToUint16(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint16(b, e.ptrToUint16(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint32:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1406,17 +1405,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadUint32 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeUint32(e.ptrToUint32(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeUint32(b, e.ptrToUint32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadUint32:
@@ -1427,16 +1426,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeUint32(e.ptrToUint32(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint32(b, e.ptrToUint32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint64:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1446,17 +1445,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadUint64 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeUint64(e.ptrToUint64(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeUint64(b, e.ptrToUint64(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadUint64:
@@ -1467,16 +1466,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeUint64(e.ptrToUint64(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint64(b, e.ptrToUint64(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadFloat32:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1486,17 +1485,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadFloat32 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeFloat32(e.ptrToFloat32(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeFloat32(b, e.ptrToFloat32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadFloat32:
@@ -1507,16 +1506,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeFloat32(e.ptrToFloat32(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeFloat32(b, e.ptrToFloat32(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadFloat64:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1526,21 +1525,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadFloat64 {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
 				v := e.ptrToFloat64(ptr + code.offset)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeFloat64(v)
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeFloat64(b, v)
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadFloat64:
@@ -1553,18 +1552,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			} else {
 				v := e.ptrToFloat64(ptr + code.offset)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeKey(code)
-				e.encodeFloat64(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeFloat64(b, v)
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadString:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1574,17 +1573,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadString {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(e.ptrToString(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, e.ptrToString(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadString:
@@ -1595,16 +1594,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(e.ptrToString(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, e.ptrToString(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadBool:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1614,17 +1613,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadBool {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeBool(e.ptrToBool(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeBool(b, e.ptrToBool(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadBool:
@@ -1635,16 +1634,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeBool(e.ptrToBool(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeBool(b, e.ptrToBool(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadBytes:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1654,17 +1653,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadBytes {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ','})
+					b = append(b, '{', '}', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeByteSlice(e.ptrToBytes(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeByteSlice(b, e.ptrToBytes(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadBytes:
@@ -1675,16 +1674,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeByteSlice(e.ptrToBytes(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeByteSlice(b, e.ptrToBytes(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadArray:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1694,16 +1693,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx) + code.offset
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadArray {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'[', ']', ','})
+					b = append(b, '[', ']', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				if !code.anonymousKey {
-					e.encodeKey(code)
+					b = e.encodeKey(b, code)
 				}
 				code = code.next
 				store(ctxptr, code.idx, ptr)
@@ -1716,15 +1715,15 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				store(ctxptr, code.idx, ptr)
 				code = code.next
 			}
 		case opStructFieldPtrHeadSlice:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1735,16 +1734,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			p := ptr + code.offset
 			if p == 0 {
 				if code.op == opStructFieldPtrHeadSlice {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 				} else {
-					e.encodeBytes([]byte{'[', ']', ','})
+					b = append(b, '[', ']', ',')
 				}
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				if !code.anonymousKey {
-					e.encodeKey(code)
+					b = e.encodeKey(b, code)
 				}
 				code = code.next
 				store(ctxptr, code.idx, p)
@@ -1758,15 +1757,15 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				store(ctxptr, code.idx, p)
 				code = code.next
 			}
 		case opStructFieldPtrHeadMarshalJSON:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1775,36 +1774,36 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadMarshalJSON:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
 				ptr += code.offset
 				v := e.ptrToInterface(code, ptr)
 				rv := reflect.ValueOf(v)
 				if rv.Type().Kind() == reflect.Interface && rv.IsNil() {
-					e.encodeNull()
+					b = encodeNull(b)
 					code = code.end
 					break
 				}
-				b, err := rv.Interface().(Marshaler).MarshalJSON()
+				bb, err := rv.Interface().(Marshaler).MarshalJSON()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				if len(b) == 0 {
-					return errUnexpectedEndOfJSON(
+				if len(bb) == 0 {
+					return nil, errUnexpectedEndOfJSON(
 						fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 						0,
 					)
 				}
 				var buf bytes.Buffer
-				if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-					return err
+				if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+					return nil, err
 				}
-				e.encodeBytes(buf.Bytes())
-				e.encodeByte(',')
+				b = append(b, buf.Bytes()...)
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadMarshalJSON:
@@ -1815,38 +1814,38 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				ptr += code.offset
 				v := e.ptrToInterface(code, ptr)
 				rv := reflect.ValueOf(v)
 				if rv.Type().Kind() == reflect.Interface && rv.IsNil() {
-					e.encodeNull()
+					b = encodeNull(b)
 					code = code.end.next
 					break
 				}
-				b, err := rv.Interface().(Marshaler).MarshalJSON()
+				bb, err := rv.Interface().(Marshaler).MarshalJSON()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				if len(b) == 0 {
-					return errUnexpectedEndOfJSON(
+				if len(bb) == 0 {
+					return nil, errUnexpectedEndOfJSON(
 						fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 						0,
 					)
 				}
 				var buf bytes.Buffer
-				if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-					return err
+				if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+					return nil, err
 				}
-				e.encodeBytes(buf.Bytes())
-				e.encodeByte(',')
+				b = append(b, buf.Bytes()...)
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadMarshalText:
 			p := load(ctxptr, code.idx)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 				break
 			}
@@ -1855,27 +1854,27 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadMarshalText:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
 				ptr += code.offset
 				v := e.ptrToInterface(code, ptr)
 				rv := reflect.ValueOf(v)
 				if rv.Type().Kind() == reflect.Interface && rv.IsNil() {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 					code = code.end
 					break
 				}
 				bytes, err := rv.Interface().(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadMarshalText:
@@ -1886,22 +1885,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				ptr += code.offset
 				v := e.ptrToInterface(code, ptr)
 				rv := reflect.ValueOf(v)
 				if rv.Type().Kind() == reflect.Interface && rv.IsNil() {
-					e.encodeNull()
-					e.encodeByte(',')
+					b = encodeNull(b)
+					b = encodeComma(b)
 					code = code.end.next
 					break
 				}
 				bytes, err := rv.Interface().(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadIndent:
@@ -1913,21 +1912,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else if code.next == code.end {
 				// not exists fields
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '}', ',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '}', ',', '\n')
 				code = code.end.next
 				store(ctxptr, code.idx, ptr)
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				code = code.next
 				store(ctxptr, code.idx, ptr)
 			}
@@ -1938,20 +1937,20 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
 				if code.op == opStructFieldPtrHeadIntIndent {
-					e.encodeIndent(code.indent)
-					e.encodeNull()
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent)
+					b = encodeNull(b)
+					b = encodeIndentComma(b)
 				} else {
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = append(b, '{', '}', ',', '\n')
 				}
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt(e.ptrToInt(ptr + code.offset))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt(b, e.ptrToInt(ptr+code.offset))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt8Indent:
@@ -1960,18 +1959,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadInt8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt8(e.ptrToInt8(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeIndentComma(b)
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt8(b, e.ptrToInt8(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt16Indent:
@@ -1980,17 +1979,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadInt16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt16(e.ptrToInt16(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt16(b, e.ptrToInt16(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt32Indent:
@@ -1999,18 +1998,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadInt32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt32(e.ptrToInt32(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt32(b, e.ptrToInt32(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadInt64Indent:
@@ -2019,18 +2018,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadInt64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt64(e.ptrToInt64(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt64(b, e.ptrToInt64(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadUintIndent:
@@ -2039,18 +2038,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadUintIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint(e.ptrToUint(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint(b, e.ptrToUint(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint8Indent:
@@ -2059,18 +2058,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadUint8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint8(e.ptrToUint8(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint8(b, e.ptrToUint8(ptr))
+				b = append(b, ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint16Indent:
@@ -2079,18 +2078,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadUint16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint16(e.ptrToUint16(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint16(b, e.ptrToUint16(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint32Indent:
@@ -2099,18 +2098,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadUint32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint32(e.ptrToUint32(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint32(b, e.ptrToUint32(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadUint64Indent:
@@ -2119,18 +2118,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadUint64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint64(e.ptrToUint64(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint64(b, e.ptrToUint64(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadFloat32Indent:
@@ -2139,18 +2138,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadFloat32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeFloat32(e.ptrToFloat32(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeFloat32(b, e.ptrToFloat32(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadFloat64Indent:
@@ -2159,22 +2158,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadFloat64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
 				v := e.ptrToFloat64(ptr)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeFloat64(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeFloat64(b, v)
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringIndent:
@@ -2183,18 +2182,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(e.ptrToString(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, e.ptrToString(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadBoolIndent:
@@ -2203,18 +2202,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadBoolIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeBool(e.ptrToBool(ptr))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeBool(b, e.ptrToBool(ptr))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadBytesIndent:
@@ -2223,21 +2222,20 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadBytesIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				s := base64.StdEncoding.EncodeToString(e.ptrToBytes(ptr))
-				e.encodeByte('"')
-				e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-				e.encodeByte('"')
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '"')
+				b = encodeBytes(b, *(*[]byte)(unsafe.Pointer(&s)))
+				b = append(b, '"', ',', '\n')
 				code = code.next
 			}
 		case opStructFieldPtrHeadOmitEmpty:
@@ -2249,16 +2247,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmpty:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				p := ptr + code.offset
 				if p == 0 || *(*uintptr)(*(*unsafe.Pointer)(unsafe.Pointer(&p))) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
+					b = e.encodeKey(b, code)
 					code = code.next
 					store(ctxptr, code.idx, p)
 				}
@@ -2278,7 +2276,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if p == 0 || *(*uintptr)(*(*unsafe.Pointer)(unsafe.Pointer(&p))) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
+					b = e.encodeKey(b, code)
 					code = code.next
 					store(ctxptr, code.idx, p)
 				}
@@ -2292,18 +2290,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToInt(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2322,9 +2320,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2337,18 +2335,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt8:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToInt8(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt8(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt8(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2367,9 +2365,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt8(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt8(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2382,18 +2380,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt16:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToInt16(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt16(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt16(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2412,9 +2410,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt16(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt16(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2427,18 +2425,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToInt32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2457,9 +2455,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2472,18 +2470,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToInt64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2502,9 +2500,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeInt64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeInt64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2517,18 +2515,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToUint(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2547,9 +2545,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2562,18 +2560,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint8:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToUint8(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint8(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint8(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2592,9 +2590,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint8(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint8(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2607,18 +2605,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint16:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToUint16(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint16(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint16(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2637,9 +2635,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint16(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint16(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2652,18 +2650,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToUint32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2682,9 +2680,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2697,18 +2695,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToUint64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2727,9 +2725,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeUint64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeUint64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2742,18 +2740,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyFloat32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToFloat32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeFloat32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeFloat32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2772,9 +2770,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeFloat32(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeFloat32(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2787,21 +2785,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyFloat64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToFloat64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
 					if math.IsInf(v, 0) || math.IsNaN(v) {
-						return errUnsupportedFloat(v)
+						return nil, errUnsupportedFloat(v)
 					}
-					e.encodeKey(code)
-					e.encodeFloat64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeFloat64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2821,11 +2819,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					code = code.nextField
 				} else {
 					if math.IsInf(v, 0) || math.IsNaN(v) {
-						return errUnsupportedFloat(v)
+						return nil, errUnsupportedFloat(v)
 					}
-					e.encodeKey(code)
-					e.encodeFloat64(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeFloat64(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2838,18 +2836,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyString:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToString(ptr + code.offset)
 				if v == "" {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeString(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = e.encodeString(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2868,9 +2866,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if v == "" {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeString(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = e.encodeString(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2883,18 +2881,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyBool:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToBool(ptr + code.offset)
 				if !v {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeBool(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeBool(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2913,9 +2911,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if !v {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeBool(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeBool(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2928,18 +2926,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyBytes:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToBytes(ptr + code.offset)
 				if len(v) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeByteSlice(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeByteSlice(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2958,9 +2956,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if len(v) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeKey(code)
-					e.encodeByteSlice(v)
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = encodeByteSlice(b, v)
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -2973,11 +2971,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyMarshalJSON:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				ptr += code.offset
 				p := e.ptrToUnsafePtr(ptr)
 				isPtr := code.typ.Kind() == reflect.Ptr
@@ -2985,16 +2983,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					code = code.nextField
 				} else {
 					v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
-					b, err := v.(Marshaler).MarshalJSON()
+					bb, err := v.(Marshaler).MarshalJSON()
 					if err != nil {
-						return &MarshalerError{
+						return nil, &MarshalerError{
 							Type: rtype2type(code.typ),
 							Err:  err,
 						}
 					}
-					if len(b) == 0 {
+					if len(bb) == 0 {
 						if isPtr {
-							return errUnexpectedEndOfJSON(
+							return nil, errUnexpectedEndOfJSON(
 								fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 								0,
 							)
@@ -3002,12 +3000,12 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 						code = code.nextField
 					} else {
 						var buf bytes.Buffer
-						if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-							return err
+						if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+							return nil, err
 						}
-						e.encodeKey(code)
-						e.encodeBytes(buf.Bytes())
-						e.encodeByte(',')
+						b = e.encodeKey(b, code)
+						b = append(b, buf.Bytes()...)
+						b = encodeComma(b)
 						code = code.next
 					}
 				}
@@ -3030,16 +3028,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					code = code.nextField
 				} else {
 					v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
-					b, err := v.(Marshaler).MarshalJSON()
+					bb, err := v.(Marshaler).MarshalJSON()
 					if err != nil {
-						return &MarshalerError{
+						return nil, &MarshalerError{
 							Type: rtype2type(code.typ),
 							Err:  err,
 						}
 					}
-					if len(b) == 0 {
+					if len(bb) == 0 {
 						if isPtr {
-							return errUnexpectedEndOfJSON(
+							return nil, errUnexpectedEndOfJSON(
 								fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 								0,
 							)
@@ -3047,12 +3045,12 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 						code = code.nextField
 					} else {
 						var buf bytes.Buffer
-						if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-							return err
+						if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+							return nil, err
 						}
-						e.encodeKey(code)
-						e.encodeBytes(buf.Bytes())
-						e.encodeByte(',')
+						b = e.encodeKey(b, code)
+						b = append(b, buf.Bytes()...)
+						b = encodeComma(b)
 						code = code.next
 					}
 				}
@@ -3066,11 +3064,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyMarshalText:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				ptr += code.offset
 				p := e.ptrToUnsafePtr(ptr)
 				isPtr := code.typ.Kind() == reflect.Ptr
@@ -3080,14 +3078,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
 					bytes, err := v.(encoding.TextMarshaler).MarshalText()
 					if err != nil {
-						return &MarshalerError{
+						return nil, &MarshalerError{
 							Type: rtype2type(code.typ),
 							Err:  err,
 						}
 					}
-					e.encodeKey(code)
-					e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -3111,14 +3109,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 					v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
 					bytes, err := v.(encoding.TextMarshaler).MarshalText()
 					if err != nil {
-						return &MarshalerError{
+						return nil, &MarshalerError{
 							Type: rtype2type(code.typ),
 							Err:  err,
 						}
 					}
-					e.encodeKey(code)
-					e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -3131,20 +3129,20 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				p := ptr + code.offset
 				if p == 0 || *(*uintptr)(*(*unsafe.Pointer)(unsafe.Pointer(&p))) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
 					code = code.next
 					store(ctxptr, code.idx, p)
 				}
@@ -3158,22 +3156,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyIntIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToInt(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeInt(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeInt(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3186,22 +3184,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToInt8(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeInt8(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeInt8(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3214,22 +3212,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToInt16(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeInt16(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeInt16(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3242,22 +3240,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToInt32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeInt32(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeInt32(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3270,22 +3268,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyInt64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToInt64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeInt64(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeInt64(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3298,22 +3296,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUintIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToUint(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeUint(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeUint(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3326,22 +3324,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToUint8(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeUint8(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeUint8(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3354,22 +3352,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToUint16(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeUint16(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeUint16(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3382,22 +3380,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToUint32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeUint32(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeUint32(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3410,22 +3408,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyUint64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToUint64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeUint64(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeUint64(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3438,22 +3436,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyFloat32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToFloat32(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeFloat32(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeFloat32(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3466,25 +3464,25 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyFloat64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToFloat64(ptr + code.offset)
 				if v == 0 {
 					code = code.nextField
 				} else {
 					if math.IsInf(v, 0) || math.IsNaN(v) {
-						return errUnsupportedFloat(v)
+						return nil, errUnsupportedFloat(v)
 					}
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeFloat64(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeFloat64(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3497,22 +3495,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyStringIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToString(ptr + code.offset)
 				if v == "" {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeString(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = e.encodeString(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3525,22 +3523,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyBoolIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToBool(ptr + code.offset)
 				if !v {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
-					e.encodeBool(v)
-					e.encodeBytes([]byte{',', '\n'})
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
+					b = encodeBool(b, v)
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3553,25 +3551,25 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadOmitEmptyBytesIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeBytes([]byte{'{', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = append(b, '{', '\n')
 				v := e.ptrToBytes(ptr + code.offset)
 				if len(v) == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent + 1)
-					e.encodeKey(code)
-					e.encodeByte(' ')
+					b = e.encodeIndent(b, code.indent+1)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
 					s := base64.StdEncoding.EncodeToString(v)
-					e.encodeByte('"')
-					e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-					e.encodeByte('"')
-					e.encodeBytes([]byte{',', '\n'})
+					b = append(b, '"')
+					b = encodeBytes(b, *(*[]byte)(unsafe.Pointer(&s)))
+					b = append(b, '"')
+					b = encodeIndentComma(b)
 					code = code.next
 				}
 			}
@@ -3584,13 +3582,13 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTag:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				p := ptr + code.offset
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				code = code.next
 				store(ctxptr, code.idx, p)
 			}
@@ -3605,7 +3603,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				code = code.next
 				store(ctxptr, code.idx, ptr+code.offset)
 			}
@@ -3618,14 +3616,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagInt:
@@ -3639,9 +3637,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt8:
@@ -3653,14 +3651,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt8:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt8(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt8(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagInt8:
@@ -3674,9 +3672,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt8(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt8(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt16:
@@ -3688,14 +3686,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt16:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt16(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt16(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagInt16:
@@ -3709,9 +3707,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt16(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt16(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt32:
@@ -3723,14 +3721,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagInt32:
@@ -3744,9 +3742,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt64:
@@ -3758,14 +3756,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt64(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt64(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagInt64:
@@ -3779,9 +3777,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToInt64(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt64(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint:
@@ -3793,14 +3791,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagUint:
@@ -3814,9 +3812,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint8:
@@ -3828,14 +3826,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint8:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint8(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint8(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagUint8:
@@ -3849,9 +3847,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint8(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint8(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint16:
@@ -3863,14 +3861,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint16:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint16(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint16(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagUint16:
@@ -3884,9 +3882,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint16(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint16(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint32:
@@ -3898,14 +3896,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagUint32:
@@ -3919,9 +3917,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint64:
@@ -3933,14 +3931,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint64(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint64(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagUint64:
@@ -3954,9 +3952,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToUint64(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint64(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagFloat32:
@@ -3968,14 +3966,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagFloat32:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToFloat32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToFloat32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagFloat32:
@@ -3989,9 +3987,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToFloat32(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToFloat32(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagFloat64:
@@ -4003,18 +4001,18 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagFloat64:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				v := e.ptrToFloat64(ptr + code.offset)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(v))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(v))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagFloat64:
@@ -4030,11 +4028,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			} else {
 				v := e.ptrToFloat64(ptr + code.offset)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(v))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(v))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagString:
@@ -4046,22 +4044,22 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagString:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
 				var buf bytes.Buffer
 				enc := NewEncoder(&buf)
 				s := e.ptrToString(ptr + code.offset)
 				if e.enabledHTMLEscape {
-					enc.encodeEscapedString(s)
+					enc.buf = encodeEscapedString(enc.buf, s)
 				} else {
-					enc.encodeNoEscapedString(s)
+					enc.buf = encodeNoEscapedString(enc.buf, s)
 				}
-				e.encodeString(string(enc.buf))
-				e.encodeByte(',')
+				b = e.encodeString(b, string(enc.buf))
+				b = encodeComma(b)
 				enc.release()
 				code = code.next
 			}
@@ -4076,9 +4074,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(strconv.Quote(e.ptrToString(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, strconv.Quote(e.ptrToString(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagBool:
@@ -4090,14 +4088,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagBool:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToBool(ptr + code.offset)))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToBool(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagBool:
@@ -4111,9 +4109,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeString(fmt.Sprint(e.ptrToBool(ptr + code.offset)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, fmt.Sprint(e.ptrToBool(ptr+code.offset)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagBytes:
@@ -4125,14 +4123,14 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagBytes:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
-				e.encodeKey(code)
-				e.encodeByteSlice(e.ptrToBytes(ptr + code.offset))
-				e.encodeByte(',')
+				b = append(b, '{')
+				b = e.encodeKey(b, code)
+				b = encodeByteSlice(b, e.ptrToBytes(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagBytes:
@@ -4146,9 +4144,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if ptr == 0 {
 				code = code.end.next
 			} else {
-				e.encodeKey(code)
-				e.encodeByteSlice(e.ptrToBytes(ptr + code.offset))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeByteSlice(b, e.ptrToBytes(ptr+code.offset))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagMarshalJSON:
@@ -4160,40 +4158,40 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagMarshalJSON:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				ptr += code.offset
 				p := e.ptrToUnsafePtr(ptr)
 				isPtr := code.typ.Kind() == reflect.Ptr
 				v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
-				b, err := v.(Marshaler).MarshalJSON()
+				bb, err := v.(Marshaler).MarshalJSON()
 				if err != nil {
-					return &MarshalerError{
+					return nil, &MarshalerError{
 						Type: rtype2type(code.typ),
 						Err:  err,
 					}
 				}
-				if len(b) == 0 {
+				if len(bb) == 0 {
 					if isPtr {
-						return errUnexpectedEndOfJSON(
+						return nil, errUnexpectedEndOfJSON(
 							fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 							0,
 						)
 					}
-					e.encodeKey(code)
-					e.encodeBytes([]byte{'"', '"'})
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = append(b, '"', '"')
+					b = encodeComma(b)
 					code = code.nextField
 				} else {
 					var buf bytes.Buffer
-					if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-						return err
+					if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+						return nil, err
 					}
-					e.encodeString(buf.String())
-					e.encodeByte(',')
+					b = e.encodeString(b, buf.String())
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -4212,32 +4210,32 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				p := e.ptrToUnsafePtr(ptr)
 				isPtr := code.typ.Kind() == reflect.Ptr
 				v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
-				b, err := v.(Marshaler).MarshalJSON()
+				bb, err := v.(Marshaler).MarshalJSON()
 				if err != nil {
-					return &MarshalerError{
+					return nil, &MarshalerError{
 						Type: rtype2type(code.typ),
 						Err:  err,
 					}
 				}
-				if len(b) == 0 {
+				if len(bb) == 0 {
 					if isPtr {
-						return errUnexpectedEndOfJSON(
+						return nil, errUnexpectedEndOfJSON(
 							fmt.Sprintf("error calling MarshalJSON for type %s", code.typ),
 							0,
 						)
 					}
-					e.encodeKey(code)
-					e.encodeBytes([]byte{'"', '"'})
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = append(b, '"', '"')
+					b = encodeComma(b)
 					code = code.nextField
 				} else {
 					var buf bytes.Buffer
-					if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-						return err
+					if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+						return nil, err
 					}
-					e.encodeKey(code)
-					e.encodeString(buf.String())
-					e.encodeByte(',')
+					b = e.encodeKey(b, code)
+					b = e.encodeString(b, buf.String())
+					b = encodeComma(b)
 					code = code.next
 				}
 			}
@@ -4250,24 +4248,24 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagMarshalText:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.end.next
 			} else {
-				e.encodeByte('{')
+				b = append(b, '{')
 				ptr += code.offset
 				p := e.ptrToUnsafePtr(ptr)
 				v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
 				bytes, err := v.(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return &MarshalerError{
+					return nil, &MarshalerError{
 						Type: rtype2type(code.typ),
 						Err:  err,
 					}
 				}
-				e.encodeKey(code)
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrAnonymousHeadStringTagMarshalText:
@@ -4286,11 +4284,11 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				v := *(*interface{})(unsafe.Pointer(&interfaceHeader{typ: code.typ, ptr: p}))
 				bytes, err := v.(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeKey(code)
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagIndent:
@@ -4302,16 +4300,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
+				b = append(b, '{', '\n')
 				p := ptr + code.offset
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				code = code.next
 				store(ctxptr, code.idx, p)
 			}
@@ -4324,17 +4322,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagIntIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToInt(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt8Indent:
@@ -4346,17 +4344,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToInt8(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt8(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt16Indent:
@@ -4368,17 +4366,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToInt16(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt16(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt32Indent:
@@ -4390,17 +4388,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToInt32(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt32(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagInt64Indent:
@@ -4412,17 +4410,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagInt64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToInt64(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToInt64(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUintIndent:
@@ -4434,17 +4432,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUintIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToUint(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint8Indent:
@@ -4456,17 +4454,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint8Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToUint8(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint8(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint16Indent:
@@ -4478,17 +4476,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint16Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToUint16(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint16(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint32Indent:
@@ -4500,17 +4498,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToUint32(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint32(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagUint64Indent:
@@ -4522,17 +4520,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagUint64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToUint64(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToUint64(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagFloat32Indent:
@@ -4544,17 +4542,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagFloat32Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToFloat32(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToFloat32(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagFloat64Indent:
@@ -4566,21 +4564,21 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagFloat64Indent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
+				b = append(b, '{', '\n')
 				v := e.ptrToFloat64(ptr + code.offset)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(v))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(v))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagStringIndent:
@@ -4592,25 +4590,25 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagStringIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				var buf bytes.Buffer
 				enc := NewEncoder(&buf)
 				s := e.ptrToString(ptr + code.offset)
 				if e.enabledHTMLEscape {
-					enc.encodeEscapedString(s)
+					enc.buf = encodeEscapedString(enc.buf, s)
 				} else {
-					enc.encodeNoEscapedString(s)
+					enc.buf = encodeNoEscapedString(enc.buf, s)
 				}
-				e.encodeString(string(enc.buf))
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeString(b, string(enc.buf))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagBoolIndent:
@@ -4622,17 +4620,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagBoolIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(fmt.Sprint(e.ptrToBool(ptr + code.offset)))
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, fmt.Sprint(e.ptrToBool(ptr+code.offset)))
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructFieldPtrHeadStringTagBytesIndent:
@@ -4644,538 +4642,538 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldHeadStringTagBytesIndent:
 			ptr := load(ctxptr, code.idx)
 			if ptr == 0 {
-				e.encodeIndent(code.indent)
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.end.next
 			} else {
-				e.encodeBytes([]byte{'{', '\n'})
-				e.encodeIndent(code.indent + 1)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = append(b, '{', '\n')
+				b = e.encodeIndent(b, code.indent+1)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				s := base64.StdEncoding.EncodeToString(
 					e.ptrToBytes(ptr + code.offset),
 				)
-				e.encodeByte('"')
-				e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-				e.encodeByte('"')
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '"')
+				b = encodeBytes(b, *(*[]byte)(unsafe.Pointer(&s)))
+				b = append(b, '"')
+				b = encodeIndentComma(b)
 				code = code.next
 			}
 		case opStructField:
 			if !code.anonymousKey {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 			}
 			ptr := load(ctxptr, code.headIdx) + code.offset
 			code = code.next
 			store(ctxptr, code.idx, ptr)
 		case opStructFieldPtrInt:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeInt(e.ptrToInt(p))
+				b = encodeInt(b, e.ptrToInt(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldInt:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeInt(e.ptrToInt(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeInt(b, e.ptrToInt(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrInt8:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeInt8(e.ptrToInt8(p))
+				b = encodeInt8(b, e.ptrToInt8(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldInt8:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeInt8(e.ptrToInt8(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeInt8(b, e.ptrToInt8(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrInt16:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeInt16(e.ptrToInt16(p))
+				b = encodeInt16(b, e.ptrToInt16(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldInt16:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeInt16(e.ptrToInt16(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeInt16(b, e.ptrToInt16(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrInt32:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeInt32(e.ptrToInt32(p))
+				b = encodeInt32(b, e.ptrToInt32(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldInt32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeInt32(e.ptrToInt32(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeInt32(b, e.ptrToInt32(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrInt64:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeInt64(e.ptrToInt64(p))
+				b = encodeInt64(b, e.ptrToInt64(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldInt64:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeInt64(e.ptrToInt64(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeInt64(b, e.ptrToInt64(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrUint:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeUint(e.ptrToUint(p))
+				b = encodeUint(b, e.ptrToUint(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldUint:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeUint(e.ptrToUint(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeUint(b, e.ptrToUint(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrUint8:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeUint8(e.ptrToUint8(p))
+				b = encodeUint8(b, e.ptrToUint8(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldUint8:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeUint8(e.ptrToUint8(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeUint8(b, e.ptrToUint8(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrUint16:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeUint16(e.ptrToUint16(p))
+				b = encodeUint16(b, e.ptrToUint16(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldUint16:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeUint16(e.ptrToUint16(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeUint16(b, e.ptrToUint16(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrUint32:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeUint32(e.ptrToUint32(p))
+				b = encodeUint32(b, e.ptrToUint32(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldUint32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeUint32(e.ptrToUint32(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeUint32(b, e.ptrToUint32(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrUint64:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeUint64(e.ptrToUint64(p))
+				b = encodeUint64(b, e.ptrToUint64(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldUint64:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeUint64(e.ptrToUint64(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeUint64(b, e.ptrToUint64(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrFloat32:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeFloat32(e.ptrToFloat32(p))
+				b = encodeFloat32(b, e.ptrToFloat32(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldFloat32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeFloat32(e.ptrToFloat32(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeFloat32(b, e.ptrToFloat32(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrFloat64:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
-				e.encodeByte(',')
+				b = encodeNull(b)
+				b = encodeComma(b)
 				code = code.next
 				break
 			}
 			v := e.ptrToFloat64(p)
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeFloat64(v)
-			e.encodeByte(',')
+			b = encodeFloat64(b, v)
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldFloat64:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			v := e.ptrToFloat64(ptr + code.offset)
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeFloat64(v)
-			e.encodeByte(',')
+			b = encodeFloat64(b, v)
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrString:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeString(e.ptrToString(p))
+				b = e.encodeString(b, e.ptrToString(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldString:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(e.ptrToString(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, e.ptrToString(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldPtrBool:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := e.ptrToPtr(ptr + code.offset)
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 			} else {
-				e.encodeBool(e.ptrToBool(p))
+				b = encodeBool(b, e.ptrToBool(p))
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldBool:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeBool(e.ptrToBool(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeBool(b, e.ptrToBool(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldBytes:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeByteSlice(e.ptrToBytes(ptr + code.offset))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeByteSlice(b, e.ptrToBytes(ptr+code.offset))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldMarshalJSON:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
 			var buf bytes.Buffer
-			if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-				return err
+			if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+				return nil, err
 			}
-			e.encodeBytes(buf.Bytes())
-			e.encodeByte(',')
+			b = append(b, buf.Bytes()...)
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldMarshalText:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
 			bytes, err := v.(encoding.TextMarshaler).MarshalText()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
-			e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-			e.encodeByte(',')
+			b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldArray:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldSlice:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldMap:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldMapLoad:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldStruct:
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldIntIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeInt(e.ptrToInt(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt(b, e.ptrToInt(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldInt8Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeInt8(e.ptrToInt8(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt8(b, e.ptrToInt8(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldInt16Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeInt16(e.ptrToInt16(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt16(b, e.ptrToInt16(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldInt32Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeInt32(e.ptrToInt32(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt32(b, e.ptrToInt32(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldInt64Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeInt64(e.ptrToInt64(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeInt64(b, e.ptrToInt64(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldUintIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeUint(e.ptrToUint(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint(b, e.ptrToUint(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldUint8Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeUint8(e.ptrToUint8(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint8(b, e.ptrToUint8(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldUint16Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeUint16(e.ptrToUint16(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint16(b, e.ptrToUint16(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldUint32Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeUint32(e.ptrToUint32(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint32(b, e.ptrToUint32(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldUint64Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeUint64(e.ptrToUint64(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeUint64(b, e.ptrToUint64(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldFloat32Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeFloat32(e.ptrToFloat32(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeFloat32(b, e.ptrToFloat32(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldFloat64Indent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToFloat64(ptr + code.offset)
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeFloat64(v)
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeFloat64(b, v)
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeString(e.ptrToString(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeString(b, e.ptrToString(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldBoolIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeBool(e.ptrToBool(ptr + code.offset))
-			e.encodeBytes([]byte{',', '\n'})
+			b = encodeBool(b, e.ptrToBool(ptr+code.offset))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldBytesIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			s := base64.StdEncoding.EncodeToString(e.ptrToBytes(ptr + code.offset))
-			e.encodeByte('"')
-			e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-			e.encodeByte('"')
-			e.encodeBytes([]byte{',', '\n'})
+			b = append(b, '"')
+			b = append(b, *(*[]byte)(unsafe.Pointer(&s))...)
+			b = append(b, '"')
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldMarshalJSONIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
 			var buf bytes.Buffer
-			if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-				return err
+			if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+				return nil, err
 			}
-			e.encodeBytes(buf.Bytes())
-			e.encodeBytes([]byte{',', '\n'})
+			b = append(b, buf.Bytes()...)
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldArrayIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			array := e.ptrToSlice(p)
 			if p == 0 || uintptr(array.data) == 0 {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.nextField
 			} else {
 				code = code.next
 			}
 		case opStructFieldSliceIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			slice := e.ptrToSlice(p)
 			if p == 0 || uintptr(slice.data) == 0 {
-				e.encodeNull()
-				e.encodeBytes([]byte{',', '\n'})
+				b = encodeNull(b)
+				b = encodeIndentComma(b)
 				code = code.nextField
 			} else {
 				code = code.next
 			}
 		case opStructFieldMapIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 				code = code.nextField
 			} else {
 				p = e.ptrToPtr(p)
 				mlen := maplen(e.ptrToUnsafePtr(p))
 				if mlen == 0 {
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = append(b, '{', '}', ',', '\n')
 					mapCode := code.next
 					code = mapCode.end.next
 				} else {
@@ -5183,19 +5181,19 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				}
 			}
 		case opStructFieldMapLoadIndent:
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			if p == 0 {
-				e.encodeNull()
+				b = encodeNull(b)
 				code = code.nextField
 			} else {
 				p = e.ptrToPtr(p)
 				mlen := maplen(e.ptrToUnsafePtr(p))
 				if mlen == 0 {
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = append(b, '{', '}', ',', '\n')
 					code = code.nextField
 				} else {
 					code = code.next
@@ -5204,17 +5202,17 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldStructIndent:
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			if p == 0 {
-				e.encodeBytes([]byte{'{', '}', ',', '\n'})
+				b = append(b, '{', '}', ',', '\n')
 				code = code.nextField
 			} else {
 				headCode := code.next
 				if headCode.next == headCode.end {
 					// not exists fields
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = append(b, '{', '}', ',', '\n')
 					code = code.nextField
 				} else {
 					code = code.next
@@ -5227,7 +5225,7 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 || **(**uintptr)(unsafe.Pointer(&p)) == 0 {
 				code = code.nextField
 			} else {
-				e.encodeKey(code)
+				b = e.encodeKey(b, code)
 				code = code.next
 				store(ctxptr, code.idx, p)
 			}
@@ -5235,99 +5233,99 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeInt(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt8:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt8(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeInt8(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt8(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt16:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt16(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeInt16(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt16(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt32:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt32(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeInt32(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt32(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt64:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt64(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeInt64(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeInt64(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeUint(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint8:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint8(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeUint8(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint8(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint16:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint16(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeUint16(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint16(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint32:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint32(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeUint32(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint32(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint64:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint64(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeUint64(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeUint64(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyFloat32:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToFloat32(ptr + code.offset)
 			if v != 0 {
-				e.encodeKey(code)
-				e.encodeFloat32(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeFloat32(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyFloat64:
@@ -5335,38 +5333,38 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			v := e.ptrToFloat64(ptr + code.offset)
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeKey(code)
-				e.encodeFloat64(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeFloat64(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyString:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToString(ptr + code.offset)
 			if v != "" {
-				e.encodeKey(code)
-				e.encodeString(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = e.encodeString(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyBool:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToBool(ptr + code.offset)
 			if v {
-				e.encodeKey(code)
-				e.encodeBool(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeBool(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyBytes:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToBytes(ptr + code.offset)
 			if len(v) > 0 {
-				e.encodeKey(code)
-				e.encodeByteSlice(v)
-				e.encodeByte(',')
+				b = e.encodeKey(b, code)
+				b = encodeByteSlice(b, v)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyMarshalJSON:
@@ -5374,16 +5372,16 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
 			if v != nil {
-				b, err := v.(Marshaler).MarshalJSON()
+				bb, err := v.(Marshaler).MarshalJSON()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
 				var buf bytes.Buffer
-				if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-					return err
+				if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+					return nil, err
 				}
-				e.encodeBytes(buf.Bytes())
-				e.encodeByte(',')
+				b = append(b, buf.Bytes()...)
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyMarshalText:
@@ -5393,10 +5391,10 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if v != nil {
 				bytes, err := v.(encoding.TextMarshaler).MarshalText()
 				if err != nil {
-					return errMarshaler(code, err)
+					return nil, errMarshaler(code, err)
 				}
-				e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-				e.encodeByte(',')
+				b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+				b = encodeComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyArray:
@@ -5449,9 +5447,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 || **(**uintptr)(unsafe.Pointer(&p)) == 0 {
 				code = code.nextField
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				code = code.next
 				store(ctxptr, code.idx, p)
 			}
@@ -5459,121 +5457,121 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt8Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt8(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt8(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt8(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt16Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt16(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt16(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt16(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt32Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt32(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt32(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt32(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyInt64Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToInt64(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeInt64(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeInt64(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUintIndent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint8Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint8(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint8(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint8(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint16Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint16(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint16(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint16(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint32Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint32(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint32(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint32(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyUint64Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToUint64(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeUint64(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeUint64(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyFloat32Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToFloat32(ptr + code.offset)
 			if v != 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeFloat32(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeFloat32(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyFloat64Indent:
@@ -5581,49 +5579,49 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			v := e.ptrToFloat64(ptr + code.offset)
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
-					return errUnsupportedFloat(v)
+					return nil, errUnsupportedFloat(v)
 				}
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeFloat64(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeFloat64(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyStringIndent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToString(ptr + code.offset)
 			if v != "" {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeString(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = e.encodeString(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyBoolIndent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToBool(ptr + code.offset)
 			if v {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
-				e.encodeBool(v)
-				e.encodeBytes([]byte{',', '\n'})
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
+				b = encodeBool(b, v)
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyBytesIndent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToBytes(ptr + code.offset)
 			if len(v) > 0 {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				s := base64.StdEncoding.EncodeToString(v)
-				e.encodeByte('"')
-				e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-				e.encodeByte('"')
-				e.encodeBytes([]byte{',', '\n'})
+				b = append(b, '"')
+				b = append(b, *(*[]byte)(unsafe.Pointer(&s))...)
+				b = append(b, '"')
+				b = encodeIndentComma(b)
 			}
 			code = code.next
 		case opStructFieldOmitEmptyArrayIndent:
@@ -5633,9 +5631,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 || uintptr(array.data) == 0 {
 				code = code.nextField
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				code = code.next
 			}
 		case opStructFieldOmitEmptySliceIndent:
@@ -5645,9 +5643,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 || uintptr(slice.data) == 0 {
 				code = code.nextField
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				code = code.next
 			}
 		case opStructFieldOmitEmptyMapIndent:
@@ -5660,9 +5658,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if mlen == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeKey(code)
-					e.encodeByte(' ')
+					b = e.encodeIndent(b, code.indent)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
 					code = code.next
 				}
 			}
@@ -5676,9 +5674,9 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 				if mlen == 0 {
 					code = code.nextField
 				} else {
-					e.encodeIndent(code.indent)
-					e.encodeKey(code)
-					e.encodeByte(' ')
+					b = e.encodeIndent(b, code.indent)
+					b = e.encodeKey(b, code)
+					b = append(b, ' ')
 					code = code.next
 				}
 			}
@@ -5688,13 +5686,13 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			if p == 0 {
 				code = code.nextField
 			} else {
-				e.encodeIndent(code.indent)
-				e.encodeKey(code)
-				e.encodeByte(' ')
+				b = e.encodeIndent(b, code.indent)
+				b = e.encodeKey(b, code)
+				b = append(b, ' ')
 				headCode := code.next
 				if headCode.next == headCode.end {
 					// not exists fields
-					e.encodeBytes([]byte{'{', '}', ',', '\n'})
+					b = append(b, '{', '}', ',', '\n')
 					code = code.nextField
 				} else {
 					code = code.next
@@ -5704,120 +5702,120 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 		case opStructFieldStringTag:
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
-			e.encodeKey(code)
+			b = e.encodeKey(b, code)
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldStringTagInt:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToInt(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagInt8:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToInt8(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt8(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagInt16:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToInt16(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt16(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagInt32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToInt32(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt32(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagInt64:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToInt64(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt64(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagUint:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToUint(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagUint8:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToUint8(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint8(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagUint16:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToUint16(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint16(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagUint32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToUint32(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint32(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagUint64:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToUint64(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint64(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagFloat32:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToFloat32(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToFloat32(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagFloat64:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToFloat64(ptr + code.offset)
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(v))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(v))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagString:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			var b bytes.Buffer
-			enc := NewEncoder(&b)
-			enc.encodeString(e.ptrToString(ptr + code.offset))
-			e.encodeString(string(enc.buf))
+			b = e.encodeKey(b, code)
+			var buf bytes.Buffer
+			enc := NewEncoder(&buf)
+			enc.buf = enc.encodeString(enc.buf, e.ptrToString(ptr+code.offset))
+			b = e.encodeString(b, string(enc.buf))
 			code = code.next
 		case opStructFieldStringTagBool:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeKey(code)
-			e.encodeString(fmt.Sprint(e.ptrToBool(ptr + code.offset)))
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = e.encodeString(b, fmt.Sprint(e.ptrToBool(ptr+code.offset)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagBytes:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToBytes(ptr + code.offset)
-			e.encodeKey(code)
-			e.encodeByteSlice(v)
-			e.encodeByte(',')
+			b = e.encodeKey(b, code)
+			b = encodeByteSlice(b, v)
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagMarshalJSON:
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
 			var buf bytes.Buffer
-			if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-				return err
+			if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+				return nil, err
 			}
-			e.encodeString(buf.String())
-			e.encodeByte(',')
+			b = e.encodeString(b, buf.String())
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagMarshalText:
 			ptr := load(ctxptr, code.headIdx)
@@ -5825,212 +5823,212 @@ func (e *Encoder) run(ctx *encodeRuntimeContext, code *opcode) error {
 			v := e.ptrToInterface(code, p)
 			bytes, err := v.(encoding.TextMarshaler).MarshalText()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
-			e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-			e.encodeByte(',')
+			b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+			b = encodeComma(b)
 			code = code.next
 		case opStructFieldStringTagIndent:
 			ptr := load(ctxptr, code.headIdx)
 			p := ptr + code.offset
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			code = code.next
 			store(ctxptr, code.idx, p)
 		case opStructFieldStringTagIntIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToInt(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagInt8Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToInt8(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt8(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagInt16Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToInt16(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt16(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagInt32Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToInt32(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt32(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagInt64Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToInt64(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToInt64(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagUintIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToUint(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagUint8Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToUint8(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint8(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagUint16Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToUint16(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint16(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagUint32Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToUint32(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint32(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagUint64Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToUint64(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToUint64(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagFloat32Indent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToFloat32(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToFloat32(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagFloat64Indent:
 			ptr := load(ctxptr, code.headIdx)
 			v := e.ptrToFloat64(ptr + code.offset)
 			if math.IsInf(v, 0) || math.IsNaN(v) {
-				return errUnsupportedFloat(v)
+				return nil, errUnsupportedFloat(v)
 			}
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(v))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(v))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagStringIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			var b bytes.Buffer
-			enc := NewEncoder(&b)
-			enc.encodeString(e.ptrToString(ptr + code.offset))
-			e.encodeString(string(enc.buf))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			var buf bytes.Buffer
+			enc := NewEncoder(&buf)
+			enc.buf = enc.encodeString(enc.buf, e.ptrToString(ptr+code.offset))
+			b = e.encodeString(b, string(enc.buf))
+			b = encodeIndentComma(b)
 			enc.release()
 			code = code.next
 		case opStructFieldStringTagBoolIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
-			e.encodeString(fmt.Sprint(e.ptrToBool(ptr + code.offset)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
+			b = e.encodeString(b, fmt.Sprint(e.ptrToBool(ptr+code.offset)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagBytesIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			s := base64.StdEncoding.EncodeToString(
 				e.ptrToBytes(ptr + code.offset),
 			)
-			e.encodeByte('"')
-			e.encodeBytes(*(*[]byte)(unsafe.Pointer(&s)))
-			e.encodeByte('"')
-			e.encodeBytes([]byte{',', '\n'})
+			b = append(b, '"')
+			b = append(b, *(*[]byte)(unsafe.Pointer(&s))...)
+			b = append(b, '"')
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagMarshalJSONIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
-			b, err := v.(Marshaler).MarshalJSON()
+			bb, err := v.(Marshaler).MarshalJSON()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
 			var buf bytes.Buffer
-			if err := compact(&buf, b, e.enabledHTMLEscape); err != nil {
-				return err
+			if err := compact(&buf, bb, e.enabledHTMLEscape); err != nil {
+				return nil, err
 			}
-			e.encodeString(buf.String())
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeString(b, buf.String())
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructFieldStringTagMarshalTextIndent:
 			ptr := load(ctxptr, code.headIdx)
-			e.encodeIndent(code.indent)
-			e.encodeKey(code)
-			e.encodeByte(' ')
+			b = e.encodeIndent(b, code.indent)
+			b = e.encodeKey(b, code)
+			b = append(b, ' ')
 			p := ptr + code.offset
 			v := e.ptrToInterface(code, p)
 			bytes, err := v.(encoding.TextMarshaler).MarshalText()
 			if err != nil {
-				return errMarshaler(code, err)
+				return nil, errMarshaler(code, err)
 			}
-			e.encodeString(*(*string)(unsafe.Pointer(&bytes)))
-			e.encodeBytes([]byte{',', '\n'})
+			b = e.encodeString(b, *(*string)(unsafe.Pointer(&bytes)))
+			b = encodeIndentComma(b)
 			code = code.next
 		case opStructEnd:
-			last := len(e.buf) - 1
-			if e.buf[last] == ',' {
-				e.buf[last] = '}'
+			last := len(b) - 1
+			if b[last] == ',' {
+				b[last] = '}'
 			} else {
-				e.encodeByte('}')
+				b = append(b, '}')
 			}
-			e.encodeByte(',')
+			b = encodeComma(b)
 			code = code.next
 		case opStructAnonymousEnd:
 			code = code.next
 		case opStructEndIndent:
-			last := len(e.buf) - 1
-			if e.buf[last] == '\n' {
+			last := len(b) - 1
+			if b[last] == '\n' {
 				// to remove ',' and '\n' characters
-				e.buf = e.buf[:len(e.buf)-2]
+				b = b[:len(b)-2]
 			}
-			e.encodeByte('\n')
-			e.encodeIndent(code.indent)
-			e.encodeByte('}')
-			e.encodeBytes([]byte{',', '\n'})
+			b = append(b, '\n')
+			b = e.encodeIndent(b, code.indent)
+			b = append(b, '}')
+			b = encodeIndentComma(b)
 			code = code.next
 		case opEnd:
 			goto END
 		}
 	}
 END:
-	return nil
+	return b, nil
 }
 
 func (e *Encoder) ptrToInt(p uintptr) int            { return **(**int)(unsafe.Pointer(&p)) }
diff --git a/json.go b/json.go
index 402f07d..0edabfc 100644
--- a/json.go
+++ b/json.go
@@ -393,7 +393,7 @@ func HTMLEscape(dst *bytes.Buffer, src []byte) {
 	}
 	enc := NewEncoder(dst)
 	enc.SetEscapeHTML(true)
-	enc.encode(v)
+	enc.buf, _ = enc.encode(v)
 	dst.Write(enc.buf[:len(enc.buf)-1]) // remove last ',' character
 }