// Code generated by internal/cmd/generator. DO NOT EDIT.
package vm_indent

import (
	"unsafe"

	"github.com/goccy/go-json/internal/encoder"
)

func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
	ctxptr := ctx.Ptr()
	var code *encoder.Opcode
	if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
		code = codeSet.EscapeKeyCode
	} else {
		code = codeSet.NoescapeKeyCode
	}

	for {
		switch code.Op {
		default:
			return nil, errUnimplementedOp(code.Op)
		// The opcodes of a value of interface{} and of a map are first: the position of a case in the switch
		// changes the layout of the code of the VM, and these were the ones to suffer from it.
		case encoder.OpInterfacePtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpInterface:
			p := load(ctxptr, code.Idx)
			// An interface value which holds nothing is null: its first word, the type or the itab, is nil.
			// It is decided here, as a call costs more than the check: the fields of interface{} of a struct
			// are nil in many a value.
			if p == nil || *(*unsafe.Pointer)(p) == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			first, base, scalar, err := ctx.EnterInterface(code, p)
			if err != nil {
				return nil, err
			}
			if first == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			if scalar {
				bb, err := appendScalar(ctx, b, first, base)
				if err != nil {
					return nil, err
				}
				b = bb
				code = code.Next
				break
			}
			code = first
			ctxptr = base
		case encoder.OpInterfaceEnd:
			code, ctxptr = ctx.LeaveFrame(code)
		case encoder.OpStructFieldInterface:
			// The field of a value of interface{}: the key, and then what OpInterface does for the value. A field
			// of interface{} is nil in many a value, and it is null then, without a call. The cases are here, with
			// the ones of a value of interface{}, not with the other fields: there they cost the small structs 3%.
			p := unsafe.Add(load(ctxptr, code.Idx), code.Offset)
			b = appendStructKey(ctx, code, b)
			if *(*unsafe.Pointer)(p) == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			first, base, scalar, err := ctx.EnterInterface(code, p)
			if err != nil {
				return nil, err
			}
			if first == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			if scalar {
				bb, err := appendScalar(ctx, b, first, base)
				if err != nil {
					return nil, err
				}
				b = bb
				code = code.Next
				break
			}
			code = first
			ctxptr = base
		case encoder.OpStructFieldOmitEmptyInterface:
			p := unsafe.Add(load(ctxptr, code.Idx), code.Offset)
			if *(*unsafe.Pointer)(p) == nil {
				code = code.NextField
				break
			}
			b = appendStructKey(ctx, code, b)
			first, base, scalar, err := ctx.EnterInterface(code, p)
			if err != nil {
				return nil, err
			}
			if first == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			if scalar {
				bb, err := appendScalar(ctx, b, first, base)
				if err != nil {
					return nil, err
				}
				b = bb
				code = code.Next
				break
			}
			code = first
			ctxptr = base
		case encoder.OpMapPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpMap:
			p := load(ctxptr, code.Idx)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			// The entries are read from the map into the context first ( encoder.MapLayout ), and encoded from
			// there: in the order of the map, or sorted by their keys when they are strings. A sorted map whose
			// keys are not strings is encoded as it comes and its entries are put in the order of their encoded
			// keys at OpMapEnd.
			mapCtx := encoder.NewMapContext(ctx)
			if code.Flags&encoder.MapStringKeyFlags != 0 && (code.Map.ScalarValue || code.Map.InterfaceValue) && ctx.Option.Flag&encoder.UnorderedMapOption != 0 {
				// the entries are written as the map is read: all of them when the values are scalars, and the
				// ones which hold a scalar when the values are of interface{}, and the context gets the others.
				if encoder.MapLen(p) == 0 {
					encoder.ReleaseMapContext(ctx, mapCtx)
					b = appendEmptyObject(ctx, b)
					code = code.End.Next
					break
				}
				bb, err := appendMapAsRead(ctx, code, appendStructHead(ctx, b), p, mapCtx)
				if err != nil {
					return nil, err
				}
				b = bb
			} else if code.Map.Collect(p, mapCtx) == 0 {
				encoder.ReleaseMapContext(ctx, mapCtx)
				b = appendEmptyObject(ctx, b)
				code = code.End.Next
				break
			} else {
				b = appendStructHead(ctx, b)
				if (ctx.Option.Flag & encoder.UnorderedMapOption) == 0 {
					if code.Flags&encoder.MapStringKeyFlags != 0 {
						mapCtx.SortKeys()
						mapCtx.Sorted = true
						mapCtx.DirectEntries = code.Map.ScalarValue || code.Map.InterfaceValue
					} else {
						mapCtx.SortByEncodedKeys()
						mapCtx.First = len(b)
					}
				}
			}
			store(ctxptr, code.Idx, unsafe.Pointer(mapCtx))
			// the first entry is begun as the others are, by the header: it has the next opcode and the flags
			// of the key opcode.
			mapCtx.Idx = -1
			fallthrough
		case encoder.OpMapKey:
			// After an entry, or at the start with Idx -1: the next entry is begun, or the map is ended.
			// A key of a string is written here, and the value of the entry is given to the opcode of the
			// value: that saves the opcodes of the key and of the value for every entry. The key of another
			// kind is given to its opcode, which OpMapValue follows.
			mapCtx := (*encoder.MapContext)(load(ctxptr, code.Idx))
			byEncodedKeys := mapCtx.Slice.Items != nil
			idx := mapCtx.Idx
			if byEncodedKeys && idx >= 0 {
				mapCtx.Slice.Items[idx].Value = b[mapCtx.Start:]
			}
			idx++
			if mapCtx.DirectEntries && idx < mapCtx.Len {
				// the entries from here are written by one call, up to one whose value is left to its opcodes.
				bb, next, err := appendSortedMapEntries(ctx, code, b, mapCtx, idx)
				if err != nil {
					return nil, err
				}
				b, idx = bb, next
			}
			if idx == mapCtx.Len {
				if byEncodedKeys {
					code = code.End
				} else {
					b = appendObjectEnd(ctx, code, b)
					encoder.ReleaseMapContext(ctx, mapCtx)
					code = code.End.Next
				}
				break
			}
			mapCtx.Idx = idx
			if byEncodedKeys {
				mapCtx.Start = len(b)
			} else {
				b = appendMapKeyIndent(ctx, code, b)
			}
			if code.Flags&encoder.MapStringKeyFlags == 0 {
				store(ctxptr, code.Next.Idx, mapCtx.KeyAt(idx))
				code = code.Next
				break
			}
			if mapCtx.Sorted {
				idx = int(mapCtx.Order[idx])
			}
			b = appendString(ctx, b, mapCtx.Keys[idx])
			b = appendComma(ctx, b)
			b = appendColon(ctx, b)
			store(ctxptr, code.Next.Idx, mapCtx.ValueAt(idx))
			code = code.Next
		case encoder.OpMapValue:
			mapCtx := (*encoder.MapContext)(load(ctxptr, code.Idx))
			if mapCtx.Slice.Items != nil {
				mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:]
				mapCtx.Start = len(b)
			} else {
				b = appendColon(ctx, b)
			}
			store(ctxptr, code.Next.Idx, mapCtx.ValueAt(mapCtx.Idx))
			code = code.Next
		case encoder.OpMapEnd:
			// the entries of a sorted map whose keys are not strings, in the order of their encoded keys.
			mapCtx := (*encoder.MapContext)(load(ctxptr, code.Idx))
			mapCtx.Slice.Sort()
			buf := mapCtx.Buf
			for _, item := range mapCtx.Slice.Items {
				buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
			}
			buf = appendMapEnd(ctx, code, buf)
			b = b[:mapCtx.First]
			b = append(b, buf...)
			mapCtx.Buf = buf
			encoder.ReleaseMapContext(ctx, mapCtx)
			code = code.Next
		case encoder.OpPtr:
			p := load(ctxptr, code.Idx)
			code = code.Next
			store(ctxptr, code.Idx, ptrToPtr(p))
		case encoder.OpIntPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpInt:
			b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpUintPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpUint:
			b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
			b = appendComma(ctx, b)
			code = code.Next
		// The values as strings, for the keys of a map and for the string option of a field whose key is longer
		// than a chunk: such a field is encoded by the generic field opcode and the opcode of its value.
		case encoder.OpIntPtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpIntString:
			b = append(b, '"')
			b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpUintPtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpUintString:
			b = append(b, '"')
			b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpFloat32PtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpFloat32String:
			b = append(b, '"')
			bb, err := appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpFloat64PtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpFloat64String:
			v := ptrToFloat64(load(ctxptr, code.Idx))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = append(b, '"')
			b = appendFloat64(ctx, b, v)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpBoolPtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpBoolString:
			b = append(b, '"')
			b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStringPtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpStringString:
			b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(load(ctxptr, code.Idx)))))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpNumberPtrString:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpNumberString:
			b = append(b, '"')
			bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
			if err != nil {
				return nil, err
			}
			b = append(bb, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpFloat32Ptr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
				b = appendComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpFloat32:
			bb, err := appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpFloat64Ptr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpFloat64:
			v := ptrToFloat64(load(ctxptr, code.Idx))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStringPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpString:
			b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpBoolPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpBool:
			b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpBytesPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpBytes:
			b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpNumberPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpNumber:
			bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpMarshalJSONPtr:
			p := load(ctxptr, code.Idx)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
			fallthrough
		case encoder.OpMarshalJSON:
			p := load(ctxptr, code.Idx)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
				p = ptrToPtr(p)
			}
			bb, err := appendMarshalJSON(ctx, code, b, p)
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpMarshalTextPtr:
			p := load(ctxptr, code.Idx)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
			fallthrough
		case encoder.OpMarshalText:
			p := load(ctxptr, code.Idx)
			if p == nil {
				if (code.Flags & encoder.MapKeyFlags) != 0 {
					// the name of a key which is a nil pointer is "", as encoding/json names it
					b = appendComma(ctx, append(b, `""`...))
				} else {
					// a nil pointer value is null, as with encoding/json and as OpMarshalJSON writes it
					b = appendNullComma(ctx, b)
				}
				code = code.Next
				break
			}
			if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
				p = ptrToPtr(p)
			}
			bb, err := appendMarshalText(ctx, code, b, p)
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpSlicePtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpSlice:
			p := load(ctxptr, code.Idx)
			slice := ptrToSlice(p)
			if p == nil || slice.Data == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			storeInt(ctxptr, code.ElemIdx, 0)
			storeInt(ctxptr, code.Length, uintptr(slice.Len))
			store(ctxptr, code.Idx, slice.Data)
			if slice.Len > 0 {
				b = appendArrayHead(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, slice.Data)
			} else {
				b = appendEmptyArray(ctx, b)
				code = code.End.Next
			}
		case encoder.OpSliceElem:
			idx := loadInt(ctxptr, code.ElemIdx)
			length := loadInt(ctxptr, code.Length)
			idx++
			if idx < length {
				b = appendArrayElemIndent(ctx, code, b)
				storeInt(ctxptr, code.ElemIdx, idx)
				data := load(ctxptr, code.Idx)
				size := uintptr(code.Size)
				code = code.Next
				store(ctxptr, code.Idx, unsafe.Add(data, idx*size))
			} else {
				b = appendArrayEnd(ctx, code, b)
				code = code.End.Next
			}
		case encoder.OpArrayPtr:
			p := ptrToNPtr(load(ctxptr, code.Idx), code.PtrNum)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			store(ctxptr, code.Idx, p)
			fallthrough
		case encoder.OpArray:
			p := load(ctxptr, code.Idx)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.End.Next
				break
			}
			if code.Length > 0 {
				b = appendArrayHead(ctx, code, b)
				storeInt(ctxptr, code.ElemIdx, 0)
				code = code.Next
				store(ctxptr, code.Idx, p)
			} else {
				b = appendEmptyArray(ctx, b)
				code = code.End.Next
			}
		case encoder.OpArrayElem:
			idx := loadInt(ctxptr, code.ElemIdx)
			idx++
			if idx < uintptr(code.Length) {
				b = appendArrayElemIndent(ctx, code, b)
				storeInt(ctxptr, code.ElemIdx, idx)
				p := load(ctxptr, code.Idx)
				size := uintptr(code.Size)
				code = code.Next
				store(ctxptr, code.Idx, unsafe.Add(p, idx*size))
			} else {
				b = appendArrayEnd(ctx, code, b)
				code = code.End.Next
			}
		case encoder.OpRecursivePtr:
			p := load(ctxptr, code.Idx)
			if p == nil {
				code = code.Next
				break
			}
			store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
			fallthrough
		case encoder.OpRecursive:
			if code.Flags&encoder.TailRecursiveFlags != 0 {
				// a value of a list, the last field of a value of the same type: encoded in this frame, with
				// the braces of the value it is the field of closed at OpRecursiveEnd.
				p := load(ctxptr, code.Idx)
				if ctx.RecursiveLevel > encoder.StartDetectingCyclesAfter {
					if err := ctx.RecordSeen(code, p); err != nil {
						return nil, err
					}
				}
				first := code.Jmp.Code
				store(ctxptr, first.Idx, p)
				// the end of the struct is next, then OpRecursiveEnd, which has what the indent is deeper by.
				ctx.BaseIndent += code.Next.Next.Indent
				ctx.TailLevels++
				ctx.RecursiveLevel++
				code = first
				break
			}
			first, base, err := ctx.EnterRecursive(code, load(ctxptr, code.Idx))
			if err != nil {
				return nil, err
			}
			code = first
			ctxptr = base
		case encoder.OpRecursiveEnd:
			// the braces of the values of a list this value was the last field of, from the innermost.
			for ; ctx.TailLevels > 0; ctx.TailLevels-- {
				ctx.RecursiveLevel--
				if ctx.RecursiveLevel > encoder.StartDetectingCyclesAfter {
					ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
				}
				ctx.BaseIndent -= code.Indent
				b = appendStructEndSkipLast(ctx, code.Next, b)
			}
			code, ctxptr = ctx.LeaveFrame(code)
		case encoder.OpStructPtrHead:
			p := load(ctxptr, code.Idx)
			if p == nil {
				if code.Flags&encoder.AnonymousHeadFlags == 0 {
					b = appendNullComma(ctx, b)
				}
				code = code.End.Next
				break
			}
			store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
			fallthrough
		case encoder.OpStructHead:
			p := load(ctxptr, code.Idx)
			if p == nil && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
				if code.Flags&encoder.AnonymousHeadFlags == 0 {
					b = appendNullComma(ctx, b)
				}
				code = code.End.Next
				break
			}
			if code.Flags&encoder.AnonymousHeadFlags == 0 {
				b = appendStructHead(ctx, b)
			}
			code = code.Next
		case encoder.OpStructField:
			// the generic field: the value is encoded by its own opcode, and the key may be longer than a chunk.
			if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
				if len(code.Key) <= encoder.KeyChunkSize {
					b = appendStructKey(ctx, code, b)
				} else {
					b = appendLongStructKey(ctx, code, b)
				}
			}
			p := unsafe.Add(load(ctxptr, code.Idx), code.Offset)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmpty:
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			if encoder.IsEmptyField(code.EmptyKind, code.NumBitSize, p) || (code.ZeroKind != encoder.ZeroNever && encoder.IsZeroField(code, p)) {
				code = code.NextField
			} else {
				if len(code.Key) <= encoder.KeyChunkSize {
					b = appendStructKey(ctx, code, b)
				} else {
					b = appendLongStructKey(ctx, code, b)
				}
				code = code.Next
				store(ctxptr, code.Idx, p)
			}
		case encoder.OpStructFieldInt3:
			// Three fields of the kind in a row, then two: the fields after the first are encoded without
			// a dispatch, by falling through to the case of the field. The same for the other kinds below.
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldInt2:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldInt:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyInt:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldIntString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyIntString:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldIntPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendInt(ctx, b, p, code)
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyIntPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendInt(ctx, b, p, code)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldIntPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendInt(ctx, b, p, code)
				b = append(b, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyIntPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendInt(ctx, b, p, code)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldUint3:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldUint2:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldUint:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyUint:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldUintString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyUintString:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldUintPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendUint(ctx, b, p, code)
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyUintPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendUint(ctx, b, p, code)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldUintPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendUint(ctx, b, p, code)
				b = append(b, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyUintPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendUint(ctx, b, p, code)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat32:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			bb, err := appendFloat32(ctx, b, ptrToFloat32(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat32:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat32(unsafe.Add(p, code.Offset))
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				bb, err := appendFloat32(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = bb
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat32String:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			bb, err := appendFloat32(ctx, b, ptrToFloat32(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat32String:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat32(unsafe.Add(p, code.Offset))
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat32Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat32Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat32PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat32PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat643:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldFloat642:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldFloat64:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat64:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if v != 0 {
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendStructKey(ctx, code, b)
				b = appendFloat64(ctx, b, v)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat64String:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendFloat64(ctx, b, v)
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat64String:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if v != 0 {
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat64Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNullComma(ctx, b)
				code = code.Next
				break
			}
			v := ptrToFloat64(p)
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat64Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendFloat64(ctx, b, v)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldFloat64PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = append(b, '"')
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyFloat64PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldString3:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendString(ctx, b, ptrToString(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldString2:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendString(ctx, b, ptrToString(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendString(ctx, b, ptrToString(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyString:
			p := load(ctxptr, code.Idx)
			v := ptrToString(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, v)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldStringString:
			p := load(ctxptr, code.Idx)
			s := ptrToString(unsafe.Add(p, code.Offset))
			b = appendStructKey(ctx, code, b)
			b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyStringString:
			p := load(ctxptr, code.Idx)
			v := ptrToString(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldStringPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendString(ctx, b, ptrToString(p))
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyStringPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, ptrToString(p))
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldStringPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyStringPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBool3:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldBool2:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
			fallthrough
		case encoder.OpStructFieldBool:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBool:
			p := load(ctxptr, code.Idx)
			v := ptrToBool(unsafe.Add(p, code.Offset))
			if v {
				b = appendStructKey(ctx, code, b)
				b = appendBool(ctx, b, v)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBoolString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = append(b, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBoolString:
			p := load(ctxptr, code.Idx)
			v := ptrToBool(unsafe.Add(p, code.Offset))
			if v {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendBool(ctx, b, v)
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBoolPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendBool(ctx, b, ptrToBool(p))
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBoolPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendBool(ctx, b, ptrToBool(p))
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBoolPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendBool(ctx, b, ptrToBool(p))
				b = append(b, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBoolPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendBool(ctx, b, ptrToBool(p))
				b = append(b, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBytes:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendByteSlice(ctx, b, ptrToBytes(unsafe.Add(p, code.Offset)))
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBytes:
			p := load(ctxptr, code.Idx)
			v := ptrToBytes(unsafe.Add(p, code.Offset))
			if len(v) > 0 {
				b = appendStructKey(ctx, code, b)
				b = appendByteSlice(ctx, b, v)
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldBytesPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendByteSlice(ctx, b, ptrToBytes(p))
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyBytesPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendByteSlice(ctx, b, ptrToBytes(p))
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldNumber:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			bb, err := appendNumber(ctx, b, ptrToNumber(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyNumber:
			p := load(ctxptr, code.Idx)
			v := ptrToNumber(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				bb, err := appendNumber(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = appendComma(ctx, bb)
			}
			code = code.Next
		case encoder.OpStructFieldNumberString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			bb, err := appendNumber(ctx, b, ptrToNumber(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = append(bb, '"')
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyNumberString:
			p := load(ctxptr, code.Idx)
			v := ptrToNumber(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldNumberPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyNumberPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = appendComma(ctx, bb)
			}
			code = code.Next
		case encoder.OpStructFieldNumberPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			b = appendStructKey(ctx, code, b)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyNumberPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
				b = appendComma(ctx, b)
			}
			code = code.Next
		case encoder.OpStructFieldMarshalJSON:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			p = unsafe.Add(p, code.Offset)
			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
				p = ptrToPtr(p)
			}
			if p == nil && (code.Flags&encoder.NilCheckFlags) != 0 {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendMarshalJSON(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyMarshalJSON:
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
				p = ptrToPtr(p)
			}
			if p == nil && (code.Flags&encoder.NilCheckFlags) != 0 {
				code = code.NextField
				break
			}
			iface := ptrToInterface(code, p)
			if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
				code = code.NextField
				break
			}
			b = appendStructKey(ctx, code, b)
			bb, err := appendMarshalJSON(ctx, code, b, p)
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpStructFieldMarshalJSONPtr:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendMarshalJSON(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendMarshalJSON(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = appendComma(ctx, bb)
			}
			code = code.Next
		case encoder.OpStructFieldMarshalText:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			p = unsafe.Add(p, code.Offset)
			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
				p = ptrToPtr(p)
			}
			if p == nil && (code.Flags&encoder.NilCheckFlags) != 0 {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendMarshalText(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyMarshalText:
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
				p = ptrToPtr(p)
			}
			if p == nil && (code.Flags&encoder.NilCheckFlags) != 0 {
				code = code.NextField
				break
			}
			iface := ptrToInterface(code, p)
			if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
				code = code.NextField
				break
			}
			b = appendStructKey(ctx, code, b)
			bb, err := appendMarshalText(ctx, code, b, p)
			if err != nil {
				return nil, err
			}
			b = appendComma(ctx, bb)
			code = code.Next
		case encoder.OpStructFieldMarshalTextPtr:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendMarshalText(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendComma(ctx, b)
			code = code.Next
		case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendMarshalText(ctx, code, b, p)
				if err != nil {
					return nil, err
				}
				b = appendComma(ctx, bb)
			}
			code = code.Next
		case encoder.OpStructFieldArray:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptyArray:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldArrayPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptyArrayPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			} else {
				code = code.NextField
			}
		case encoder.OpStructFieldSlice:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptySlice:
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			slice := ptrToSlice(p)
			if slice.Len == 0 {
				code = code.NextField
			} else {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			}
		case encoder.OpStructFieldSlicePtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptySlicePtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			} else {
				code = code.NextField
			}
		case encoder.OpStructFieldMap:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToPtr(unsafe.Add(p, code.Offset))
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptyMap:
			p := load(ctxptr, code.Idx)
			p = ptrToPtr(unsafe.Add(p, code.Offset))
			if p == nil || encoder.MapLen(p) == 0 {
				code = code.NextField
			} else {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			}
		case encoder.OpStructFieldMapPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToPtr(unsafe.Add(p, code.Offset))
			if p != nil {
				p = ptrToNPtr(p, code.PtrNum)
			}
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptyMapPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToPtr(unsafe.Add(p, code.Offset))
			if p != nil {
				p = ptrToNPtr(p, code.PtrNum)
			}
			if p != nil {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			} else {
				code = code.NextField
			}
		case encoder.OpStructFieldStruct:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			code = code.Next
			store(ctxptr, code.Idx, p)
		case encoder.OpStructFieldOmitEmptyStruct:
			p := load(ctxptr, code.Idx)
			p = unsafe.Add(p, code.Offset)
			if ptrToPtr(p) == nil && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
				code = code.NextField
			} else {
				b = appendStructKey(ctx, code, b)
				code = code.Next
				store(ctxptr, code.Idx, p)
			}
		case encoder.OpStructEnd:
			b = appendStructEndSkipLast(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndInt:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyInt:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndIntString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
			b = append(b, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyIntString:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendInt(ctx, b, unsafe.Add(p, code.Offset), code)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndIntPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendInt(ctx, b, p, code)
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyIntPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendInt(ctx, b, p, code)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndIntPtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendInt(ctx, b, p, code)
				b = append(b, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyIntPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendInt(ctx, b, p, code)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndUint:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyUint:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndUintString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
			b = append(b, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyUintString:
			p := load(ctxptr, code.Idx)
			u64 := ptrToUint64(unsafe.Add(p, code.Offset), code.NumBitSize)
			v := u64 & ((1 << code.NumBitSize) - 1)
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendUint(ctx, b, unsafe.Add(p, code.Offset), code)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndUintPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendUint(ctx, b, p, code)
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyUintPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendUint(ctx, b, p, code)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndUintPtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendUint(ctx, b, p, code)
				b = append(b, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyUintPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendUint(ctx, b, p, code)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat32:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			bb, err := appendFloat32(ctx, b, ptrToFloat32(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat32:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat32(unsafe.Add(p, code.Offset))
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				bb, err := appendFloat32(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = bb
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat32String:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			bb, err := appendFloat32(ctx, b, ptrToFloat32(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = bb
			b = append(b, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat32String:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat32(unsafe.Add(p, code.Offset))
			if v != 0 {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat32Ptr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat32Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat32PtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat32PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendFloat32(ctx, b, ptrToFloat32(p))
				if err != nil {
					return nil, err
				}
				b = bb
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat64:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendStructKey(ctx, code, b)
			b = appendFloat64(ctx, b, v)
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat64:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if v != 0 {
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendStructKey(ctx, code, b)
				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.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendFloat64(ctx, b, v)
			b = append(b, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat64String:
			p := load(ctxptr, code.Idx)
			v := ptrToFloat64(unsafe.Add(p, code.Offset))
			if v != 0 {
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat64Ptr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
				b = appendStructEnd(ctx, code, b)
				code = code.Next
				break
			}
			v := ptrToFloat64(p)
			if isInfOrNaN(v) {
				return nil, errUnsupportedFloat(v)
			}
			b = appendFloat64(ctx, b, v)
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat64Ptr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendFloat64(ctx, b, v)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndFloat64PtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyFloat64PtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				v := ptrToFloat64(p)
				if isInfOrNaN(v) {
					return nil, errUnsupportedFloat(v)
				}
				b = append(b, '"')
				b = appendFloat64(ctx, b, v)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendString(ctx, b, ptrToString(unsafe.Add(p, code.Offset)))
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyString:
			p := load(ctxptr, code.Idx)
			v := ptrToString(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				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.Idx)
			b = appendStructKey(ctx, code, b)
			s := ptrToString(unsafe.Add(p, 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.Idx)
			v := ptrToString(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndStringPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendString(ctx, b, ptrToString(p))
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyStringPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendString(ctx, b, ptrToString(p))
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndStringPtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				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.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				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.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBool:
			p := load(ctxptr, code.Idx)
			v := ptrToBool(unsafe.Add(p, code.Offset))
			if v {
				b = appendStructKey(ctx, code, b)
				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.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			b = appendBool(ctx, b, ptrToBool(unsafe.Add(p, code.Offset)))
			b = append(b, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBoolString:
			p := load(ctxptr, code.Idx)
			v := ptrToBool(unsafe.Add(p, code.Offset))
			if v {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendBool(ctx, b, v)
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndBoolPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendBool(ctx, b, ptrToBool(p))
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBoolPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = appendBool(ctx, b, ptrToBool(p))
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndBoolPtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				b = appendBool(ctx, b, ptrToBool(p))
				b = append(b, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBoolPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				b = appendBool(ctx, b, ptrToBool(p))
				b = append(b, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndBytes:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = appendByteSlice(ctx, b, ptrToBytes(unsafe.Add(p, code.Offset)))
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBytes:
			p := load(ctxptr, code.Idx)
			v := ptrToBytes(unsafe.Add(p, code.Offset))
			if len(v) > 0 {
				b = appendStructKey(ctx, code, b)
				b = appendByteSlice(ctx, b, v)
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndBytesPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = appendByteSlice(ctx, b, ptrToBytes(p))
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyBytesPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				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.Idx)
			b = appendStructKey(ctx, code, b)
			bb, err := appendNumber(ctx, b, ptrToNumber(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = appendStructEnd(ctx, code, bb)
			code = code.Next
		case encoder.OpStructEndOmitEmptyNumber:
			p := load(ctxptr, code.Idx)
			v := ptrToNumber(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				bb, err := appendNumber(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = appendStructEnd(ctx, code, bb)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndNumberString:
			p := load(ctxptr, code.Idx)
			b = appendStructKey(ctx, code, b)
			b = append(b, '"')
			bb, err := appendNumber(ctx, b, ptrToNumber(unsafe.Add(p, code.Offset)))
			if err != nil {
				return nil, err
			}
			b = append(bb, '"')
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyNumberString:
			p := load(ctxptr, code.Idx)
			v := ptrToNumber(unsafe.Add(p, code.Offset))
			if v != "" {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, v)
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndNumberPtr:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = bb
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyNumberPtr:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = appendStructEnd(ctx, code, bb)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpStructEndNumberPtrString:
			b = appendStructKey(ctx, code, b)
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p == nil {
				b = appendNull(ctx, b)
			} else {
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
			}
			b = appendStructEnd(ctx, code, b)
			code = code.Next
		case encoder.OpStructEndOmitEmptyNumberPtrString:
			p := load(ctxptr, code.Idx)
			p = ptrToNPtr(unsafe.Add(p, code.Offset), code.PtrNum)
			if p != nil {
				b = appendStructKey(ctx, code, b)
				b = append(b, '"')
				bb, err := appendNumber(ctx, b, ptrToNumber(p))
				if err != nil {
					return nil, err
				}
				b = append(bb, '"')
				b = appendStructEnd(ctx, code, b)
			} else {
				b = appendStructEndSkipLast(ctx, code, b)
			}
			code = code.Next
		case encoder.OpEnd:
			goto END
		}
	}
END:
	return b, nil
}

// appendMapAsRead writes the entries of the map at p, whose keys are of a string kind, as the map is read: the
// map is not sorted, so the order of its entries is not specified, and an entry written here costs neither a
// copy to the context nor the opcodes of an entry. When the values are written by one opcode of a scalar,
// every entry is written. When the values are of interface{}, the ones which hold a scalar or nothing are
// written, and the others are given to the context, to be encoded by the opcodes of their values from
// OpMapKey on: they come after the scalars, which are most of the entries of a JSON object held by a value of
// interface{}.
//
//go:noinline
func appendMapAsRead(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, p unsafe.Pointer, mapCtx *encoder.MapContext) ([]byte, error) {
	code.Map.Reset(mapCtx)
	if code.Map.ScalarValue {
		mapCtx.Len = 0
		return mapScalarValueWriters[code.Map.ValueWords](ctx, code, b, p)
	}
	for k, v := range *(*map[string]any)(unsafe.Pointer(&p)) {
		iface := (*emptyInterface)(unsafe.Pointer(&v))
		var scalar *encoder.Opcode
		// A value of interface{} which holds nothing is null. What holds a value whose data word is nil, such
		// as a nil pointer, is left to OpInterface, which knows what is null and what is not.
		if iface.typ != nil && iface.ptr != nil {
			codeSet := ctx.RecentCodeSet(uintptr(iface.typ))
			if codeSet == nil {
				var err error
				codeSet, err = encoder.CompileToGetCodeSet(ctx, uintptr(iface.typ))
				if err != nil {
					return nil, err
				}
			}
			scalar = codeSet.Scalar
		}
		if iface.typ != nil && scalar == nil {
			mapCtx.Keys = append(mapCtx.Keys, k)
			mapCtx.Values = append(mapCtx.Values, unsafe.Slice((*byte)(unsafe.Pointer(&v)), unsafe.Sizeof(v))...)
			continue
		}
		b = appendMapKey(ctx, code, b, k)
		if scalar == nil {
			b = appendNullComma(ctx, b)
			continue
		}
		// the data word of the interface value is the address of the scalar, or the pointer to it.
		bb, err := appendScalar(ctx, b, scalar, iface.ptr)
		if err != nil {
			return nil, err
		}
		b = bb
	}
	mapCtx.Len = len(mapCtx.Keys)
	return b, nil
}

// appendSortedMapEntries writes the entries of a sorted map with keys of a string kind directly, as
// appendMapAsRead does for a map which is not sorted, from the one at idx in the order of the keys, as the
// opcodes of the entries would: every value when the values are written by one opcode of a scalar
// ( MapLayout.ScalarValue ), and a value of interface{} which holds a scalar or nothing
// ( MapLayout.InterfaceValue ). It returns the index of the first entry it doesn't write, whose value is left to
// its opcodes, or the number of the entries. code is the opcode of the keys, followed by the one of the values.
//
//go:noinline
func appendSortedMapEntries(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, mapCtx *encoder.MapContext, idx int) ([]byte, int, error) {
	scalarValue := mapCtx.ScalarValue()
	for ; idx < mapCtx.Len; idx++ {
		i := int(mapCtx.Order[idx])
		p := mapCtx.ValueAt(i)
		scalar := code.Next
		if !scalarValue {
			// as appendMapAsRead does for a value of interface{}.
			iface := (*emptyInterface)(p)
			if iface.typ == nil {
				b = appendMapKey(ctx, code, b, mapCtx.Keys[i])
				b = appendNullComma(ctx, b)
				continue
			}
			if iface.ptr == nil {
				return b, idx, nil
			}
			codeSet := ctx.RecentCodeSet(uintptr(iface.typ))
			if codeSet == nil {
				var err error
				codeSet, err = encoder.CompileToGetCodeSet(ctx, uintptr(iface.typ))
				if err != nil {
					return nil, 0, err
				}
			}
			if codeSet.Scalar == nil {
				return b, idx, nil
			}
			scalar = codeSet.Scalar
			p = iface.ptr
		}
		b = appendMapKey(ctx, code, b, mapCtx.Keys[i])
		bb, err := appendScalar(ctx, b, scalar, p)
		if err != nil {
			return nil, 0, err
		}
		b = bb
	}
	return b, idx, nil
}

// appendMapKey writes the key of an entry of a map, as OpMapKey does.
func appendMapKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, k string) []byte {
	b = appendMapKeyIndent(ctx, code, b)
	b = appendString(ctx, b, k)
	b = appendComma(ctx, b)
	return appendColon(ctx, b)
}

// appendMapScalarValues writes the entries of the map at p, whose values are written by the opcode of a
// scalar which follows the header, as the map is ranged over as a map of values of V: the layout of a map
// depends only on the sizes of the key and of the value ( encoder.MapLayout ).
func appendMapScalarValues[V any](ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, p unsafe.Pointer) ([]byte, error) {
	value := code.Next
	// v is declared out of the loop: its address is given to appendScalar, so it lives on the heap, and a
	// variable of the loop would be allocated for each entry.
	var (
		k string
		v V
	)
	for k, v = range *(*map[string]V)(unsafe.Pointer(&p)) {
		b = appendMapKey(ctx, code, b, k)
		bb, err := appendScalar(ctx, b, value, unsafe.Pointer(&v))
		if err != nil {
			return nil, err
		}
		b = bb
	}
	return b, nil
}

// mapScalarValueWriters are appendMapScalarValues by the words of a value.
var mapScalarValueWriters = [encoder.MapScalarValueWords + 1]func(*encoder.RuntimeContext, *encoder.Opcode, []byte, unsafe.Pointer) ([]byte, error){
	appendMapScalarValues[[0]uint64],
	appendMapScalarValues[[1]uint64],
	appendMapScalarValues[[2]uint64],
	appendMapScalarValues[[3]uint64],
}