migrate go version to 1.17 (#203)

* migrate go version to 1.17

* update contributing

1 files changed, 1664 insertions, 1601 deletions

diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
index b470adaf4..6e05155f1 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
@@ -7,13 +7,19 @@ import (
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/encoder"
+	"github.com/goccy/go-json/internal/runtime"
 )
 
-func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt encoder.Option) ([]byte, error) {
+func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
 	recursiveLevel := 0
 	ptrOffset := uintptr(0)
 	ctxptr := ctx.Ptr()
-	code := codeSet.Code
+	var code *encoder.Opcode
+	if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
+		code = codeSet.EscapeKeyCode
+	} else {
+		code = codeSet.NoescapeKeyCode
+	}
 
 	for {
 		switch code.Op {
@@ -26,62 +32,62 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpIntPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpInt:
-			b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code)
-			b = appendComma(b)
+			b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpUintPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpUint:
-			b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code)
-			b = appendComma(b)
+			b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpIntString:
 			b = append(b, '"')
-			b = appendInt(b, ptrToUint64(load(ctxptr, code.Idx)), code)
+			b = appendInt(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpUintString:
 			b = append(b, '"')
-			b = appendUint(b, ptrToUint64(load(ctxptr, code.Idx)), code)
+			b = appendUint(ctx, b, ptrToUint64(load(ctxptr, code.Idx)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpFloat32Ptr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpFloat32:
-			b = appendFloat32(b, ptrToFloat32(load(ctxptr, code.Idx)))
-			b = appendComma(b)
+			b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpFloat64Ptr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
@@ -92,73 +98,73 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
-			b = appendFloat64(b, v)
-			b = appendComma(b)
+			b = appendFloat64(ctx, b, v)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStringPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpString:
-			b = appendString(b, ptrToString(load(ctxptr, code.Idx)))
-			b = appendComma(b)
+			b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpBoolPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpBool:
-			b = appendBool(b, ptrToBool(load(ctxptr, code.Idx)))
-			b = appendComma(b)
+			b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpBytesPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpBytes:
-			b = appendByteSlice(b, ptrToBytes(load(ctxptr, code.Idx)))
-			b = appendComma(b)
+			b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpNumberPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
 			store(ctxptr, code.Idx, p)
 			fallthrough
 		case encoder.OpNumber:
-			bb, err := appendNumber(b, ptrToNumber(load(ctxptr, code.Idx)))
+			bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpInterfacePtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
@@ -167,38 +173,92 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpInterface:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
-			for _, seen := range ctx.SeenPtr {
-				if p == seen {
-					return nil, errUnsupportedValue(code, p)
+			if recursiveLevel > encoder.StartDetectingCyclesAfter {
+				for _, seen := range ctx.SeenPtr {
+					if p == seen {
+						return nil, errUnsupportedValue(code, p)
+					}
 				}
 			}
 			ctx.SeenPtr = append(ctx.SeenPtr, p)
-			iface := (*emptyInterface)(ptrToUnsafePtr(p))
-			if iface.ptr == nil {
-				b = appendNull(b)
-				b = appendComma(b)
+			var (
+				typ      *runtime.Type
+				ifacePtr unsafe.Pointer
+			)
+			up := ptrToUnsafePtr(p)
+			if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
+				iface := (*nonEmptyInterface)(up)
+				ifacePtr = iface.ptr
+				typ = iface.itab.typ
+			} else {
+				iface := (*emptyInterface)(up)
+				ifacePtr = iface.ptr
+				typ = iface.typ
+			}
+			if ifacePtr == nil {
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
-			bb, err := appendInterface(ctx, codeSet, opt, code, b, iface, ptrOffset)
+			ctx.KeepRefs = append(ctx.KeepRefs, up)
+			ifaceCodeSet, err := encoder.CompileToGetCodeSet(uintptr(unsafe.Pointer(typ)))
 			if err != nil {
 				return nil, err
 			}
-			ctxptr = ctx.Ptr()
+
+			totalLength := uintptr(code.Length) + 3
+			nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
+
+			var c *encoder.Opcode
+			if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
+				c = ifaceCodeSet.InterfaceEscapeKeyCode
+			} else {
+				c = ifaceCodeSet.InterfaceNoescapeKeyCode
+			}
+			curlen := uintptr(len(ctx.Ptrs))
+			offsetNum := ptrOffset / uintptrSize
+			oldOffset := ptrOffset
+			ptrOffset += totalLength * uintptrSize
+			oldBaseIndent := ctx.BaseIndent
+			indentDiffFromTop := c.Indent - 1
+			ctx.BaseIndent += code.Indent - indentDiffFromTop
+
+			newLen := offsetNum + totalLength + nextTotalLength
+			if curlen < newLen {
+				ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
+			}
+			ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
+
+			end := ifaceCodeSet.EndCode
+			store(ctxptr, c.Idx, uintptr(ifacePtr))
+			store(ctxptr, end.Idx, oldOffset)
+			store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
+			storeIndent(ctxptr, end, uintptr(oldBaseIndent))
+			code = c
+			recursiveLevel++
+		case encoder.OpInterfaceEnd:
+			recursiveLevel--
+
+			// restore ctxptr
+			offset := load(ctxptr, code.Idx)
+			restoreIndent(ctx, code, ctxptr)
 			ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
 
-			b = bb
-			code = code.Next
+			codePtr := load(ctxptr, code.ElemIdx)
+			code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
+			ctxptr = ctx.Ptr() + offset
+			ptrOffset = offset
 		case encoder.OpMarshalJSONPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
@@ -207,25 +267,25 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpMarshalJSON:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
-			if code.IsNilableType && code.Indirect {
+			if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
 				p = ptrToPtr(p)
 			}
 			bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpMarshalTextPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
@@ -235,24 +295,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
 				b = append(b, `""`...)
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
-			if code.IsNilableType && code.Indirect {
+			if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
 				p = ptrToPtr(p)
 			}
-			bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+			bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpSlicePtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
@@ -262,8 +322,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			p := load(ctxptr, code.Idx)
 			slice := ptrToSlice(p)
 			if p == 0 || slice.Data == nil {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
@@ -275,7 +335,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				code = code.Next
 				store(ctxptr, code.Idx, uintptr(slice.Data))
 			} else {
-				b = appendEmptyArray(b)
+				b = appendEmptyArray(ctx, b)
 				code = code.End.Next
 			}
 		case encoder.OpSliceElem:
@@ -285,8 +345,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			if idx < length {
 				b = appendArrayElemIndent(ctx, code, b)
 				store(ctxptr, code.ElemIdx, idx)
-				data := load(ctxptr, code.HeadIdx)
-				size := code.Size
+				data := load(ctxptr, code.Idx)
+				size := uintptr(code.Size)
 				code = code.Next
 				store(ctxptr, code.Idx, data+idx*size)
 			} else {
@@ -296,8 +356,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpArrayPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
@@ -306,8 +366,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpArray:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
@@ -317,17 +377,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				code = code.Next
 				store(ctxptr, code.Idx, p)
 			} else {
-				b = appendEmptyArray(b)
+				b = appendEmptyArray(ctx, b)
 				code = code.End.Next
 			}
 		case encoder.OpArrayElem:
 			idx := load(ctxptr, code.ElemIdx)
 			idx++
-			if idx < code.Length {
+			if idx < uintptr(code.Length) {
 				b = appendArrayElemIndent(ctx, code, b)
 				store(ctxptr, code.ElemIdx, idx)
-				p := load(ctxptr, code.HeadIdx)
-				size := code.Size
+				p := load(ctxptr, code.Idx)
+				size := uintptr(code.Size)
 				code = code.Next
 				store(ctxptr, code.Idx, p+idx*size)
 			} else {
@@ -337,8 +397,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpMapPtr:
 			p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
@@ -347,31 +407,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpMap:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.End.Next
 				break
 			}
 			uptr := ptrToUnsafePtr(p)
 			mlen := maplen(uptr)
 			if mlen <= 0 {
-				b = appendEmptyObject(b)
+				b = appendEmptyObject(ctx, b)
 				code = code.End.Next
 				break
 			}
-			b = appendStructHead(b)
+			b = appendStructHead(ctx, b)
 			iter := mapiterinit(code.Type, uptr)
 			ctx.KeepRefs = append(ctx.KeepRefs, iter)
 			store(ctxptr, code.ElemIdx, 0)
 			store(ctxptr, code.Length, uintptr(mlen))
 			store(ctxptr, code.MapIter, uintptr(iter))
-			if (opt & encoder.UnorderedMapOption) == 0 {
+			if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+				b = appendMapKeyIndent(ctx, code.Next, b)
+			} else {
 				mapCtx := encoder.NewMapContext(mlen)
 				mapCtx.Pos = append(mapCtx.Pos, len(b))
 				ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
 				store(ctxptr, code.End.MapPos, uintptr(unsafe.Pointer(mapCtx)))
-			} else {
-				b = appendMapKeyIndent(ctx, code.Next, b)
 			}
 			key := mapiterkey(iter)
 			store(ctxptr, code.Next.Idx, uintptr(key))
@@ -380,7 +440,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			idx := load(ctxptr, code.ElemIdx)
 			length := load(ctxptr, code.Length)
 			idx++
-			if (opt & encoder.UnorderedMapOption) != 0 {
+			if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
 				if idx < length {
 					b = appendMapKeyIndent(ctx, code, b)
 					store(ctxptr, code.ElemIdx, idx)
@@ -409,8 +469,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 			}
 		case encoder.OpMapValue:
-			if (opt & encoder.UnorderedMapOption) != 0 {
-				b = appendColon(b)
+			if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
+				b = appendColon(ctx, b)
 			} else {
 				ptr := load(ctxptr, code.End.MapPos)
 				mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(ptr))
@@ -479,7 +539,8 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			oldOffset := ptrOffset
 			ptrOffset += code.Jmp.CurLen * uintptrSize
 			oldBaseIndent := ctx.BaseIndent
-			ctx.BaseIndent += code.Indent - 1
+			indentDiffFromTop := c.Indent - 1
+			ctx.BaseIndent += code.Indent - indentDiffFromTop
 
 			newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
 			if curlen < newLen {
@@ -490,7 +551,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			store(ctxptr, c.Idx, ptr)
 			store(ctxptr, c.End.Next.Idx, oldOffset)
 			store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
-			storeIndent(ctxptr, c, uintptr(oldBaseIndent))
+			storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
 			code = c
 			recursiveLevel++
 		case encoder.OpRecursiveEnd:
@@ -508,9 +569,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHead:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -519,29 +580,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHead:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if !code.AnonymousKey && len(code.Key) > 0 {
-				b = appendStructKey(ctx, code, b)
+			if len(code.Key) > 0 {
+				if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
+					b = appendStructKey(ctx, code, b)
+				}
 			}
-			p += code.Offset
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructPtrHeadOmitEmpty:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -550,19 +613,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmpty:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && (code.Indirect || code.Next.Op == encoder.OpStructEnd) {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			p += code.Offset
-			if p == 0 || (ptrToPtr(p) == 0 && code.IsNextOpPtrType) {
+			p += uintptr(code.Offset)
+			if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
@@ -570,12 +633,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				store(ctxptr, code.Idx, p)
 			}
 		case encoder.OpStructPtrHeadInt:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -586,27 +649,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadInt:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
-			b = appendComma(b)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyInt:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -617,33 +680,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyInt:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, u64, code)
-				b = appendComma(b)
+				b = appendInt(ctx, b, u64, code)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadIntString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -654,29 +717,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadIntString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyIntString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -687,34 +750,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyIntString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, u64, code)
+				b = appendInt(ctx, b, u64, code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadIntPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -723,34 +786,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadIntPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyIntPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -759,32 +822,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyIntPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, ptrToUint64(p), code)
-				b = appendComma(b)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadIntPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -793,36 +856,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadIntPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -831,35 +894,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyIntPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadUint:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -870,27 +933,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadUint:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
-			b = appendComma(b)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyUint:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -901,33 +964,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyUint:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, u64, code)
-				b = appendComma(b)
+				b = appendUint(ctx, b, u64, code)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadUintString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -938,29 +1001,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadUintString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyUintString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -971,34 +1034,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyUintString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, u64, code)
+				b = appendUint(ctx, b, u64, code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadUintPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1007,34 +1070,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadUintPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyUintPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1043,32 +1106,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyUintPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, ptrToUint64(p), code)
-				b = appendComma(b)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadUintPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1077,36 +1140,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadUintPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1115,35 +1178,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyUintPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadFloat32:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1154,27 +1217,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadFloat32:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
-			b = appendComma(b)
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat32:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1185,32 +1248,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyFloat32:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToFloat32(p + code.Offset)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, v)
-				b = appendComma(b)
+				b = appendFloat32(ctx, b, v)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadFloat32String:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1221,29 +1284,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadFloat32String:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat32String:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1254,33 +1317,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyFloat32String:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToFloat32(p + code.Offset)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, v)
+				b = appendFloat32(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadFloat32Ptr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1289,34 +1352,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadFloat32Ptr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1325,32 +1388,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyFloat32Ptr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, ptrToFloat32(p))
-				b = appendComma(b)
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadFloat32PtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1359,36 +1422,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadFloat32PtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1397,35 +1460,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyFloat32PtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadFloat64:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1436,31 +1499,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadFloat64:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			v := ptrToFloat64(p + code.Offset)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendFloat64(b, v)
-			b = appendComma(b)
+			b = appendFloat64(ctx, b, v)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat64:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1471,17 +1534,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyFloat64:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToFloat64(p + code.Offset)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v == 0 {
 				code = code.NextField
 			} else {
@@ -1489,17 +1552,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 					return nil, errUnsupportedFloat(v)
 				}
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat64(b, v)
-				b = appendComma(b)
+				b = appendFloat64(ctx, b, v)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadFloat64String:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1510,33 +1573,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadFloat64String:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToFloat64(p + code.Offset)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat64(b, v)
+			b = appendFloat64(ctx, b, v)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat64String:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1547,17 +1610,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyFloat64String:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToFloat64(p + code.Offset)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v == 0 {
 				code = code.NextField
 			} else {
@@ -1566,17 +1629,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadFloat64Ptr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1585,38 +1648,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadFloat64Ptr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1625,19 +1688,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyFloat64Ptr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
@@ -1645,16 +1708,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
-				b = appendComma(b)
+				b = appendFloat64(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadFloat64PtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1663,40 +1726,40 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadFloat64PtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1705,19 +1768,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyFloat64PtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
@@ -1726,18 +1789,18 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1748,27 +1811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendString(b, ptrToString(p+code.Offset))
-			b = appendComma(b)
+			b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1779,32 +1842,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToString(p + code.Offset)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v == "" {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, v)
-				b = appendComma(b)
+				b = appendString(ctx, b, v)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadStringString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1815,27 +1878,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadStringString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendString(b, string(appendString([]byte{}, ptrToString(p+code.Offset))))
-			b = appendComma(b)
+			b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyStringString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -1846,31 +1909,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyStringString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToString(p + code.Offset)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v == "" {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, v)))
-				b = appendComma(b)
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadStringPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1879,34 +1942,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadStringPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, ptrToString(p))
+				b = appendString(ctx, b, ptrToString(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyStringPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1915,32 +1978,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyStringPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, ptrToString(p))
-				b = appendComma(b)
+				b = appendString(ctx, b, ptrToString(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadStringPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1949,34 +2012,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadStringPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -1985,33 +2048,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyStringPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
-				b = appendComma(b)
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadBool:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2022,27 +2085,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadBool:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendBool(b, ptrToBool(p+code.Offset))
-			b = appendComma(b)
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBool:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2053,32 +2116,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyBool:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToBool(p + code.Offset)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, v)
-				b = appendComma(b)
+				b = appendBool(ctx, b, v)
+				b = appendComma(ctx, b)
 				code = code.Next
 			} else {
 				code = code.NextField
 			}
 		case encoder.OpStructPtrHeadBoolString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2089,29 +2152,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadBoolString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendBool(b, ptrToBool(p+code.Offset))
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBoolString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2122,23 +2185,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyBoolString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToBool(p + code.Offset)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, v)
+				b = appendBool(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			} else {
 				code = code.NextField
@@ -2146,9 +2209,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadBoolPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2157,34 +2220,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadBoolPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2193,32 +2256,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyBoolPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, ptrToBool(p))
-				b = appendComma(b)
+				b = appendBool(ctx, b, ptrToBool(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadBoolPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2227,36 +2290,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadBoolPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2265,35 +2328,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyBoolPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadBytes:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2304,27 +2367,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadBytes:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendByteSlice(b, ptrToBytes(p+code.Offset))
-			b = appendComma(b)
+			b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBytes:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2335,31 +2398,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyBytes:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToBytes(p + code.Offset)
+			v := ptrToBytes(p + uintptr(code.Offset))
 			if len(v) == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, v)
-				b = appendComma(b)
+				b = appendByteSlice(ctx, b, v)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadBytesPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2368,34 +2431,34 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadBytesPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendByteSlice(b, ptrToBytes(p))
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2404,33 +2467,33 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyBytesPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, ptrToBytes(p))
-				b = appendComma(b)
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadNumber:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2441,30 +2504,30 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadNumber:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyNumber:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2475,35 +2538,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyNumber:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToNumber(p + code.Offset)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v == "" {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadNumberString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2514,32 +2577,32 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadNumberString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
 			b = append(bb, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyNumberString:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2550,36 +2613,36 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyNumberString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			v := ptrToNumber(p + code.Offset)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v == "" {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadNumberPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2588,38 +2651,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadNumberPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2628,35 +2691,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyNumberPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadNumberPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2665,39 +2728,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadNumberPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2706,38 +2769,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyNumberPtrString:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2748,27 +2811,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			p += code.Offset
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructPtrHeadOmitEmptyArray:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2779,27 +2842,27 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptyArray:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			p += code.Offset
+			p += uintptr(code.Offset)
 			b = appendStructKey(ctx, code, b)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructPtrHeadOmitEmptySlice:
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				p := load(ctxptr, code.Idx)
 				if p == 0 {
-					if !code.AnonymousHead {
-						b = appendNull(b)
-						b = appendComma(b)
+					if code.Flags&encoder.AnonymousHeadFlags == 0 {
+						b = appendNull(ctx, b)
+						b = appendComma(ctx, b)
 					}
 					code = code.End.Next
 					break
@@ -2810,17 +2873,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructHeadOmitEmptySlice:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			p += code.Offset
+			p += uintptr(code.Offset)
 			slice := ptrToSlice(p)
 			if slice.Len == 0 {
 				code = code.NextField
@@ -2832,9 +2895,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2843,24 +2906,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.NextField
 			} else {
 				code = code.Next
@@ -2869,9 +2932,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2880,19 +2943,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
 				code = code.NextField
@@ -2904,9 +2967,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadMap:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2915,29 +2978,29 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadMap:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if p != 0 && code.Indirect {
-				p = ptrToPtr(p + code.Offset)
+			if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				p = ptrToPtr(p + uintptr(code.Offset))
 			}
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructPtrHeadOmitEmptyMap:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2946,19 +3009,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMap:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if p != 0 && code.Indirect {
-				p = ptrToPtr(p + code.Offset)
+			if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				p = ptrToPtr(p + uintptr(code.Offset))
 			}
 			if maplen(ptrToUnsafePtr(p)) == 0 {
 				code = code.NextField
@@ -2970,9 +3033,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadMapPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -2981,31 +3044,31 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadMapPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.NextField
 				break
 			}
-			p = ptrToPtr(p + code.Offset)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.NextField
 			} else {
-				if code.Indirect {
+				if (code.Flags & encoder.IndirectFlags) != 0 {
 					p = ptrToNPtr(p, code.PtrNum)
 				}
 				code = code.Next
@@ -3014,9 +3077,9 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadOmitEmptyMapPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -3025,26 +3088,26 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMapPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			if p == 0 {
 				code = code.NextField
 				break
 			}
-			p = ptrToPtr(p + code.Offset)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			if p == 0 {
 				code = code.NextField
 			} else {
-				if code.Indirect {
+				if (code.Flags & encoder.IndirectFlags) != 0 {
 					p = ptrToNPtr(p, code.PtrNum)
 				}
 				b = appendStructKey(ctx, code, b)
@@ -3054,38 +3117,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 		case encoder.OpStructPtrHeadMarshalJSON:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
 			}
 			fallthrough
 		case encoder.OpStructHeadMarshalJSON:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.IsNilableType {
-				if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalJSON {
-					p = ptrToPtr(p + code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
+				if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
+					p = ptrToPtr(p + uintptr(code.Offset))
 				}
 			}
-			if p == 0 && code.Nilcheck {
-				b = appendNull(b)
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
+				b = appendNull(ctx, b)
 			} else {
 				bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
@@ -3093,42 +3156,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
 			}
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMarshalJSON:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.IsNilableType {
-				if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
-					p = ptrToPtr(p + code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
+				if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
+					p = ptrToPtr(p + uintptr(code.Offset))
 				}
 			}
 			iface := ptrToInterface(code, p)
-			if code.Nilcheck && encoder.IsNilForMarshaler(iface) {
+			if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
@@ -3137,15 +3200,15 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 					return nil, err
 				}
 				b = bb
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadMarshalJSONPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -3154,23 +3217,23 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadMarshalJSONPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
@@ -3178,14 +3241,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -3194,19 +3257,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			if p == 0 {
 				code = code.NextField
@@ -3217,103 +3280,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 					return nil, err
 				}
 				b = bb
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadMarshalText:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
 			}
 			fallthrough
 		case encoder.OpStructHeadMarshalText:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.IsNilableType {
-				if code.Indirect || code.Op == encoder.OpStructPtrHeadMarshalText {
-					p = ptrToPtr(p + code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
+				if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
+					p = ptrToPtr(p + uintptr(code.Offset))
 				}
 			}
-			if p == 0 && code.Nilcheck {
-				b = appendNull(b)
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyMarshalText:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
+			if (code.Flags & encoder.IndirectFlags) != 0 {
 				store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
 			}
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMarshalText:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
-			if code.IsNilableType {
-				if code.Indirect || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
-					p = ptrToPtr(p + code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
+				if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
+					p = ptrToPtr(p + uintptr(code.Offset))
 				}
 			}
-			if p == 0 && code.Nilcheck {
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructPtrHeadMarshalTextPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -3322,38 +3385,38 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadMarshalTextPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			b = appendStructKey(ctx, code, b)
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
 			p := load(ctxptr, code.Idx)
 			if p == 0 {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
@@ -3362,43 +3425,43 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			fallthrough
 		case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
 			p := load(ctxptr, code.Idx)
-			if p == 0 && code.Indirect {
-				if !code.AnonymousHead {
-					b = appendNull(b)
-					b = appendComma(b)
+			if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
+				if code.Flags&encoder.AnonymousHeadFlags == 0 {
+					b = appendNull(ctx, b)
+					b = appendComma(ctx, b)
 				}
 				code = code.End.Next
 				break
 			}
-			if code.Indirect {
-				p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			if (code.Flags & encoder.IndirectFlags) != 0 {
+				p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			}
-			if !code.AnonymousHead {
-				b = appendStructHead(b)
+			if code.Flags&encoder.AnonymousHeadFlags == 0 {
+				b = appendStructHead(ctx, b)
 			}
 			if p == 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 				code = code.Next
 			}
 		case encoder.OpStructField:
-			if !code.AnonymousKey {
+			if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
 				b = appendStructKey(ctx, code, b)
 			}
-			p := load(ctxptr, code.HeadIdx) + code.Offset
+			p := load(ctxptr, code.Idx) + uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmpty:
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
-			if ptrToPtr(p) == 0 && code.IsNextOpPtrType {
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
+			if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
@@ -3406,298 +3469,298 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				store(ctxptr, code.Idx, p)
 			}
 		case encoder.OpStructFieldInt:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
-			b = appendComma(b)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyInt:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, u64, code)
-				b = appendComma(b)
+				b = appendInt(ctx, b, u64, code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldIntString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyIntString:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, u64, code)
+				b = appendInt(ctx, b, u64, code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldIntPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyIntPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, ptrToUint64(p), code)
-				b = appendComma(b)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldIntPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyIntPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldUint:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
-			b = appendComma(b)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyUint:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, u64, code)
-				b = appendComma(b)
+				b = appendUint(ctx, b, u64, code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldUintString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyUintString:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, u64, code)
+				b = appendUint(ctx, b, u64, code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldUintPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyUintPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, ptrToUint64(p), code)
-				b = appendComma(b)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldUintPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyUintPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat32:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
-			b = appendComma(b)
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat32:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat32(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, v)
-				b = appendComma(b)
+				b = appendFloat32(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat32String:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat32String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat32(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, v)
+				b = appendFloat32(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat32Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat32Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, ptrToFloat32(p))
-				b = appendComma(b)
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat32PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat32PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat64:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			v := ptrToFloat64(p + code.Offset)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
-			b = appendFloat64(b, v)
-			b = appendComma(b)
+			b = appendFloat64(ctx, b, v)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat64:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat64(b, v)
-				b = appendComma(b)
+				b = appendFloat64(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat64String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat64(b, v)
+			b = appendFloat64(ctx, b, v)
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat64String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat64Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
-				b = appendComma(b)
+				b = appendNull(ctx, b)
+				b = appendComma(ctx, b)
 				code = code.Next
 				break
 			}
@@ -3705,42 +3768,42 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
-			b = appendFloat64(b, v)
-			b = appendComma(b)
+			b = appendFloat64(ctx, b, v)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat64Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
-				b = appendComma(b)
+				b = appendFloat64(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldFloat64PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
 				b = append(b, '"')
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyFloat64PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
@@ -3748,307 +3811,307 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendString(b, ptrToString(p+code.Offset))
-			b = appendComma(b)
+			b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToString(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, v)
-				b = appendComma(b)
+				b = appendString(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldStringString:
-			p := load(ctxptr, code.HeadIdx)
-			s := ptrToString(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			s := ptrToString(p + uintptr(code.Offset))
 			b = appendStructKey(ctx, code, b)
-			b = appendString(b, string(appendString([]byte{}, s)))
-			b = appendComma(b)
+			b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyStringString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToString(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, v)))
-				b = appendComma(b)
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldStringPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, ptrToString(p))
+				b = appendString(ctx, b, ptrToString(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyStringPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, ptrToString(p))
-				b = appendComma(b)
+				b = appendString(ctx, b, ptrToString(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldStringPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyStringPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
-				b = appendComma(b)
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBool:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendBool(b, ptrToBool(p+code.Offset))
-			b = appendComma(b)
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBool:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBool(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, v)
-				b = appendComma(b)
+				b = appendBool(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBoolString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendBool(b, ptrToBool(p+code.Offset))
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
 			b = append(b, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBoolString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBool(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, v)
+				b = appendBool(ctx, b, v)
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBoolPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBoolPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, ptrToBool(p))
-				b = appendComma(b)
+				b = appendBool(ctx, b, ptrToBool(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBoolPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBoolPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBytes:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendByteSlice(b, ptrToBytes(p+code.Offset))
-			b = appendComma(b)
+			b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBytes:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBytes(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBytes(p + uintptr(code.Offset))
 			if len(v) > 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, v)
-				b = appendComma(b)
+				b = appendByteSlice(ctx, b, v)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldBytesPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendByteSlice(b, ptrToBytes(p))
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyBytesPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, ptrToBytes(p))
-				b = appendComma(b)
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldNumber:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyNumber:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToNumber(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 			}
 			code = code.Next
 		case encoder.OpStructFieldNumberString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
 			b = append(bb, '"')
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyNumberString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToNumber(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldNumberPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyNumberPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 			}
 			code = code.Next
 		case encoder.OpStructFieldNumberPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			b = appendStructKey(ctx, code, b)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyNumberPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
 				b = append(bb, '"')
-				b = appendComma(b)
+				b = appendComma(ctx, b)
 			}
 			code = code.Next
 		case encoder.OpStructFieldMarshalJSON:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			p += code.Offset
-			if code.IsNilableType {
+			p += uintptr(code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
 				p = ptrToPtr(p)
 			}
-			if p == 0 && code.Nilcheck {
-				b = appendNull(b)
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
+				b = appendNull(ctx, b)
 			} else {
 				bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
@@ -4056,20 +4119,20 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyMarshalJSON:
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
-			if code.IsNilableType {
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
 				p = ptrToPtr(p)
 			}
-			if p == 0 && code.Nilcheck {
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
 				code = code.NextField
 				break
 			}
 			iface := ptrToInterface(code, p)
-			if code.Nilcheck && encoder.IsNilForMarshaler(iface) {
+			if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
 				code = code.NextField
 				break
 			}
@@ -4078,14 +4141,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpStructFieldMarshalJSONPtr:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
@@ -4093,103 +4156,103 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 			}
 			code = code.Next
 		case encoder.OpStructFieldMarshalText:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			p += code.Offset
-			if code.IsNilableType {
+			p += uintptr(code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
 				p = ptrToPtr(p)
 			}
-			if p == 0 && code.Nilcheck {
-				b = appendNull(b)
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyMarshalText:
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
-			if code.IsNilableType {
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
+			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
 				p = ptrToPtr(p)
 			}
-			if p == 0 && code.Nilcheck {
+			if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
 				code = code.NextField
 				break
 			}
 			b = appendStructKey(ctx, code, b)
-			bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+			bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 			if err != nil {
 				return nil, err
 			}
-			b = appendComma(bb)
+			b = appendComma(ctx, bb)
 			code = code.Next
 		case encoder.OpStructFieldMarshalTextPtr:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
 				b = bb
 			}
-			b = appendComma(b)
+			b = appendComma(ctx, b)
 			code = code.Next
 		case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendMarshalText(code, b, ptrToInterface(code, p))
+				bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
 				if err != nil {
 					return nil, err
 				}
-				b = appendComma(bb)
+				b = appendComma(ctx, bb)
 			}
 			code = code.Next
 		case encoder.OpStructFieldArray:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptyArray:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldArrayPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptyArrayPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				code = code.Next
@@ -4199,13 +4262,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 		case encoder.OpStructFieldSlice:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptySlice:
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
 			slice := ptrToSlice(p)
 			if slice.Len == 0 {
 				code = code.NextField
@@ -4216,13 +4279,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 		case encoder.OpStructFieldSlicePtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptySlicePtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				code = code.Next
@@ -4232,13 +4295,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 		case encoder.OpStructFieldMap:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToPtr(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptyMap:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToPtr(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
 				code = code.NextField
 			} else {
@@ -4248,16 +4311,16 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 		case encoder.OpStructFieldMapPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToPtr(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			if p != 0 {
 				p = ptrToNPtr(p, code.PtrNum)
 			}
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptyMapPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToPtr(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			p = ptrToPtr(p + uintptr(code.Offset))
 			if p != 0 {
 				p = ptrToNPtr(p, code.PtrNum)
 			}
@@ -4270,14 +4333,14 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 		case encoder.OpStructFieldStruct:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
 			code = code.Next
 			store(ctxptr, code.Idx, p)
 		case encoder.OpStructFieldOmitEmptyStruct:
-			p := load(ctxptr, code.HeadIdx)
-			p += code.Offset
-			if ptrToPtr(p) == 0 && code.IsNextOpPtrType {
+			p := load(ctxptr, code.Idx)
+			p += uintptr(code.Offset)
+			if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
 				code = code.NextField
 			} else {
 				b = appendStructKey(ctx, code, b)
@@ -4290,39 +4353,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			b = appendStructEndSkipLast(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndInt:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyInt:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, u64, code)
+				b = appendInt(ctx, b, u64, code)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndIntString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendInt(b, ptrToUint64(p+code.Offset), code)
+			b = appendInt(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyIntString:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, u64, code)
+				b = appendInt(ctx, b, u64, code)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4331,21 +4394,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndIntPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyIntPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4353,24 +4416,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndIntPtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyIntPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendInt(b, ptrToUint64(p), code)
+				b = appendInt(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4378,39 +4441,39 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndUint:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyUint:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, u64, code)
+				b = appendUint(ctx, b, u64, code)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndUintString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendUint(b, ptrToUint64(p+code.Offset), code)
+			b = appendUint(ctx, b, ptrToUint64(p+uintptr(code.Offset)), code)
 			b = append(b, '"')
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyUintString:
-			p := load(ctxptr, code.HeadIdx)
-			u64 := ptrToUint64(p + code.Offset)
-			v := u64 & code.Mask
+			p := load(ctxptr, code.Idx)
+			u64 := ptrToUint64(p + uintptr(code.Offset))
+			v := u64 & ((1 << code.NumBitSize) - 1)
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, u64, code)
+				b = appendUint(ctx, b, u64, code)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4419,21 +4482,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndUintPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyUintPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4441,24 +4504,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndUintPtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyUintPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendUint(b, ptrToUint64(p), code)
+				b = appendUint(ctx, b, ptrToUint64(p), code)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4466,37 +4529,37 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndFloat32:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat32:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat32(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, v)
+				b = appendFloat32(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndFloat32String:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat32(b, ptrToFloat32(p+code.Offset))
+			b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
 			b = append(b, '"')
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat32String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat32(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat32(p + uintptr(code.Offset))
 			if v != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, v)
+				b = appendFloat32(ctx, b, v)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4505,21 +4568,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndFloat32Ptr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat32Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4527,24 +4590,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndFloat32PtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat32PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat32(b, ptrToFloat32(p))
+				b = appendFloat32(ctx, b, ptrToFloat32(p))
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4552,51 +4615,51 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndFloat64:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
 			b = appendStructKey(ctx, code, b)
-			b = appendFloat64(b, v)
+			b = appendFloat64(ctx, b, v)
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat64:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
 				b = appendStructKey(ctx, code, b)
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndFloat64String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendFloat64(b, v)
+			b = appendFloat64(ctx, b, v)
 			b = append(b, '"')
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat64String:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToFloat64(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToFloat64(p + uintptr(code.Offset))
 			if v != 0 {
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4605,10 +4668,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndFloat64Ptr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 				b = appendStructEnd(ctx, code, b)
 				code = code.Next
 				break
@@ -4617,19 +4680,19 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			if math.IsInf(v, 0) || math.IsNaN(v) {
 				return nil, errUnsupportedFloat(v)
 			}
-			b = appendFloat64(b, v)
+			b = appendFloat64(ctx, b, v)
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat64Ptr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4637,24 +4700,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndFloat64PtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
 				v := ptrToFloat64(p)
 				if math.IsInf(v, 0) || math.IsNaN(v) {
 					return nil, errUnsupportedFloat(v)
 				}
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyFloat64PtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				v := ptrToFloat64(p)
@@ -4662,7 +4725,7 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 					return nil, errUnsupportedFloat(v)
 				}
 				b = append(b, '"')
-				b = appendFloat64(b, v)
+				b = appendFloat64(ctx, b, v)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4670,35 +4733,35 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendString(b, ptrToString(p+code.Offset))
+			b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToString(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, v)
+				b = appendString(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndStringString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			s := ptrToString(p + code.Offset)
-			b = appendString(b, string(appendString([]byte{}, s)))
+			s := ptrToString(p + uintptr(code.Offset))
+			b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyStringString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToString(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToString(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, v)))
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4706,21 +4769,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndStringPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, ptrToString(p))
+				b = appendString(ctx, b, ptrToString(p))
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyStringPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, ptrToString(p))
+				b = appendString(ctx, b, ptrToString(p))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4728,58 +4791,58 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndStringPtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyStringPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendString(b, string(appendString([]byte{}, ptrToString(p))))
+				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndBool:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendBool(b, ptrToBool(p+code.Offset))
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBool:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBool(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, v)
+				b = appendBool(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndBoolString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			b = appendBool(b, ptrToBool(p+code.Offset))
+			b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
 			b = append(b, '"')
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBoolString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBool(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBool(p + uintptr(code.Offset))
 			if v {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, v)
+				b = appendBool(ctx, b, v)
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4788,21 +4851,21 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndBoolPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBoolPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4810,24 +4873,24 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndBoolPtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBoolPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				b = appendBool(b, ptrToBool(p))
+				b = appendBool(ctx, b, ptrToBool(p))
 				b = append(b, '"')
 				b = appendStructEnd(ctx, code, b)
 			} else {
@@ -4835,17 +4898,17 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndBytes:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			b = appendByteSlice(b, ptrToBytes(p+code.Offset))
+			b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBytes:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToBytes(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToBytes(p + uintptr(code.Offset))
 			if len(v) > 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, v)
+				b = appendByteSlice(ctx, b, v)
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
@@ -4853,41 +4916,41 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndBytesPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				b = appendByteSlice(b, ptrToBytes(p))
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
 			}
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyBytesPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				b = appendByteSlice(b, ptrToBytes(p))
+				b = appendByteSlice(ctx, b, ptrToBytes(p))
 				b = appendStructEnd(ctx, code, b)
 			} else {
 				b = appendStructEndSkipLast(ctx, code, b)
 			}
 			code = code.Next
 		case encoder.OpStructEndNumber:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
 			b = appendStructEnd(ctx, code, bb)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyNumber:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToNumber(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
@@ -4897,10 +4960,10 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			}
 			code = code.Next
 		case encoder.OpStructEndNumberString:
-			p := load(ctxptr, code.HeadIdx)
+			p := load(ctxptr, code.Idx)
 			b = appendStructKey(ctx, code, b)
 			b = append(b, '"')
-			bb, err := appendNumber(b, ptrToNumber(p+code.Offset))
+			bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
 			if err != nil {
 				return nil, err
 			}
@@ -4908,12 +4971,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyNumberString:
-			p := load(ctxptr, code.HeadIdx)
-			v := ptrToNumber(p + code.Offset)
+			p := load(ctxptr, code.Idx)
+			v := ptrToNumber(p + uintptr(code.Offset))
 			if v != "" {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, v)
+				bb, err := appendNumber(ctx, b, v)
 				if err != nil {
 					return nil, err
 				}
@@ -4925,12 +4988,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndNumberPtr:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
@@ -4939,11 +5002,11 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyNumberPtr:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
@@ -4954,13 +5017,13 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			code = code.Next
 		case encoder.OpStructEndNumberPtrString:
 			b = appendStructKey(ctx, code, b)
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p == 0 {
-				b = appendNull(b)
+				b = appendNull(ctx, b)
 			} else {
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}
@@ -4969,12 +5032,12 @@ func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, opt
 			b = appendStructEnd(ctx, code, b)
 			code = code.Next
 		case encoder.OpStructEndOmitEmptyNumberPtrString:
-			p := load(ctxptr, code.HeadIdx)
-			p = ptrToNPtr(p+code.Offset, code.PtrNum)
+			p := load(ctxptr, code.Idx)
+			p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
 			if p != 0 {
 				b = appendStructKey(ctx, code, b)
 				b = append(b, '"')
-				bb, err := appendNumber(b, ptrToNumber(p))
+				bb, err := appendNumber(ctx, b, ptrToNumber(p))
 				if err != nil {
 					return nil, err
 				}