// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: testdata

package testdata

import (
	"fmt"
	"reflect"
	"time"
	"v.io/v23/vdl"
	time_2 "v.io/v23/vdlroot/time"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

type AddressInfo struct {
	Street string
	City   string
	State  string
	Zip    string
}

func (AddressInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.AddressInfo"`
}) {
}

func (m *AddressInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Street == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Street"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.City == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("City"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.State == "")
	if var10 {
		if err := fieldsTarget1.ZeroField("State"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.Zip == "")
	if var13 {
		if err := fieldsTarget1.ZeroField("Zip"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *AddressInfo) MakeVDLTarget() vdl.Target {
	return &AddressInfoTarget{Value: m}
}

type AddressInfoTarget struct {
	Value        *AddressInfo
	streetTarget vdl.StringTarget
	cityTarget   vdl.StringTarget
	stateTarget  vdl.StringTarget
	zipTarget    vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *AddressInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*AddressInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *AddressInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Street":
		t.streetTarget.Value = &t.Value.Street
		target, err := &t.streetTarget, error(nil)
		return nil, target, err
	case "City":
		t.cityTarget.Value = &t.Value.City
		target, err := &t.cityTarget, error(nil)
		return nil, target, err
	case "State":
		t.stateTarget.Value = &t.Value.State
		target, err := &t.stateTarget, error(nil)
		return nil, target, err
	case "Zip":
		t.zipTarget.Value = &t.Value.Zip
		target, err := &t.zipTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.AddressInfo", name)
	}
}
func (t *AddressInfoTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *AddressInfoTarget) ZeroField(name string) error {
	switch name {
	case "Street":
		t.Value.Street = ""
		return nil
	case "City":
		t.Value.City = ""
		return nil
	case "State":
		t.Value.State = ""
		return nil
	case "Zip":
		t.Value.Zip = ""
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.AddressInfo", name)
	}
}
func (t *AddressInfoTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *AddressInfo) VDLRead(dec vdl.Decoder) error {
	*x = AddressInfo{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Street":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Street, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "City":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.City, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "State":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.State, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Zip":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Zip, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x AddressInfo) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*AddressInfo)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Street == "")
	if !(var1) {
		if err := enc.NextField("Street"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Street); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.City == "")
	if !(var2) {
		if err := enc.NextField("City"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.City); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var3 := (x.State == "")
	if !(var3) {
		if err := enc.NextField("State"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.State); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var4 := (x.Zip == "")
	if !(var4) {
		if err := enc.NextField("Zip"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Zip); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type CreditAgency int

const (
	CreditAgencyEquifax CreditAgency = iota
	CreditAgencyExperian
	CreditAgencyTransUnion
)

// CreditAgencyAll holds all labels for CreditAgency.
var CreditAgencyAll = [...]CreditAgency{CreditAgencyEquifax, CreditAgencyExperian, CreditAgencyTransUnion}

// CreditAgencyFromString creates a CreditAgency from a string label.
func CreditAgencyFromString(label string) (x CreditAgency, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *CreditAgency) Set(label string) error {
	switch label {
	case "Equifax", "equifax":
		*x = CreditAgencyEquifax
		return nil
	case "Experian", "experian":
		*x = CreditAgencyExperian
		return nil
	case "TransUnion", "transunion":
		*x = CreditAgencyTransUnion
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in testdata.CreditAgency", label)
}

// String returns the string label of x.
func (x CreditAgency) String() string {
	switch x {
	case CreditAgencyEquifax:
		return "Equifax"
	case CreditAgencyExperian:
		return "Experian"
	case CreditAgencyTransUnion:
		return "TransUnion"
	}
	return ""
}

func (CreditAgency) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.CreditAgency"`
	Enum struct{ Equifax, Experian, TransUnion string }
}) {
}

func (m *CreditAgency) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *CreditAgency) MakeVDLTarget() vdl.Target {
	return &CreditAgencyTarget{Value: m}
}

type CreditAgencyTarget struct {
	Value *CreditAgency
	vdl.TargetBase
}

func (t *CreditAgencyTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*CreditAgency)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Equifax":
		*t.Value = 0
	case "Experian":
		*t.Value = 1
	case "TransUnion":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum CreditAgency", src)
	}

	return nil
}

func (x *CreditAgency) VDLRead(dec vdl.Decoder) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	enum, err := dec.DecodeString()
	if err != nil {
		return err
	}
	if err = x.Set(enum); err != nil {
		return err
	}
	return dec.FinishValue()
}

func (x CreditAgency) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*CreditAgency)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.String()); err != nil {
		return err
	}
	return enc.FinishValue()
}

type ExperianRating int

const (
	ExperianRatingGood ExperianRating = iota
	ExperianRatingBad
)

// ExperianRatingAll holds all labels for ExperianRating.
var ExperianRatingAll = [...]ExperianRating{ExperianRatingGood, ExperianRatingBad}

// ExperianRatingFromString creates a ExperianRating from a string label.
func ExperianRatingFromString(label string) (x ExperianRating, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *ExperianRating) Set(label string) error {
	switch label {
	case "Good", "good":
		*x = ExperianRatingGood
		return nil
	case "Bad", "bad":
		*x = ExperianRatingBad
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in testdata.ExperianRating", label)
}

// String returns the string label of x.
func (x ExperianRating) String() string {
	switch x {
	case ExperianRatingGood:
		return "Good"
	case ExperianRatingBad:
		return "Bad"
	}
	return ""
}

func (ExperianRating) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.ExperianRating"`
	Enum struct{ Good, Bad string }
}) {
}

func (m *ExperianRating) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *ExperianRating) MakeVDLTarget() vdl.Target {
	return &ExperianRatingTarget{Value: m}
}

type ExperianRatingTarget struct {
	Value *ExperianRating
	vdl.TargetBase
}

func (t *ExperianRatingTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*ExperianRating)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Good":
		*t.Value = 0
	case "Bad":
		*t.Value = 1
	default:
		return fmt.Errorf("label %s not in enum ExperianRating", src)
	}

	return nil
}

func (x *ExperianRating) VDLRead(dec vdl.Decoder) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	enum, err := dec.DecodeString()
	if err != nil {
		return err
	}
	if err = x.Set(enum); err != nil {
		return err
	}
	return dec.FinishValue()
}

func (x ExperianRating) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ExperianRating)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.String()); err != nil {
		return err
	}
	return enc.FinishValue()
}

type RatingsArray [4]int16

func (RatingsArray) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.RatingsArray"`
}) {
}

func (m *RatingsArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 4)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromInt(int64(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RatingsArray) MakeVDLTarget() vdl.Target {
	return &RatingsArrayTarget{Value: m}
}

// RatingsArray
type RatingsArrayTarget struct {
	Value      *RatingsArray
	elemTarget vdl.Int16Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *RatingsArrayTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*RatingsArray)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *RatingsArrayTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *RatingsArrayTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *RatingsArrayTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

func (x *RatingsArray) VDLRead(dec vdl.Decoder) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible array %T, from %v", *x, dec.Type())
	}
	index := 0
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done != (index >= len(*x)):
			return fmt.Errorf("array len mismatch, got %d, want %T", index, *x)
		case done:
			return dec.FinishValue()
		}
		if err = dec.StartValue(); err != nil {
			return err
		}
		tmp, err := dec.DecodeInt(16)
		if err != nil {
			return err
		}
		x[index] = int16(tmp)
		if err = dec.FinishValue(); err != nil {
			return err
		}
		index++
	}
}

func (x RatingsArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*RatingsArray)(nil))); err != nil {
		return err
	}
	for i := 0; i < 4; i++ {
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x[i])); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type EquifaxCreditReport struct {
	Rating           byte
	FourScoreRatings RatingsArray
}

func (EquifaxCreditReport) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.EquifaxCreditReport"`
}) {
}

func (m *EquifaxCreditReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Rating == byte(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.FourScoreRatings == RatingsArray{})
	if var7 {
		if err := fieldsTarget1.ZeroField("FourScoreRatings"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FourScoreRatings")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.FourScoreRatings.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *EquifaxCreditReport) MakeVDLTarget() vdl.Target {
	return &EquifaxCreditReportTarget{Value: m}
}

type EquifaxCreditReportTarget struct {
	Value                  *EquifaxCreditReport
	ratingTarget           vdl.ByteTarget
	fourScoreRatingsTarget RatingsArrayTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *EquifaxCreditReportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*EquifaxCreditReport)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *EquifaxCreditReportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Rating":
		t.ratingTarget.Value = &t.Value.Rating
		target, err := &t.ratingTarget, error(nil)
		return nil, target, err
	case "FourScoreRatings":
		t.fourScoreRatingsTarget.Value = &t.Value.FourScoreRatings
		target, err := &t.fourScoreRatingsTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.EquifaxCreditReport", name)
	}
}
func (t *EquifaxCreditReportTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *EquifaxCreditReportTarget) ZeroField(name string) error {
	switch name {
	case "Rating":
		t.Value.Rating = byte(0)
		return nil
	case "FourScoreRatings":
		t.Value.FourScoreRatings = RatingsArray{}
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.EquifaxCreditReport", name)
	}
}
func (t *EquifaxCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *EquifaxCreditReport) VDLRead(dec vdl.Decoder) error {
	*x = EquifaxCreditReport{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Rating":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(8)
			if err != nil {
				return err
			}
			x.Rating = byte(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "FourScoreRatings":
			if err = x.FourScoreRatings.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x EquifaxCreditReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*EquifaxCreditReport)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Rating == byte(0))
	if !(var1) {
		if err := enc.NextField("Rating"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*byte)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.Rating)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.FourScoreRatings == RatingsArray{})
	if !(var2) {
		if err := enc.NextField("FourScoreRatings"); err != nil {
			return err
		}
		if err := x.FourScoreRatings.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type Tdh int

const (
	TdhTom Tdh = iota
	TdhDick
	TdhHarry
)

// TdhAll holds all labels for Tdh.
var TdhAll = [...]Tdh{TdhTom, TdhDick, TdhHarry}

// TdhFromString creates a Tdh from a string label.
func TdhFromString(label string) (x Tdh, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *Tdh) Set(label string) error {
	switch label {
	case "Tom", "tom":
		*x = TdhTom
		return nil
	case "Dick", "dick":
		*x = TdhDick
		return nil
	case "Harry", "harry":
		*x = TdhHarry
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in testdata.Tdh", label)
}

// String returns the string label of x.
func (x Tdh) String() string {
	switch x {
	case TdhTom:
		return "Tom"
	case TdhDick:
		return "Dick"
	case TdhHarry:
		return "Harry"
	}
	return ""
}

func (Tdh) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.Tdh"`
	Enum struct{ Tom, Dick, Harry string }
}) {
}

func (m *Tdh) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *Tdh) MakeVDLTarget() vdl.Target {
	return &TdhTarget{Value: m}
}

type TdhTarget struct {
	Value *Tdh
	vdl.TargetBase
}

func (t *TdhTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*Tdh)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Tom":
		*t.Value = 0
	case "Dick":
		*t.Value = 1
	case "Harry":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum Tdh", src)
	}

	return nil
}

func (x *Tdh) VDLRead(dec vdl.Decoder) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	enum, err := dec.DecodeString()
	if err != nil {
		return err
	}
	if err = x.Set(enum); err != nil {
		return err
	}
	return dec.FinishValue()
}

func (x Tdh) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Tdh)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.String()); err != nil {
		return err
	}
	return enc.FinishValue()
}

type ExperianCreditReport struct {
	Rating       ExperianRating
	TdhApprovals map[Tdh]struct{}
	Auditor      Tdh
}

func (ExperianCreditReport) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.ExperianCreditReport"`
}) {
}

func (m *ExperianCreditReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Rating == ExperianRatingGood)
	if var4 {
		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if len(m.TdhApprovals) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("TdhApprovals"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TdhApprovals")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget8, err := fieldTarget6.StartSet(tt.NonOptional().Field(1).Type, len(m.TdhApprovals))
			if err != nil {
				return err
			}
			for key10 := range m.TdhApprovals {
				keyTarget9, err := setTarget8.StartKey()
				if err != nil {
					return err
				}

				if err := key10.FillVDLTarget(keyTarget9, tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				if err := setTarget8.FinishKey(keyTarget9); err != nil {
					return err
				}
			}
			if err := fieldTarget6.FinishSet(setTarget8); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var13 := (m.Auditor == TdhTom)
	if var13 {
		if err := fieldsTarget1.ZeroField("Auditor"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Auditor")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Auditor.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ExperianCreditReport) MakeVDLTarget() vdl.Target {
	return &ExperianCreditReportTarget{Value: m}
}

type ExperianCreditReportTarget struct {
	Value              *ExperianCreditReport
	ratingTarget       ExperianRatingTarget
	tdhApprovalsTarget __VDLTarget1_set
	auditorTarget      TdhTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ExperianCreditReportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ExperianCreditReport)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ExperianCreditReportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Rating":
		t.ratingTarget.Value = &t.Value.Rating
		target, err := &t.ratingTarget, error(nil)
		return nil, target, err
	case "TdhApprovals":
		t.tdhApprovalsTarget.Value = &t.Value.TdhApprovals
		target, err := &t.tdhApprovalsTarget, error(nil)
		return nil, target, err
	case "Auditor":
		t.auditorTarget.Value = &t.Value.Auditor
		target, err := &t.auditorTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ExperianCreditReport", name)
	}
}
func (t *ExperianCreditReportTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ExperianCreditReportTarget) ZeroField(name string) error {
	switch name {
	case "Rating":
		t.Value.Rating = ExperianRatingGood
		return nil
	case "TdhApprovals":
		t.Value.TdhApprovals = map[Tdh]struct{}(nil)
		return nil
	case "Auditor":
		t.Value.Auditor = TdhTom
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ExperianCreditReport", name)
	}
}
func (t *ExperianCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[Tdh]struct{}
type __VDLTarget1_set struct {
	Value     *map[Tdh]struct{}
	currKey   Tdh
	keyTarget TdhTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget1_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[Tdh]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[Tdh]struct{})
	return t, nil
}
func (t *__VDLTarget1_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = TdhTom
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget1_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget1_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x *ExperianCreditReport) VDLRead(dec vdl.Decoder) error {
	*x = ExperianCreditReport{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Rating":
			if err = x.Rating.VDLRead(dec); err != nil {
				return err
			}
		case "TdhApprovals":
			if err = __VDLRead1_set(dec, &x.TdhApprovals); err != nil {
				return err
			}
		case "Auditor":
			if err = x.Auditor.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead1_set(dec vdl.Decoder, x *map[Tdh]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[Tdh]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[Tdh]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key Tdh
		{
			if err = key.VDLRead(dec); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[Tdh]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func (x ExperianCreditReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ExperianCreditReport)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Rating == ExperianRatingGood)
	if !(var1) {
		if err := enc.NextField("Rating"); err != nil {
			return err
		}
		if err := x.Rating.VDLWrite(enc); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.TdhApprovals) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("TdhApprovals"); err != nil {
			return err
		}
		if err := __VDLWrite1_set(enc, &x.TdhApprovals); err != nil {
			return err
		}
	}
	var3 := (x.Auditor == TdhTom)
	if !(var3) {
		if err := enc.NextField("Auditor"); err != nil {
			return err
		}
		if err := x.Auditor.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite1_set(enc vdl.Encoder, x *map[Tdh]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[Tdh]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := key.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type TransUnionCreditReport struct {
	Rating          int16
	PreviousRatings map[string]int16
}

func (TransUnionCreditReport) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.TransUnionCreditReport"`
}) {
}

func (m *TransUnionCreditReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Rating == int16(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("Rating"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if len(m.PreviousRatings) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("PreviousRatings"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PreviousRatings")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget8, err := fieldTarget6.StartMap(tt.NonOptional().Field(1).Type, len(m.PreviousRatings))
			if err != nil {
				return err
			}
			for key10, value12 := range m.PreviousRatings {
				keyTarget9, err := mapTarget8.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget9.FromString(string(key10), tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				valueTarget11, err := mapTarget8.FinishKeyStartField(keyTarget9)
				if err != nil {
					return err
				}
				if err := valueTarget11.FromInt(int64(value12), tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget8.FinishField(keyTarget9, valueTarget11); err != nil {
					return err
				}
			}
			if err := fieldTarget6.FinishMap(mapTarget8); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *TransUnionCreditReport) MakeVDLTarget() vdl.Target {
	return &TransUnionCreditReportTarget{Value: m}
}

type TransUnionCreditReportTarget struct {
	Value                 *TransUnionCreditReport
	ratingTarget          vdl.Int16Target
	previousRatingsTarget __VDLTarget2_map
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *TransUnionCreditReportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*TransUnionCreditReport)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *TransUnionCreditReportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Rating":
		t.ratingTarget.Value = &t.Value.Rating
		target, err := &t.ratingTarget, error(nil)
		return nil, target, err
	case "PreviousRatings":
		t.previousRatingsTarget.Value = &t.Value.PreviousRatings
		target, err := &t.previousRatingsTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.TransUnionCreditReport", name)
	}
}
func (t *TransUnionCreditReportTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *TransUnionCreditReportTarget) ZeroField(name string) error {
	switch name {
	case "Rating":
		t.Value.Rating = int16(0)
		return nil
	case "PreviousRatings":
		t.Value.PreviousRatings = map[string]int16(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.TransUnionCreditReport", name)
	}
}
func (t *TransUnionCreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[string]int16
type __VDLTarget2_map struct {
	Value      *map[string]int16
	currKey    string
	currElem   int16
	keyTarget  vdl.StringTarget
	elemTarget vdl.Int16Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget2_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string]int16)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string]int16)
	return t, nil
}
func (t *__VDLTarget2_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = int16(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget2_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x *TransUnionCreditReport) VDLRead(dec vdl.Decoder) error {
	*x = TransUnionCreditReport{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Rating":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			x.Rating = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "PreviousRatings":
			if err = __VDLRead2_map(dec, &x.PreviousRatings); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead2_map(dec vdl.Decoder, x *map[string]int16) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]int16
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]int16, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem int16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			elem = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]int16)
		}
		tmpMap[key] = elem
	}
}

func (x TransUnionCreditReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*TransUnionCreditReport)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Rating == int16(0))
	if !(var1) {
		if err := enc.NextField("Rating"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.Rating)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.PreviousRatings) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("PreviousRatings"); err != nil {
			return err
		}
		if err := __VDLWrite2_map(enc, &x.PreviousRatings); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite2_map(enc vdl.Encoder, x *map[string]int16) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]int16)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(elem)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type (
	// AgencyReport represents any single field of the AgencyReport union type.
	AgencyReport interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the AgencyReport union type.
		__VDLReflect(__AgencyReportReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLWrite(vdl.Encoder) error
	}
	// AgencyReportEquifaxReport represents field EquifaxReport of the AgencyReport union type.
	AgencyReportEquifaxReport struct{ Value EquifaxCreditReport }
	// AgencyReportExperianReport represents field ExperianReport of the AgencyReport union type.
	AgencyReportExperianReport struct{ Value ExperianCreditReport }
	// AgencyReportTransUnionReport represents field TransUnionReport of the AgencyReport union type.
	AgencyReportTransUnionReport struct{ Value TransUnionCreditReport }
	// __AgencyReportReflect describes the AgencyReport union type.
	__AgencyReportReflect struct {
		Name               string `vdl:"v.io/v23/query/engine/internal/testdata.AgencyReport"`
		Type               AgencyReport
		UnionTargetFactory agencyReportTargetFactory
		Union              struct {
			EquifaxReport    AgencyReportEquifaxReport
			ExperianReport   AgencyReportExperianReport
			TransUnionReport AgencyReportTransUnionReport
		}
	}
)

func (x AgencyReportEquifaxReport) Index() int                         { return 0 }
func (x AgencyReportEquifaxReport) Interface() interface{}             { return x.Value }
func (x AgencyReportEquifaxReport) Name() string                       { return "EquifaxReport" }
func (x AgencyReportEquifaxReport) __VDLReflect(__AgencyReportReflect) {}

func (m AgencyReportEquifaxReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("EquifaxReport")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m AgencyReportEquifaxReport) MakeVDLTarget() vdl.Target {
	return nil
}

func (x AgencyReportExperianReport) Index() int                         { return 1 }
func (x AgencyReportExperianReport) Interface() interface{}             { return x.Value }
func (x AgencyReportExperianReport) Name() string                       { return "ExperianReport" }
func (x AgencyReportExperianReport) __VDLReflect(__AgencyReportReflect) {}

func (m AgencyReportExperianReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ExperianReport")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m AgencyReportExperianReport) MakeVDLTarget() vdl.Target {
	return nil
}

func (x AgencyReportTransUnionReport) Index() int                         { return 2 }
func (x AgencyReportTransUnionReport) Interface() interface{}             { return x.Value }
func (x AgencyReportTransUnionReport) Name() string                       { return "TransUnionReport" }
func (x AgencyReportTransUnionReport) __VDLReflect(__AgencyReportReflect) {}

func (m AgencyReportTransUnionReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("TransUnionReport")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(2).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m AgencyReportTransUnionReport) MakeVDLTarget() vdl.Target {
	return nil
}

type AgencyReportTarget struct {
	Value     *AgencyReport
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *AgencyReportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*AgencyReport)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *AgencyReportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "EquifaxReport":
		val := EquifaxCreditReport{}
		return nil, &EquifaxCreditReportTarget{Value: &val}, nil
	case "ExperianReport":
		val := ExperianCreditReport{}
		return nil, &ExperianCreditReportTarget{Value: &val}, nil
	case "TransUnionReport":
		val := TransUnionCreditReport{}
		return nil, &TransUnionCreditReportTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/query/engine/internal/testdata.AgencyReport", name)
	}
}
func (t *AgencyReportTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "EquifaxReport":
		*t.Value = AgencyReportEquifaxReport{*(fieldTarget.(*EquifaxCreditReportTarget)).Value}
	case "ExperianReport":
		*t.Value = AgencyReportExperianReport{*(fieldTarget.(*ExperianCreditReportTarget)).Value}
	case "TransUnionReport":
		*t.Value = AgencyReportTransUnionReport{*(fieldTarget.(*TransUnionCreditReportTarget)).Value}
	}
	return nil
}
func (t *AgencyReportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type agencyReportTargetFactory struct{}

func (t agencyReportTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*AgencyReport); ok {
		return &AgencyReportTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *AgencyReport", union)
}

func VDLReadAgencyReport(dec vdl.Decoder, x *AgencyReport) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "EquifaxReport":
		var field AgencyReportEquifaxReport
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "ExperianReport":
		var field AgencyReportExperianReport
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "TransUnionReport":
		var field AgencyReportTransUnionReport
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

func (x AgencyReportEquifaxReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("EquifaxReport"); err != nil {
		return err
	}
	if err := x.Value.VDLWrite(enc); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}
func (x AgencyReportExperianReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("ExperianReport"); err != nil {
		return err
	}
	if err := x.Value.VDLWrite(enc); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}
func (x AgencyReportTransUnionReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("TransUnionReport"); err != nil {
		return err
	}
	if err := x.Value.VDLWrite(enc); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type CreditReport struct {
	Agency CreditAgency
	Report AgencyReport
}

func (CreditReport) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.CreditReport"`
}) {
}

func (m *CreditReport) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Agency == CreditAgencyEquifax)
	if var4 {
		if err := fieldsTarget1.ZeroField("Agency"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if field, ok := m.Report.(AgencyReportEquifaxReport); ok {

		var8 := (field.Value == EquifaxCreditReport{})
		var7 = var8
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("Report"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			unionValue9 := m.Report
			if unionValue9 == nil {
				unionValue9 = AgencyReportEquifaxReport{}
			}
			if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *CreditReport) MakeVDLTarget() vdl.Target {
	return &CreditReportTarget{Value: m}
}

type CreditReportTarget struct {
	Value        *CreditReport
	agencyTarget CreditAgencyTarget
	reportTarget AgencyReportTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *CreditReportTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*CreditReport)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *CreditReportTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Agency":
		t.agencyTarget.Value = &t.Value.Agency
		target, err := &t.agencyTarget, error(nil)
		return nil, target, err
	case "Report":
		t.reportTarget.Value = &t.Value.Report
		target, err := &t.reportTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.CreditReport", name)
	}
}
func (t *CreditReportTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *CreditReportTarget) ZeroField(name string) error {
	switch name {
	case "Agency":
		t.Value.Agency = CreditAgencyEquifax
		return nil
	case "Report":
		t.Value.Report = AgencyReport(AgencyReportEquifaxReport{})
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.CreditReport", name)
	}
}
func (t *CreditReportTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *CreditReport) VDLRead(dec vdl.Decoder) error {
	*x = CreditReport{
		Report: AgencyReportEquifaxReport{},
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Agency":
			if err = x.Agency.VDLRead(dec); err != nil {
				return err
			}
		case "Report":
			if err = VDLReadAgencyReport(dec, &x.Report); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x CreditReport) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*CreditReport)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Agency == CreditAgencyEquifax)
	if !(var1) {
		if err := enc.NextField("Agency"); err != nil {
			return err
		}
		if err := x.Agency.VDLWrite(enc); err != nil {
			return err
		}
	}
	var var2 bool
	if field, ok := x.Report.(AgencyReportEquifaxReport); ok {

		var3 := (field.Value == EquifaxCreditReport{})
		var2 = var3
	}
	if !(var2) {
		if err := enc.NextField("Report"); err != nil {
			return err
		}
		if err := x.Report.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type Customer struct {
	Name              string
	Id                int64
	Active            bool
	Address           AddressInfo
	PreviousAddresses []AddressInfo
	Credit            CreditReport
}

func (Customer) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.Customer"`
}) {
}

func (m *Customer) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Id == int64(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("Id"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.Active == false)
	if var10 {
		if err := fieldsTarget1.ZeroField("Active"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.Address == AddressInfo{})
	if var13 {
		if err := fieldsTarget1.ZeroField("Address"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Address.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	var var16 bool
	if len(m.PreviousAddresses) == 0 {
		var16 = true
	}
	if var16 {
		if err := fieldsTarget1.ZeroField("PreviousAddresses"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("PreviousAddresses")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget17, err := fieldTarget15.StartList(tt.NonOptional().Field(4).Type, len(m.PreviousAddresses))
			if err != nil {
				return err
			}
			for i, elem19 := range m.PreviousAddresses {
				elemTarget18, err := listTarget17.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem19.FillVDLTarget(elemTarget18, tt.NonOptional().Field(4).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget17.FinishElem(elemTarget18); err != nil {
					return err
				}
			}
			if err := fieldTarget15.FinishList(listTarget17); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
				return err
			}
		}
	}
	var22 := true
	var23 := (m.Credit.Agency == CreditAgencyEquifax)
	var22 = var22 && var23
	var var24 bool
	if field, ok := m.Credit.Report.(AgencyReportEquifaxReport); ok {

		var25 := (field.Value == EquifaxCreditReport{})
		var24 = var25
	}
	var22 = var22 && var24
	if var22 {
		if err := fieldsTarget1.ZeroField("Credit"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Credit")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Credit.FillVDLTarget(fieldTarget21, tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Customer) MakeVDLTarget() vdl.Target {
	return &CustomerTarget{Value: m}
}

type CustomerTarget struct {
	Value                   *Customer
	nameTarget              vdl.StringTarget
	idTarget                vdl.Int64Target
	activeTarget            vdl.BoolTarget
	addressTarget           AddressInfoTarget
	previousAddressesTarget __VDLTarget3_list
	creditTarget            CreditReportTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *CustomerTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Customer)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *CustomerTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "Id":
		t.idTarget.Value = &t.Value.Id
		target, err := &t.idTarget, error(nil)
		return nil, target, err
	case "Active":
		t.activeTarget.Value = &t.Value.Active
		target, err := &t.activeTarget, error(nil)
		return nil, target, err
	case "Address":
		t.addressTarget.Value = &t.Value.Address
		target, err := &t.addressTarget, error(nil)
		return nil, target, err
	case "PreviousAddresses":
		t.previousAddressesTarget.Value = &t.Value.PreviousAddresses
		target, err := &t.previousAddressesTarget, error(nil)
		return nil, target, err
	case "Credit":
		t.creditTarget.Value = &t.Value.Credit
		target, err := &t.creditTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Customer", name)
	}
}
func (t *CustomerTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *CustomerTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "Id":
		t.Value.Id = int64(0)
		return nil
	case "Active":
		t.Value.Active = false
		return nil
	case "Address":
		t.Value.Address = AddressInfo{}
		return nil
	case "PreviousAddresses":
		t.Value.PreviousAddresses = []AddressInfo(nil)
		return nil
	case "Credit":
		t.Value.Credit = CreditReport{
			Report: AgencyReportEquifaxReport{},
		}
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Customer", name)
	}
}
func (t *CustomerTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []AddressInfo
type __VDLTarget3_list struct {
	Value      *[]AddressInfo
	elemTarget AddressInfoTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget3_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]AddressInfo)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]AddressInfo, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget3_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget3_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget3_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

func (x *Customer) VDLRead(dec vdl.Decoder) error {
	*x = Customer{
		Credit: CreditReport{
			Report: AgencyReportEquifaxReport{},
		},
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Name":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Id":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Id, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Active":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Active, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Address":
			if err = x.Address.VDLRead(dec); err != nil {
				return err
			}
		case "PreviousAddresses":
			if err = __VDLRead3_list(dec, &x.PreviousAddresses); err != nil {
				return err
			}
		case "Credit":
			if err = x.Credit.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead3_list(dec vdl.Decoder, x *[]AddressInfo) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len > 0:
		*x = make([]AddressInfo, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem AddressInfo
		if err = elem.VDLRead(dec); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

func (x Customer) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Customer)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Name == "")
	if !(var1) {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.Id == int64(0))
	if !(var2) {
		if err := enc.NextField("Id"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(x.Id); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var3 := (x.Active == false)
	if !(var3) {
		if err := enc.NextField("Active"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*bool)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeBool(x.Active); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var4 := (x.Address == AddressInfo{})
	if !(var4) {
		if err := enc.NextField("Address"); err != nil {
			return err
		}
		if err := x.Address.VDLWrite(enc); err != nil {
			return err
		}
	}
	var var5 bool
	if len(x.PreviousAddresses) == 0 {
		var5 = true
	}
	if !(var5) {
		if err := enc.NextField("PreviousAddresses"); err != nil {
			return err
		}
		if err := __VDLWrite3_list(enc, &x.PreviousAddresses); err != nil {
			return err
		}
	}
	var6 := true
	var7 := (x.Credit.Agency == CreditAgencyEquifax)
	var6 = var6 && var7
	var var8 bool
	if field, ok := x.Credit.Report.(AgencyReportEquifaxReport); ok {

		var9 := (field.Value == EquifaxCreditReport{})
		var8 = var9
	}
	var6 = var6 && var8
	if !(var6) {
		if err := enc.NextField("Credit"); err != nil {
			return err
		}
		if err := x.Credit.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite3_list(enc vdl.Encoder, x *[]AddressInfo) error {
	if err := enc.StartValue(vdl.TypeOf((*[]AddressInfo)(nil))); err != nil {
		return err
	}
	for i := 0; i < len(*x); i++ {
		if err := (*x)[i].VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type Invoice struct {
	CustId      int64
	InvoiceNum  int64
	InvoiceDate time.Time
	Amount      int64
	ShipTo      AddressInfo
}

func (Invoice) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.Invoice"`
}) {
}

func (m *Invoice) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.CustId == int64(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("CustId"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CustId")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromInt(int64(m.CustId), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.InvoiceNum == int64(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("InvoiceNum"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("InvoiceNum")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromInt(int64(m.InvoiceNum), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var wireValue8 time_2.Time
	if err := time_2.TimeFromNative(&wireValue8, m.InvoiceDate); err != nil {
		return err
	}

	var11 := (wireValue8 == time_2.Time{})
	if var11 {
		if err := fieldsTarget1.ZeroField("InvoiceDate"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("InvoiceDate")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
				return err
			}
		}
	}
	var14 := (m.Amount == int64(0))
	if var14 {
		if err := fieldsTarget1.ZeroField("Amount"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Amount")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget13.FromInt(int64(m.Amount), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
				return err
			}
		}
	}
	var17 := (m.ShipTo == AddressInfo{})
	if var17 {
		if err := fieldsTarget1.ZeroField("ShipTo"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget15, fieldTarget16, err := fieldsTarget1.StartField("ShipTo")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.ShipTo.FillVDLTarget(fieldTarget16, tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget15, fieldTarget16); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Invoice) MakeVDLTarget() vdl.Target {
	return &InvoiceTarget{Value: m}
}

type InvoiceTarget struct {
	Value             *Invoice
	custIdTarget      vdl.Int64Target
	invoiceNumTarget  vdl.Int64Target
	invoiceDateTarget time_2.TimeTarget
	amountTarget      vdl.Int64Target
	shipToTarget      AddressInfoTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *InvoiceTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Invoice)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *InvoiceTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "CustId":
		t.custIdTarget.Value = &t.Value.CustId
		target, err := &t.custIdTarget, error(nil)
		return nil, target, err
	case "InvoiceNum":
		t.invoiceNumTarget.Value = &t.Value.InvoiceNum
		target, err := &t.invoiceNumTarget, error(nil)
		return nil, target, err
	case "InvoiceDate":
		t.invoiceDateTarget.Value = &t.Value.InvoiceDate
		target, err := &t.invoiceDateTarget, error(nil)
		return nil, target, err
	case "Amount":
		t.amountTarget.Value = &t.Value.Amount
		target, err := &t.amountTarget, error(nil)
		return nil, target, err
	case "ShipTo":
		t.shipToTarget.Value = &t.Value.ShipTo
		target, err := &t.shipToTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Invoice", name)
	}
}
func (t *InvoiceTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *InvoiceTarget) ZeroField(name string) error {
	switch name {
	case "CustId":
		t.Value.CustId = int64(0)
		return nil
	case "InvoiceNum":
		t.Value.InvoiceNum = int64(0)
		return nil
	case "InvoiceDate":
		t.Value.InvoiceDate = func() time.Time {
			var native time.Time
			if err := vdl.Convert(&native, time_2.Time{}); err != nil {
				panic(err)
			}
			return native
		}()
		return nil
	case "Amount":
		t.Value.Amount = int64(0)
		return nil
	case "ShipTo":
		t.Value.ShipTo = AddressInfo{}
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Invoice", name)
	}
}
func (t *InvoiceTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *Invoice) VDLRead(dec vdl.Decoder) error {
	*x = Invoice{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "CustId":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.CustId, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "InvoiceNum":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.InvoiceNum, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "InvoiceDate":
			var wire time_2.Time
			if err = wire.VDLRead(dec); err != nil {
				return err
			}
			if err = time_2.TimeToNative(wire, &x.InvoiceDate); err != nil {
				return err
			}
		case "Amount":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Amount, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "ShipTo":
			if err = x.ShipTo.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x Invoice) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Invoice)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.CustId == int64(0))
	if !(var1) {
		if err := enc.NextField("CustId"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(x.CustId); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.InvoiceNum == int64(0))
	if !(var2) {
		if err := enc.NextField("InvoiceNum"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(x.InvoiceNum); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var wireValue3 time_2.Time
	if err := time_2.TimeFromNative(&wireValue3, x.InvoiceDate); err != nil {
		return fmt.Errorf("error converting x.InvoiceDate to wiretype")
	}

	var4 := (wireValue3 == time_2.Time{})
	if !(var4) {
		if err := enc.NextField("InvoiceDate"); err != nil {
			return err
		}
		var wire time_2.Time
		if err := time_2.TimeFromNative(&wire, x.InvoiceDate); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
	}
	var5 := (x.Amount == int64(0))
	if !(var5) {
		if err := enc.NextField("Amount"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(x.Amount); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var6 := (x.ShipTo == AddressInfo{})
	if !(var6) {
		if err := enc.NextField("ShipTo"); err != nil {
			return err
		}
		if err := x.ShipTo.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type Numbers struct {
	B    byte
	Ui16 uint16
	Ui32 uint32
	Ui64 uint64
	I16  int16
	I32  int32
	I64  int64
	F32  float32
	F64  float64
}

func (Numbers) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.Numbers"`
}) {
}

func (m *Numbers) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.B == byte(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("B"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromUint(uint64(m.B), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Ui16 == uint16(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("Ui16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Ui16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromUint(uint64(m.Ui16), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var10 := (m.Ui32 == uint32(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("Ui32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Ui32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromUint(uint64(m.Ui32), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.Ui64 == uint64(0))
	if var13 {
		if err := fieldsTarget1.ZeroField("Ui64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Ui64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromUint(uint64(m.Ui64), tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	var16 := (m.I16 == int16(0))
	if var16 {
		if err := fieldsTarget1.ZeroField("I16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("I16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget15.FromInt(int64(m.I16), tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
				return err
			}
		}
	}
	var19 := (m.I32 == int32(0))
	if var19 {
		if err := fieldsTarget1.ZeroField("I32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("I32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget18.FromInt(int64(m.I32), tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
				return err
			}
		}
	}
	var22 := (m.I64 == int64(0))
	if var22 {
		if err := fieldsTarget1.ZeroField("I64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("I64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget21.FromInt(int64(m.I64), tt.NonOptional().Field(6).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	var25 := (m.F32 == float32(0))
	if var25 {
		if err := fieldsTarget1.ZeroField("F32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("F32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget24.FromFloat(float64(m.F32), tt.NonOptional().Field(7).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
				return err
			}
		}
	}
	var28 := (m.F64 == float64(0))
	if var28 {
		if err := fieldsTarget1.ZeroField("F64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("F64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget27.FromFloat(float64(m.F64), tt.NonOptional().Field(8).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Numbers) MakeVDLTarget() vdl.Target {
	return &NumbersTarget{Value: m}
}

type NumbersTarget struct {
	Value      *Numbers
	bTarget    vdl.ByteTarget
	ui16Target vdl.Uint16Target
	ui32Target vdl.Uint32Target
	ui64Target vdl.Uint64Target
	i16Target  vdl.Int16Target
	i32Target  vdl.Int32Target
	i64Target  vdl.Int64Target
	f32Target  vdl.Float32Target
	f64Target  vdl.Float64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *NumbersTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Numbers)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *NumbersTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "Ui16":
		t.ui16Target.Value = &t.Value.Ui16
		target, err := &t.ui16Target, error(nil)
		return nil, target, err
	case "Ui32":
		t.ui32Target.Value = &t.Value.Ui32
		target, err := &t.ui32Target, error(nil)
		return nil, target, err
	case "Ui64":
		t.ui64Target.Value = &t.Value.Ui64
		target, err := &t.ui64Target, error(nil)
		return nil, target, err
	case "I16":
		t.i16Target.Value = &t.Value.I16
		target, err := &t.i16Target, error(nil)
		return nil, target, err
	case "I32":
		t.i32Target.Value = &t.Value.I32
		target, err := &t.i32Target, error(nil)
		return nil, target, err
	case "I64":
		t.i64Target.Value = &t.Value.I64
		target, err := &t.i64Target, error(nil)
		return nil, target, err
	case "F32":
		t.f32Target.Value = &t.Value.F32
		target, err := &t.f32Target, error(nil)
		return nil, target, err
	case "F64":
		t.f64Target.Value = &t.Value.F64
		target, err := &t.f64Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Numbers", name)
	}
}
func (t *NumbersTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *NumbersTarget) ZeroField(name string) error {
	switch name {
	case "B":
		t.Value.B = byte(0)
		return nil
	case "Ui16":
		t.Value.Ui16 = uint16(0)
		return nil
	case "Ui32":
		t.Value.Ui32 = uint32(0)
		return nil
	case "Ui64":
		t.Value.Ui64 = uint64(0)
		return nil
	case "I16":
		t.Value.I16 = int16(0)
		return nil
	case "I32":
		t.Value.I32 = int32(0)
		return nil
	case "I64":
		t.Value.I64 = int64(0)
		return nil
	case "F32":
		t.Value.F32 = float32(0)
		return nil
	case "F64":
		t.Value.F64 = float64(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.Numbers", name)
	}
}
func (t *NumbersTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *Numbers) VDLRead(dec vdl.Decoder) error {
	*x = Numbers{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "B":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(8)
			if err != nil {
				return err
			}
			x.B = byte(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Ui16":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(16)
			if err != nil {
				return err
			}
			x.Ui16 = uint16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Ui32":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(32)
			if err != nil {
				return err
			}
			x.Ui32 = uint32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Ui64":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Ui64, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "I16":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			x.I16 = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "I32":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			x.I32 = int32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "I64":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.I64, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "F32":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeFloat(32)
			if err != nil {
				return err
			}
			x.F32 = float32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "F64":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.F64, err = dec.DecodeFloat(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x Numbers) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*Numbers)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.B == byte(0))
	if !(var1) {
		if err := enc.NextField("B"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*byte)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.B)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.Ui16 == uint16(0))
	if !(var2) {
		if err := enc.NextField("Ui16"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*uint16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.Ui16)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var3 := (x.Ui32 == uint32(0))
	if !(var3) {
		if err := enc.NextField("Ui32"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*uint32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.Ui32)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var4 := (x.Ui64 == uint64(0))
	if !(var4) {
		if err := enc.NextField("Ui64"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*uint64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(x.Ui64); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var5 := (x.I16 == int16(0))
	if !(var5) {
		if err := enc.NextField("I16"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.I16)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var6 := (x.I32 == int32(0))
	if !(var6) {
		if err := enc.NextField("I32"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(x.I32)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var7 := (x.I64 == int64(0))
	if !(var7) {
		if err := enc.NextField("I64"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(x.I64); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var8 := (x.F32 == float32(0))
	if !(var8) {
		if err := enc.NextField("F32"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*float32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(float64(x.F32)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var9 := (x.F64 == float64(0))
	if !(var9) {
		if err := enc.NextField("F64"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*float64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(x.F64); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type (
	// TitleOrValueType represents any single field of the TitleOrValueType union type.
	TitleOrValueType interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the TitleOrValueType union type.
		__VDLReflect(__TitleOrValueTypeReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
		VDLWrite(vdl.Encoder) error
	}
	// TitleOrValueTypeTitle represents field Title of the TitleOrValueType union type.
	TitleOrValueTypeTitle struct{ Value string }
	// TitleOrValueTypeValue represents field Value of the TitleOrValueType union type.
	TitleOrValueTypeValue struct{ Value int64 }
	// __TitleOrValueTypeReflect describes the TitleOrValueType union type.
	__TitleOrValueTypeReflect struct {
		Name               string `vdl:"v.io/v23/query/engine/internal/testdata.TitleOrValueType"`
		Type               TitleOrValueType
		UnionTargetFactory titleOrValueTypeTargetFactory
		Union              struct {
			Title TitleOrValueTypeTitle
			Value TitleOrValueTypeValue
		}
	}
)

func (x TitleOrValueTypeTitle) Index() int                             { return 0 }
func (x TitleOrValueTypeTitle) Interface() interface{}                 { return x.Value }
func (x TitleOrValueTypeTitle) Name() string                           { return "Title" }
func (x TitleOrValueTypeTitle) __VDLReflect(__TitleOrValueTypeReflect) {}

func (m TitleOrValueTypeTitle) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Title")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m TitleOrValueTypeTitle) MakeVDLTarget() vdl.Target {
	return nil
}

func (x TitleOrValueTypeValue) Index() int                             { return 1 }
func (x TitleOrValueTypeValue) Interface() interface{}                 { return x.Value }
func (x TitleOrValueTypeValue) Name() string                           { return "Value" }
func (x TitleOrValueTypeValue) __VDLReflect(__TitleOrValueTypeReflect) {}

func (m TitleOrValueTypeValue) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Value")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m TitleOrValueTypeValue) MakeVDLTarget() vdl.Target {
	return nil
}

type TitleOrValueTypeTarget struct {
	Value     *TitleOrValueType
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *TitleOrValueTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*TitleOrValueType)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *TitleOrValueTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "Title":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "Value":
		val := int64(0)
		return nil, &vdl.Int64Target{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/query/engine/internal/testdata.TitleOrValueType", name)
	}
}
func (t *TitleOrValueTypeTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "Title":
		*t.Value = TitleOrValueTypeTitle{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "Value":
		*t.Value = TitleOrValueTypeValue{*(fieldTarget.(*vdl.Int64Target)).Value}
	}
	return nil
}
func (t *TitleOrValueTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type titleOrValueTypeTargetFactory struct{}

func (t titleOrValueTypeTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*TitleOrValueType); ok {
		return &TitleOrValueTypeTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *TitleOrValueType", union)
}

func VDLReadTitleOrValueType(dec vdl.Decoder, x *TitleOrValueType) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "Title":
		var field TitleOrValueTypeTitle
		if err = dec.StartValue(); err != nil {
			return err
		}
		if field.Value, err = dec.DecodeString(); err != nil {
			return err
		}
		if err = dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "Value":
		var field TitleOrValueTypeValue
		if err = dec.StartValue(); err != nil {
			return err
		}
		if field.Value, err = dec.DecodeInt(64); err != nil {
			return err
		}
		if err = dec.FinishValue(); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

func (x TitleOrValueTypeTitle) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*TitleOrValueType)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("Title"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeString(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}
func (x TitleOrValueTypeValue) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*TitleOrValueType)(nil))); err != nil {
		return err
	}
	if err := enc.NextField("Value"); err != nil {
		return err
	}
	if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
		return err
	}
	if err := enc.EncodeInt(x.Value); err != nil {
		return err
	}
	if err := enc.FinishValue(); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type BazType struct {
	Name         string
	TitleOrValue TitleOrValueType
}

func (BazType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.BazType"`
}) {
}

func (m *BazType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Name == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Name"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if field, ok := m.TitleOrValue.(TitleOrValueTypeTitle); ok {

		var8 := (field.Value == "")
		var7 = var8
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("TitleOrValue"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TitleOrValue")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			unionValue9 := m.TitleOrValue
			if unionValue9 == nil {
				unionValue9 = TitleOrValueTypeTitle{}
			}
			if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *BazType) MakeVDLTarget() vdl.Target {
	return &BazTypeTarget{Value: m}
}

type BazTypeTarget struct {
	Value              *BazType
	nameTarget         vdl.StringTarget
	titleOrValueTarget TitleOrValueTypeTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BazTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*BazType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *BazTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "TitleOrValue":
		t.titleOrValueTarget.Value = &t.Value.TitleOrValue
		target, err := &t.titleOrValueTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BazType", name)
	}
}
func (t *BazTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *BazTypeTarget) ZeroField(name string) error {
	switch name {
	case "Name":
		t.Value.Name = ""
		return nil
	case "TitleOrValue":
		t.Value.TitleOrValue = TitleOrValueType(TitleOrValueTypeTitle{})
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BazType", name)
	}
}
func (t *BazTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *BazType) VDLRead(dec vdl.Decoder) error {
	*x = BazType{
		TitleOrValue: TitleOrValueTypeTitle{},
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Name":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Name, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "TitleOrValue":
			if err = VDLReadTitleOrValueType(dec, &x.TitleOrValue); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x BazType) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*BazType)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Name == "")
	if !(var1) {
		if err := enc.NextField("Name"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Name); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var var2 bool
	if field, ok := x.TitleOrValue.(TitleOrValueTypeTitle); ok {

		var3 := (field.Value == "")
		var2 = var3
	}
	if !(var2) {
		if err := enc.NextField("TitleOrValue"); err != nil {
			return err
		}
		if err := x.TitleOrValue.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type BarType struct {
	Baz BazType
}

func (BarType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.BarType"`
}) {
}

func (m *BarType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Baz == BazType{
		TitleOrValue: TitleOrValueTypeTitle{},
	})
	if var4 {
		if err := fieldsTarget1.ZeroField("Baz"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Baz")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Baz.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *BarType) MakeVDLTarget() vdl.Target {
	return &BarTypeTarget{Value: m}
}

type BarTypeTarget struct {
	Value     *BarType
	bazTarget BazTypeTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BarTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*BarType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *BarTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Baz":
		t.bazTarget.Value = &t.Value.Baz
		target, err := &t.bazTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BarType", name)
	}
}
func (t *BarTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *BarTypeTarget) ZeroField(name string) error {
	switch name {
	case "Baz":
		t.Value.Baz = BazType{
			TitleOrValue: TitleOrValueTypeTitle{},
		}
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BarType", name)
	}
}
func (t *BarTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *BarType) VDLRead(dec vdl.Decoder) error {
	*x = BarType{
		Baz: BazType{
			TitleOrValue: TitleOrValueTypeTitle{},
		},
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Baz":
			if err = x.Baz.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x BarType) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*BarType)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Baz == BazType{
		TitleOrValue: TitleOrValueTypeTitle{},
	})
	if !(var1) {
		if err := enc.NextField("Baz"); err != nil {
			return err
		}
		if err := x.Baz.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type FooType struct {
	Bar BarType
}

func (FooType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.FooType"`
}) {
}

func (m *FooType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Bar == BarType{
		Baz: BazType{
			TitleOrValue: TitleOrValueTypeTitle{},
		},
	})
	if var4 {
		if err := fieldsTarget1.ZeroField("Bar"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Bar")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Bar.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *FooType) MakeVDLTarget() vdl.Target {
	return &FooTypeTarget{Value: m}
}

type FooTypeTarget struct {
	Value     *FooType
	barTarget BarTypeTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *FooTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*FooType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *FooTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Bar":
		t.barTarget.Value = &t.Value.Bar
		target, err := &t.barTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FooType", name)
	}
}
func (t *FooTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *FooTypeTarget) ZeroField(name string) error {
	switch name {
	case "Bar":
		t.Value.Bar = BarType{
			Baz: BazType{
				TitleOrValue: TitleOrValueTypeTitle{},
			},
		}
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FooType", name)
	}
}
func (t *FooTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *FooType) VDLRead(dec vdl.Decoder) error {
	*x = FooType{
		Bar: BarType{
			Baz: BazType{
				TitleOrValue: TitleOrValueTypeTitle{},
			},
		},
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Bar":
			if err = x.Bar.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x FooType) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*FooType)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Bar == BarType{
		Baz: BazType{
			TitleOrValue: TitleOrValueTypeTitle{},
		},
	})
	if !(var1) {
		if err := enc.NextField("Bar"); err != nil {
			return err
		}
		if err := x.Bar.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type K struct {
	A byte
	B string
}

func (K) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.K"`
}) {
}

func (m *K) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.A == byte(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("A"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromUint(uint64(m.A), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.B == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("B"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *K) MakeVDLTarget() vdl.Target {
	return &KTarget{Value: m}
}

type KTarget struct {
	Value   *K
	aTarget vdl.ByteTarget
	bTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *KTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*K)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *KTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.K", name)
	}
}
func (t *KTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *KTarget) ZeroField(name string) error {
	switch name {
	case "A":
		t.Value.A = byte(0)
		return nil
	case "B":
		t.Value.B = ""
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.K", name)
	}
}
func (t *KTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *K) VDLRead(dec vdl.Decoder) error {
	*x = K{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(8)
			if err != nil {
				return err
			}
			x.A = byte(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "B":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.B, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x K) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*K)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.A == byte(0))
	if !(var1) {
		if err := enc.NextField("A"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*byte)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(x.A)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.B == "")
	if !(var2) {
		if err := enc.NextField("B"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.B); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type V struct {
	A string
	B float32
}

func (V) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.V"`
}) {
}

func (m *V) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.A == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("A"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.A), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.B == float32(0))
	if var7 {
		if err := fieldsTarget1.ZeroField("B"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromFloat(float64(m.B), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *V) MakeVDLTarget() vdl.Target {
	return &VTarget{Value: m}
}

type VTarget struct {
	Value   *V
	aTarget vdl.StringTarget
	bTarget vdl.Float32Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *VTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*V)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *VTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.V", name)
	}
}
func (t *VTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *VTarget) ZeroField(name string) error {
	switch name {
	case "A":
		t.Value.A = ""
		return nil
	case "B":
		t.Value.B = float32(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.V", name)
	}
}
func (t *VTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *V) VDLRead(dec vdl.Decoder) error {
	*x = V{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.A, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "B":
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeFloat(32)
			if err != nil {
				return err
			}
			x.B = float32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x V) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*V)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.A == "")
	if !(var1) {
		if err := enc.NextField("A"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.A); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.B == float32(0))
	if !(var2) {
		if err := enc.NextField("B"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*float32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(float64(x.B)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type FunWithMaps struct {
	Key       K
	Map       map[K]V
	Confusing map[int16][]map[string]struct{}
}

func (FunWithMaps) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.FunWithMaps"`
}) {
}

func (m *FunWithMaps) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Key == K{})
	if var4 {
		if err := fieldsTarget1.ZeroField("Key"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Key.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if len(m.Map) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("Map"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Map")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget8, err := fieldTarget6.StartMap(tt.NonOptional().Field(1).Type, len(m.Map))
			if err != nil {
				return err
			}
			for key10, value12 := range m.Map {
				keyTarget9, err := mapTarget8.StartKey()
				if err != nil {
					return err
				}

				if err := key10.FillVDLTarget(keyTarget9, tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				valueTarget11, err := mapTarget8.FinishKeyStartField(keyTarget9)
				if err != nil {
					return err
				}

				if err := value12.FillVDLTarget(valueTarget11, tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget8.FinishField(keyTarget9, valueTarget11); err != nil {
					return err
				}
			}
			if err := fieldTarget6.FinishMap(mapTarget8); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var var15 bool
	if len(m.Confusing) == 0 {
		var15 = true
	}
	if var15 {
		if err := fieldsTarget1.ZeroField("Confusing"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("Confusing")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget16, err := fieldTarget14.StartMap(tt.NonOptional().Field(2).Type, len(m.Confusing))
			if err != nil {
				return err
			}
			for key18, value20 := range m.Confusing {
				keyTarget17, err := mapTarget16.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget17.FromInt(int64(key18), tt.NonOptional().Field(2).Type.Key()); err != nil {
					return err
				}
				valueTarget19, err := mapTarget16.FinishKeyStartField(keyTarget17)
				if err != nil {
					return err
				}

				listTarget21, err := valueTarget19.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value20))
				if err != nil {
					return err
				}
				for i, elem23 := range value20 {
					elemTarget22, err := listTarget21.StartElem(i)
					if err != nil {
						return err
					}

					setTarget24, err := elemTarget22.StartSet(tt.NonOptional().Field(2).Type.Elem().Elem(), len(elem23))
					if err != nil {
						return err
					}
					for key26 := range elem23 {
						keyTarget25, err := setTarget24.StartKey()
						if err != nil {
							return err
						}
						if err := keyTarget25.FromString(string(key26), tt.NonOptional().Field(2).Type.Elem().Elem().Key()); err != nil {
							return err
						}
						if err := setTarget24.FinishKey(keyTarget25); err != nil {
							return err
						}
					}
					if err := elemTarget22.FinishSet(setTarget24); err != nil {
						return err
					}
					if err := listTarget21.FinishElem(elemTarget22); err != nil {
						return err
					}
				}
				if err := valueTarget19.FinishList(listTarget21); err != nil {
					return err
				}
				if err := mapTarget16.FinishField(keyTarget17, valueTarget19); err != nil {
					return err
				}
			}
			if err := fieldTarget14.FinishMap(mapTarget16); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *FunWithMaps) MakeVDLTarget() vdl.Target {
	return &FunWithMapsTarget{Value: m}
}

type FunWithMapsTarget struct {
	Value           *FunWithMaps
	keyTarget       KTarget
	mapTarget       __VDLTarget4_map
	confusingTarget __VDLTarget5_map
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *FunWithMapsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*FunWithMaps)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *FunWithMapsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Key":
		t.keyTarget.Value = &t.Value.Key
		target, err := &t.keyTarget, error(nil)
		return nil, target, err
	case "Map":
		t.mapTarget.Value = &t.Value.Map
		target, err := &t.mapTarget, error(nil)
		return nil, target, err
	case "Confusing":
		t.confusingTarget.Value = &t.Value.Confusing
		target, err := &t.confusingTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FunWithMaps", name)
	}
}
func (t *FunWithMapsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *FunWithMapsTarget) ZeroField(name string) error {
	switch name {
	case "Key":
		t.Value.Key = K{}
		return nil
	case "Map":
		t.Value.Map = map[K]V(nil)
		return nil
	case "Confusing":
		t.Value.Confusing = map[int16][]map[string]struct{}(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FunWithMaps", name)
	}
}
func (t *FunWithMapsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[K]V
type __VDLTarget4_map struct {
	Value      *map[K]V
	currKey    K
	currElem   V
	keyTarget  KTarget
	elemTarget VTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget4_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[K]V)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[K]V)
	return t, nil
}
func (t *__VDLTarget4_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = K{}
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget4_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = V{}
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget4_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget4_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int16][]map[string]struct{}
type __VDLTarget5_map struct {
	Value      *map[int16][]map[string]struct{}
	currKey    int16
	currElem   []map[string]struct{}
	keyTarget  vdl.Int16Target
	elemTarget __VDLTarget6_list
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget5_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[int16][]map[string]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int16][]map[string]struct{})
	return t, nil
}
func (t *__VDLTarget5_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = int16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget5_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = []map[string]struct{}(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget5_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget5_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// []map[string]struct{}
type __VDLTarget6_list struct {
	Value      *[]map[string]struct{}
	elemTarget __VDLTarget7_set
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget6_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]map[string]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]map[string]struct{}, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget6_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget6_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget6_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

// map[string]struct{}
type __VDLTarget7_set struct {
	Value     *map[string]struct{}
	currKey   string
	keyTarget vdl.StringTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget7_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[string]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string]struct{})
	return t, nil
}
func (t *__VDLTarget7_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget7_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget7_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x *FunWithMaps) VDLRead(dec vdl.Decoder) error {
	*x = FunWithMaps{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Key":
			if err = x.Key.VDLRead(dec); err != nil {
				return err
			}
		case "Map":
			if err = __VDLRead4_map(dec, &x.Map); err != nil {
				return err
			}
		case "Confusing":
			if err = __VDLRead5_map(dec, &x.Confusing); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead4_map(dec vdl.Decoder, x *map[K]V) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[K]V
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[K]V, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key K
		{
			if err = key.VDLRead(dec); err != nil {
				return err
			}
		}
		var elem V
		{
			if err = elem.VDLRead(dec); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[K]V)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead5_map(dec vdl.Decoder, x *map[int16][]map[string]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int16][]map[string]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int16][]map[string]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			key = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem []map[string]struct{}
		{
			if err = __VDLRead6_list(dec, &elem); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int16][]map[string]struct{})
		}
		tmpMap[key] = elem
	}
}

func __VDLRead6_list(dec vdl.Decoder, x *[]map[string]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len > 0:
		*x = make([]map[string]struct{}, 0, len)
	default:
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem map[string]struct{}
		if err = __VDLRead7_set(dec, &elem); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

func __VDLRead7_set(dec vdl.Decoder, x *map[string]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func (x FunWithMaps) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*FunWithMaps)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Key == K{})
	if !(var1) {
		if err := enc.NextField("Key"); err != nil {
			return err
		}
		if err := x.Key.VDLWrite(enc); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.Map) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("Map"); err != nil {
			return err
		}
		if err := __VDLWrite4_map(enc, &x.Map); err != nil {
			return err
		}
	}
	var var3 bool
	if len(x.Confusing) == 0 {
		var3 = true
	}
	if !(var3) {
		if err := enc.NextField("Confusing"); err != nil {
			return err
		}
		if err := __VDLWrite5_map(enc, &x.Confusing); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite4_map(enc vdl.Encoder, x *map[K]V) error {
	if err := enc.StartValue(vdl.TypeOf((*map[K]V)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := key.VDLWrite(enc); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite5_map(enc vdl.Encoder, x *map[int16][]map[string]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int16][]map[string]struct{})(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := __VDLWrite6_list(enc, &elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite6_list(enc vdl.Encoder, x *[]map[string]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*[]map[string]struct{})(nil))); err != nil {
		return err
	}
	for i := 0; i < len(*x); i++ {
		if err := __VDLWrite7_set(enc, &(*x)[i]); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite7_set(enc vdl.Encoder, x *map[string]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type FunWithTypes struct {
	T1 *vdl.Type
	T2 *vdl.Type
}

func (FunWithTypes) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.FunWithTypes"`
}) {
}

func (m *FunWithTypes) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.T1 == nil || m.T1 == vdl.AnyType)
	if var4 {
		if err := fieldsTarget1.ZeroField("T1"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("T1")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			typeObjectVal5 := m.T1
			if typeObjectVal5 == nil {
				typeObjectVal5 = vdl.AnyType
			}
			if err := fieldTarget3.FromTypeObject(typeObjectVal5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var8 := (m.T2 == nil || m.T2 == vdl.AnyType)
	if var8 {
		if err := fieldsTarget1.ZeroField("T2"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("T2")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			typeObjectVal9 := m.T2
			if typeObjectVal9 == nil {
				typeObjectVal9 = vdl.AnyType
			}
			if err := fieldTarget7.FromTypeObject(typeObjectVal9); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *FunWithTypes) MakeVDLTarget() vdl.Target {
	return &FunWithTypesTarget{Value: m}
}

type FunWithTypesTarget struct {
	Value    *FunWithTypes
	t1Target vdl.TypeObjectTarget
	t2Target vdl.TypeObjectTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *FunWithTypesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*FunWithTypes)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *FunWithTypesTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "T1":
		t.t1Target.Value = &t.Value.T1
		target, err := &t.t1Target, error(nil)
		return nil, target, err
	case "T2":
		t.t2Target.Value = &t.Value.T2
		target, err := &t.t2Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FunWithTypes", name)
	}
}
func (t *FunWithTypesTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *FunWithTypesTarget) ZeroField(name string) error {
	switch name {
	case "T1":
		t.Value.T1 = vdl.AnyType
		return nil
	case "T2":
		t.Value.T2 = vdl.AnyType
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.FunWithTypes", name)
	}
}
func (t *FunWithTypesTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *FunWithTypes) VDLRead(dec vdl.Decoder) error {
	*x = FunWithTypes{
		T1: vdl.AnyType,
		T2: vdl.AnyType,
	}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "T1":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.T1, err = dec.DecodeTypeObject(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "T2":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.T2, err = dec.DecodeTypeObject(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x FunWithTypes) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*FunWithTypes)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.T1 == nil || x.T1 == vdl.AnyType)
	if !(var1) {
		if err := enc.NextField("T1"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeObjectType); err != nil {
			return err
		}
		if err := enc.EncodeTypeObject(x.T1); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	var2 := (x.T2 == nil || x.T2 == vdl.AnyType)
	if !(var2) {
		if err := enc.NextField("T2"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeObjectType); err != nil {
			return err
		}
		if err := enc.EncodeTypeObject(x.T2); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

type ManyMaps struct {
	B   map[bool]string
	By  map[byte]string
	U16 map[uint16]string
	U32 map[uint32]string
	U64 map[uint64]string
	I16 map[int16]string
	I32 map[int32]string
	I64 map[int64]string
	F32 map[float32]string
	F64 map[float64]string
	S   map[string]string
	Ms  map[string]map[string]string
	T   map[time.Time]string
}

func (ManyMaps) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.ManyMaps"`
}) {
}

func (m *ManyMaps) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.B) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("B"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.B))
			if err != nil {
				return err
			}
			for key7, value9 := range m.B {
				keyTarget6, err := mapTarget5.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget6.FromBool(bool(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
				if err != nil {
					return err
				}
				if err := valueTarget8.FromString(string(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var12 bool
	if len(m.By) == 0 {
		var12 = true
	}
	if var12 {
		if err := fieldsTarget1.ZeroField("By"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("By")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget13, err := fieldTarget11.StartMap(tt.NonOptional().Field(1).Type, len(m.By))
			if err != nil {
				return err
			}
			for key15, value17 := range m.By {
				keyTarget14, err := mapTarget13.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget14.FromUint(uint64(key15), tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
				if err != nil {
					return err
				}
				if err := valueTarget16.FromString(string(value17), tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
					return err
				}
			}
			if err := fieldTarget11.FinishMap(mapTarget13); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
				return err
			}
		}
	}
	var var20 bool
	if len(m.U16) == 0 {
		var20 = true
	}
	if var20 {
		if err := fieldsTarget1.ZeroField("U16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("U16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget21, err := fieldTarget19.StartMap(tt.NonOptional().Field(2).Type, len(m.U16))
			if err != nil {
				return err
			}
			for key23, value25 := range m.U16 {
				keyTarget22, err := mapTarget21.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget22.FromUint(uint64(key23), tt.NonOptional().Field(2).Type.Key()); err != nil {
					return err
				}
				valueTarget24, err := mapTarget21.FinishKeyStartField(keyTarget22)
				if err != nil {
					return err
				}
				if err := valueTarget24.FromString(string(value25), tt.NonOptional().Field(2).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget21.FinishField(keyTarget22, valueTarget24); err != nil {
					return err
				}
			}
			if err := fieldTarget19.FinishMap(mapTarget21); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
				return err
			}
		}
	}
	var var28 bool
	if len(m.U32) == 0 {
		var28 = true
	}
	if var28 {
		if err := fieldsTarget1.ZeroField("U32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("U32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget29, err := fieldTarget27.StartMap(tt.NonOptional().Field(3).Type, len(m.U32))
			if err != nil {
				return err
			}
			for key31, value33 := range m.U32 {
				keyTarget30, err := mapTarget29.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget30.FromUint(uint64(key31), tt.NonOptional().Field(3).Type.Key()); err != nil {
					return err
				}
				valueTarget32, err := mapTarget29.FinishKeyStartField(keyTarget30)
				if err != nil {
					return err
				}
				if err := valueTarget32.FromString(string(value33), tt.NonOptional().Field(3).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget29.FinishField(keyTarget30, valueTarget32); err != nil {
					return err
				}
			}
			if err := fieldTarget27.FinishMap(mapTarget29); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
				return err
			}
		}
	}
	var var36 bool
	if len(m.U64) == 0 {
		var36 = true
	}
	if var36 {
		if err := fieldsTarget1.ZeroField("U64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("U64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget37, err := fieldTarget35.StartMap(tt.NonOptional().Field(4).Type, len(m.U64))
			if err != nil {
				return err
			}
			for key39, value41 := range m.U64 {
				keyTarget38, err := mapTarget37.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget38.FromUint(uint64(key39), tt.NonOptional().Field(4).Type.Key()); err != nil {
					return err
				}
				valueTarget40, err := mapTarget37.FinishKeyStartField(keyTarget38)
				if err != nil {
					return err
				}
				if err := valueTarget40.FromString(string(value41), tt.NonOptional().Field(4).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget37.FinishField(keyTarget38, valueTarget40); err != nil {
					return err
				}
			}
			if err := fieldTarget35.FinishMap(mapTarget37); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
				return err
			}
		}
	}
	var var44 bool
	if len(m.I16) == 0 {
		var44 = true
	}
	if var44 {
		if err := fieldsTarget1.ZeroField("I16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("I16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget45, err := fieldTarget43.StartMap(tt.NonOptional().Field(5).Type, len(m.I16))
			if err != nil {
				return err
			}
			for key47, value49 := range m.I16 {
				keyTarget46, err := mapTarget45.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget46.FromInt(int64(key47), tt.NonOptional().Field(5).Type.Key()); err != nil {
					return err
				}
				valueTarget48, err := mapTarget45.FinishKeyStartField(keyTarget46)
				if err != nil {
					return err
				}
				if err := valueTarget48.FromString(string(value49), tt.NonOptional().Field(5).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget45.FinishField(keyTarget46, valueTarget48); err != nil {
					return err
				}
			}
			if err := fieldTarget43.FinishMap(mapTarget45); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
				return err
			}
		}
	}
	var var52 bool
	if len(m.I32) == 0 {
		var52 = true
	}
	if var52 {
		if err := fieldsTarget1.ZeroField("I32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("I32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget53, err := fieldTarget51.StartMap(tt.NonOptional().Field(6).Type, len(m.I32))
			if err != nil {
				return err
			}
			for key55, value57 := range m.I32 {
				keyTarget54, err := mapTarget53.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget54.FromInt(int64(key55), tt.NonOptional().Field(6).Type.Key()); err != nil {
					return err
				}
				valueTarget56, err := mapTarget53.FinishKeyStartField(keyTarget54)
				if err != nil {
					return err
				}
				if err := valueTarget56.FromString(string(value57), tt.NonOptional().Field(6).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget53.FinishField(keyTarget54, valueTarget56); err != nil {
					return err
				}
			}
			if err := fieldTarget51.FinishMap(mapTarget53); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
				return err
			}
		}
	}
	var var60 bool
	if len(m.I64) == 0 {
		var60 = true
	}
	if var60 {
		if err := fieldsTarget1.ZeroField("I64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget58, fieldTarget59, err := fieldsTarget1.StartField("I64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget61, err := fieldTarget59.StartMap(tt.NonOptional().Field(7).Type, len(m.I64))
			if err != nil {
				return err
			}
			for key63, value65 := range m.I64 {
				keyTarget62, err := mapTarget61.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget62.FromInt(int64(key63), tt.NonOptional().Field(7).Type.Key()); err != nil {
					return err
				}
				valueTarget64, err := mapTarget61.FinishKeyStartField(keyTarget62)
				if err != nil {
					return err
				}
				if err := valueTarget64.FromString(string(value65), tt.NonOptional().Field(7).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget61.FinishField(keyTarget62, valueTarget64); err != nil {
					return err
				}
			}
			if err := fieldTarget59.FinishMap(mapTarget61); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget58, fieldTarget59); err != nil {
				return err
			}
		}
	}
	var var68 bool
	if len(m.F32) == 0 {
		var68 = true
	}
	if var68 {
		if err := fieldsTarget1.ZeroField("F32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget66, fieldTarget67, err := fieldsTarget1.StartField("F32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget69, err := fieldTarget67.StartMap(tt.NonOptional().Field(8).Type, len(m.F32))
			if err != nil {
				return err
			}
			for key71, value73 := range m.F32 {
				keyTarget70, err := mapTarget69.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget70.FromFloat(float64(key71), tt.NonOptional().Field(8).Type.Key()); err != nil {
					return err
				}
				valueTarget72, err := mapTarget69.FinishKeyStartField(keyTarget70)
				if err != nil {
					return err
				}
				if err := valueTarget72.FromString(string(value73), tt.NonOptional().Field(8).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget69.FinishField(keyTarget70, valueTarget72); err != nil {
					return err
				}
			}
			if err := fieldTarget67.FinishMap(mapTarget69); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget66, fieldTarget67); err != nil {
				return err
			}
		}
	}
	var var76 bool
	if len(m.F64) == 0 {
		var76 = true
	}
	if var76 {
		if err := fieldsTarget1.ZeroField("F64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget74, fieldTarget75, err := fieldsTarget1.StartField("F64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget77, err := fieldTarget75.StartMap(tt.NonOptional().Field(9).Type, len(m.F64))
			if err != nil {
				return err
			}
			for key79, value81 := range m.F64 {
				keyTarget78, err := mapTarget77.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget78.FromFloat(float64(key79), tt.NonOptional().Field(9).Type.Key()); err != nil {
					return err
				}
				valueTarget80, err := mapTarget77.FinishKeyStartField(keyTarget78)
				if err != nil {
					return err
				}
				if err := valueTarget80.FromString(string(value81), tt.NonOptional().Field(9).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget77.FinishField(keyTarget78, valueTarget80); err != nil {
					return err
				}
			}
			if err := fieldTarget75.FinishMap(mapTarget77); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget74, fieldTarget75); err != nil {
				return err
			}
		}
	}
	var var84 bool
	if len(m.S) == 0 {
		var84 = true
	}
	if var84 {
		if err := fieldsTarget1.ZeroField("S"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget82, fieldTarget83, err := fieldsTarget1.StartField("S")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget85, err := fieldTarget83.StartMap(tt.NonOptional().Field(10).Type, len(m.S))
			if err != nil {
				return err
			}
			for key87, value89 := range m.S {
				keyTarget86, err := mapTarget85.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget86.FromString(string(key87), tt.NonOptional().Field(10).Type.Key()); err != nil {
					return err
				}
				valueTarget88, err := mapTarget85.FinishKeyStartField(keyTarget86)
				if err != nil {
					return err
				}
				if err := valueTarget88.FromString(string(value89), tt.NonOptional().Field(10).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget85.FinishField(keyTarget86, valueTarget88); err != nil {
					return err
				}
			}
			if err := fieldTarget83.FinishMap(mapTarget85); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget82, fieldTarget83); err != nil {
				return err
			}
		}
	}
	var var92 bool
	if len(m.Ms) == 0 {
		var92 = true
	}
	if var92 {
		if err := fieldsTarget1.ZeroField("Ms"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget90, fieldTarget91, err := fieldsTarget1.StartField("Ms")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget93, err := fieldTarget91.StartMap(tt.NonOptional().Field(11).Type, len(m.Ms))
			if err != nil {
				return err
			}
			for key95, value97 := range m.Ms {
				keyTarget94, err := mapTarget93.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget94.FromString(string(key95), tt.NonOptional().Field(11).Type.Key()); err != nil {
					return err
				}
				valueTarget96, err := mapTarget93.FinishKeyStartField(keyTarget94)
				if err != nil {
					return err
				}

				mapTarget98, err := valueTarget96.StartMap(tt.NonOptional().Field(11).Type.Elem(), len(value97))
				if err != nil {
					return err
				}
				for key100, value102 := range value97 {
					keyTarget99, err := mapTarget98.StartKey()
					if err != nil {
						return err
					}
					if err := keyTarget99.FromString(string(key100), tt.NonOptional().Field(11).Type.Elem().Key()); err != nil {
						return err
					}
					valueTarget101, err := mapTarget98.FinishKeyStartField(keyTarget99)
					if err != nil {
						return err
					}
					if err := valueTarget101.FromString(string(value102), tt.NonOptional().Field(11).Type.Elem().Elem()); err != nil {
						return err
					}
					if err := mapTarget98.FinishField(keyTarget99, valueTarget101); err != nil {
						return err
					}
				}
				if err := valueTarget96.FinishMap(mapTarget98); err != nil {
					return err
				}
				if err := mapTarget93.FinishField(keyTarget94, valueTarget96); err != nil {
					return err
				}
			}
			if err := fieldTarget91.FinishMap(mapTarget93); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget90, fieldTarget91); err != nil {
				return err
			}
		}
	}
	var var105 bool
	if len(m.T) == 0 {
		var105 = true
	}
	if var105 {
		if err := fieldsTarget1.ZeroField("T"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget103, fieldTarget104, err := fieldsTarget1.StartField("T")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			mapTarget106, err := fieldTarget104.StartMap(tt.NonOptional().Field(12).Type, len(m.T))
			if err != nil {
				return err
			}
			for key108, value110 := range m.T {
				keyTarget107, err := mapTarget106.StartKey()
				if err != nil {
					return err
				}

				var wireValue111 time_2.Time
				if err := time_2.TimeFromNative(&wireValue111, key108); err != nil {
					return err
				}

				if err := wireValue111.FillVDLTarget(keyTarget107, tt.NonOptional().Field(12).Type.Key()); err != nil {
					return err
				}
				valueTarget109, err := mapTarget106.FinishKeyStartField(keyTarget107)
				if err != nil {
					return err
				}
				if err := valueTarget109.FromString(string(value110), tt.NonOptional().Field(12).Type.Elem()); err != nil {
					return err
				}
				if err := mapTarget106.FinishField(keyTarget107, valueTarget109); err != nil {
					return err
				}
			}
			if err := fieldTarget104.FinishMap(mapTarget106); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget103, fieldTarget104); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ManyMaps) MakeVDLTarget() vdl.Target {
	return &ManyMapsTarget{Value: m}
}

type ManyMapsTarget struct {
	Value     *ManyMaps
	bTarget   __VDLTarget8_map
	byTarget  __VDLTarget9_map
	u16Target __VDLTarget10_map
	u32Target __VDLTarget11_map
	u64Target __VDLTarget12_map
	i16Target __VDLTarget13_map
	i32Target __VDLTarget14_map
	i64Target __VDLTarget15_map
	f32Target __VDLTarget16_map
	f64Target __VDLTarget17_map
	sTarget   __VDLTarget18_map
	msTarget  __VDLTarget19_map
	tTarget   __VDLTarget20_map
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ManyMapsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ManyMaps)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ManyMapsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "By":
		t.byTarget.Value = &t.Value.By
		target, err := &t.byTarget, error(nil)
		return nil, target, err
	case "U16":
		t.u16Target.Value = &t.Value.U16
		target, err := &t.u16Target, error(nil)
		return nil, target, err
	case "U32":
		t.u32Target.Value = &t.Value.U32
		target, err := &t.u32Target, error(nil)
		return nil, target, err
	case "U64":
		t.u64Target.Value = &t.Value.U64
		target, err := &t.u64Target, error(nil)
		return nil, target, err
	case "I16":
		t.i16Target.Value = &t.Value.I16
		target, err := &t.i16Target, error(nil)
		return nil, target, err
	case "I32":
		t.i32Target.Value = &t.Value.I32
		target, err := &t.i32Target, error(nil)
		return nil, target, err
	case "I64":
		t.i64Target.Value = &t.Value.I64
		target, err := &t.i64Target, error(nil)
		return nil, target, err
	case "F32":
		t.f32Target.Value = &t.Value.F32
		target, err := &t.f32Target, error(nil)
		return nil, target, err
	case "F64":
		t.f64Target.Value = &t.Value.F64
		target, err := &t.f64Target, error(nil)
		return nil, target, err
	case "S":
		t.sTarget.Value = &t.Value.S
		target, err := &t.sTarget, error(nil)
		return nil, target, err
	case "Ms":
		t.msTarget.Value = &t.Value.Ms
		target, err := &t.msTarget, error(nil)
		return nil, target, err
	case "T":
		t.tTarget.Value = &t.Value.T
		target, err := &t.tTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ManyMaps", name)
	}
}
func (t *ManyMapsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ManyMapsTarget) ZeroField(name string) error {
	switch name {
	case "B":
		t.Value.B = map[bool]string(nil)
		return nil
	case "By":
		t.Value.By = map[byte]string(nil)
		return nil
	case "U16":
		t.Value.U16 = map[uint16]string(nil)
		return nil
	case "U32":
		t.Value.U32 = map[uint32]string(nil)
		return nil
	case "U64":
		t.Value.U64 = map[uint64]string(nil)
		return nil
	case "I16":
		t.Value.I16 = map[int16]string(nil)
		return nil
	case "I32":
		t.Value.I32 = map[int32]string(nil)
		return nil
	case "I64":
		t.Value.I64 = map[int64]string(nil)
		return nil
	case "F32":
		t.Value.F32 = map[float32]string(nil)
		return nil
	case "F64":
		t.Value.F64 = map[float64]string(nil)
		return nil
	case "S":
		t.Value.S = map[string]string(nil)
		return nil
	case "Ms":
		t.Value.Ms = map[string]map[string]string(nil)
		return nil
	case "T":
		t.Value.T = map[time.Time]string(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ManyMaps", name)
	}
}
func (t *ManyMapsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[bool]string
type __VDLTarget8_map struct {
	Value      *map[bool]string
	currKey    bool
	currElem   string
	keyTarget  vdl.BoolTarget
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget8_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[bool]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[bool]string)
	return t, nil
}
func (t *__VDLTarget8_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = false
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget8_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget8_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget8_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[byte]string
type __VDLTarget9_map struct {
	Value      *map[byte]string
	currKey    byte
	currElem   string
	keyTarget  vdl.ByteTarget
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget9_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[byte]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[byte]string)
	return t, nil
}
func (t *__VDLTarget9_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = byte(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget9_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget9_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget9_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint16]string
type __VDLTarget10_map struct {
	Value      *map[uint16]string
	currKey    uint16
	currElem   string
	keyTarget  vdl.Uint16Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget10_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint16]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint16]string)
	return t, nil
}
func (t *__VDLTarget10_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget10_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget10_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget10_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint32]string
type __VDLTarget11_map struct {
	Value      *map[uint32]string
	currKey    uint32
	currElem   string
	keyTarget  vdl.Uint32Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget11_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint32]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint32]string)
	return t, nil
}
func (t *__VDLTarget11_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget11_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget11_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget11_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint64]string
type __VDLTarget12_map struct {
	Value      *map[uint64]string
	currKey    uint64
	currElem   string
	keyTarget  vdl.Uint64Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget12_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint64]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint64]string)
	return t, nil
}
func (t *__VDLTarget12_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget12_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget12_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget12_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int16]string
type __VDLTarget13_map struct {
	Value      *map[int16]string
	currKey    int16
	currElem   string
	keyTarget  vdl.Int16Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget13_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[int16]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int16]string)
	return t, nil
}
func (t *__VDLTarget13_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = int16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget13_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget13_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget13_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int32]string
type __VDLTarget14_map struct {
	Value      *map[int32]string
	currKey    int32
	currElem   string
	keyTarget  vdl.Int32Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget14_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[int32]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int32]string)
	return t, nil
}
func (t *__VDLTarget14_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = int32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget14_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget14_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget14_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int64]string
type __VDLTarget15_map struct {
	Value      *map[int64]string
	currKey    int64
	currElem   string
	keyTarget  vdl.Int64Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget15_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[int64]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int64]string)
	return t, nil
}
func (t *__VDLTarget15_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = int64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget15_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget15_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget15_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[float32]string
type __VDLTarget16_map struct {
	Value      *map[float32]string
	currKey    float32
	currElem   string
	keyTarget  vdl.Float32Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget16_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[float32]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[float32]string)
	return t, nil
}
func (t *__VDLTarget16_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = float32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget16_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget16_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget16_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[float64]string
type __VDLTarget17_map struct {
	Value      *map[float64]string
	currKey    float64
	currElem   string
	keyTarget  vdl.Float64Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget17_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[float64]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[float64]string)
	return t, nil
}
func (t *__VDLTarget17_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = float64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget17_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget17_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget17_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[string]string
type __VDLTarget18_map struct {
	Value      *map[string]string
	currKey    string
	currElem   string
	keyTarget  vdl.StringTarget
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget18_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string]string)
	return t, nil
}
func (t *__VDLTarget18_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget18_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget18_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget18_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[string]map[string]string
type __VDLTarget19_map struct {
	Value      *map[string]map[string]string
	currKey    string
	currElem   map[string]string
	keyTarget  vdl.StringTarget
	elemTarget __VDLTarget18_map
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget19_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string]map[string]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string]map[string]string)
	return t, nil
}
func (t *__VDLTarget19_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget19_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = map[string]string(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget19_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget19_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[time.Time]string
type __VDLTarget20_map struct {
	Value      *map[time.Time]string
	currKey    time.Time
	currElem   string
	keyTarget  time_2.TimeTarget
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget20_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[time.Time]string)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[time.Time]string)
	return t, nil
}
func (t *__VDLTarget20_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = reflect.Zero(reflect.TypeOf(t.currKey)).Interface().(time.Time)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget20_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget20_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget20_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x *ManyMaps) VDLRead(dec vdl.Decoder) error {
	*x = ManyMaps{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "B":
			if err = __VDLRead8_map(dec, &x.B); err != nil {
				return err
			}
		case "By":
			if err = __VDLRead9_map(dec, &x.By); err != nil {
				return err
			}
		case "U16":
			if err = __VDLRead10_map(dec, &x.U16); err != nil {
				return err
			}
		case "U32":
			if err = __VDLRead11_map(dec, &x.U32); err != nil {
				return err
			}
		case "U64":
			if err = __VDLRead12_map(dec, &x.U64); err != nil {
				return err
			}
		case "I16":
			if err = __VDLRead13_map(dec, &x.I16); err != nil {
				return err
			}
		case "I32":
			if err = __VDLRead14_map(dec, &x.I32); err != nil {
				return err
			}
		case "I64":
			if err = __VDLRead15_map(dec, &x.I64); err != nil {
				return err
			}
		case "F32":
			if err = __VDLRead16_map(dec, &x.F32); err != nil {
				return err
			}
		case "F64":
			if err = __VDLRead17_map(dec, &x.F64); err != nil {
				return err
			}
		case "S":
			if err = __VDLRead18_map(dec, &x.S); err != nil {
				return err
			}
		case "Ms":
			if err = __VDLRead19_map(dec, &x.Ms); err != nil {
				return err
			}
		case "T":
			if err = __VDLRead20_map(dec, &x.T); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead8_map(dec vdl.Decoder, x *map[bool]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[bool]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[bool]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key bool
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[bool]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead9_map(dec vdl.Decoder, x *map[byte]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[byte]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[byte]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key byte
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(8)
			if err != nil {
				return err
			}
			key = byte(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[byte]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead10_map(dec vdl.Decoder, x *map[uint16]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint16]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint16]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(16)
			if err != nil {
				return err
			}
			key = uint16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint16]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead11_map(dec vdl.Decoder, x *map[uint32]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint32]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint32]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(32)
			if err != nil {
				return err
			}
			key = uint32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint32]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead12_map(dec vdl.Decoder, x *map[uint64]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint64]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint64]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint64]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead13_map(dec vdl.Decoder, x *map[int16]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int16]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int16]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			key = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int16]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead14_map(dec vdl.Decoder, x *map[int32]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int32]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int32]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			key = int32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int32]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead15_map(dec vdl.Decoder, x *map[int64]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int64]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int64]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int64]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead16_map(dec vdl.Decoder, x *map[float32]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[float32]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[float32]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key float32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeFloat(32)
			if err != nil {
				return err
			}
			key = float32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[float32]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead17_map(dec vdl.Decoder, x *map[float64]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[float64]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[float64]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key float64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeFloat(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[float64]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead18_map(dec vdl.Decoder, x *map[string]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead19_map(dec vdl.Decoder, x *map[string]map[string]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[string]map[string]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]map[string]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		var elem map[string]string
		{
			if err = __VDLRead18_map(dec, &elem); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[string]map[string]string)
		}
		tmpMap[key] = elem
	}
}

func __VDLRead20_map(dec vdl.Decoder, x *map[time.Time]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
	}
	var tmpMap map[time.Time]string
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[time.Time]string, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key time.Time
		{
			var wire time_2.Time
			if err = wire.VDLRead(dec); err != nil {
				return err
			}
			if err = time_2.TimeToNative(wire, &key); err != nil {
				return err
			}
		}
		var elem string
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if elem, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[time.Time]string)
		}
		tmpMap[key] = elem
	}
}

func (x ManyMaps) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ManyMaps)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.B) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("B"); err != nil {
			return err
		}
		if err := __VDLWrite8_map(enc, &x.B); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.By) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("By"); err != nil {
			return err
		}
		if err := __VDLWrite9_map(enc, &x.By); err != nil {
			return err
		}
	}
	var var3 bool
	if len(x.U16) == 0 {
		var3 = true
	}
	if !(var3) {
		if err := enc.NextField("U16"); err != nil {
			return err
		}
		if err := __VDLWrite10_map(enc, &x.U16); err != nil {
			return err
		}
	}
	var var4 bool
	if len(x.U32) == 0 {
		var4 = true
	}
	if !(var4) {
		if err := enc.NextField("U32"); err != nil {
			return err
		}
		if err := __VDLWrite11_map(enc, &x.U32); err != nil {
			return err
		}
	}
	var var5 bool
	if len(x.U64) == 0 {
		var5 = true
	}
	if !(var5) {
		if err := enc.NextField("U64"); err != nil {
			return err
		}
		if err := __VDLWrite12_map(enc, &x.U64); err != nil {
			return err
		}
	}
	var var6 bool
	if len(x.I16) == 0 {
		var6 = true
	}
	if !(var6) {
		if err := enc.NextField("I16"); err != nil {
			return err
		}
		if err := __VDLWrite13_map(enc, &x.I16); err != nil {
			return err
		}
	}
	var var7 bool
	if len(x.I32) == 0 {
		var7 = true
	}
	if !(var7) {
		if err := enc.NextField("I32"); err != nil {
			return err
		}
		if err := __VDLWrite14_map(enc, &x.I32); err != nil {
			return err
		}
	}
	var var8 bool
	if len(x.I64) == 0 {
		var8 = true
	}
	if !(var8) {
		if err := enc.NextField("I64"); err != nil {
			return err
		}
		if err := __VDLWrite15_map(enc, &x.I64); err != nil {
			return err
		}
	}
	var var9 bool
	if len(x.F32) == 0 {
		var9 = true
	}
	if !(var9) {
		if err := enc.NextField("F32"); err != nil {
			return err
		}
		if err := __VDLWrite16_map(enc, &x.F32); err != nil {
			return err
		}
	}
	var var10 bool
	if len(x.F64) == 0 {
		var10 = true
	}
	if !(var10) {
		if err := enc.NextField("F64"); err != nil {
			return err
		}
		if err := __VDLWrite17_map(enc, &x.F64); err != nil {
			return err
		}
	}
	var var11 bool
	if len(x.S) == 0 {
		var11 = true
	}
	if !(var11) {
		if err := enc.NextField("S"); err != nil {
			return err
		}
		if err := __VDLWrite18_map(enc, &x.S); err != nil {
			return err
		}
	}
	var var12 bool
	if len(x.Ms) == 0 {
		var12 = true
	}
	if !(var12) {
		if err := enc.NextField("Ms"); err != nil {
			return err
		}
		if err := __VDLWrite19_map(enc, &x.Ms); err != nil {
			return err
		}
	}
	var var13 bool
	if len(x.T) == 0 {
		var13 = true
	}
	if !(var13) {
		if err := enc.NextField("T"); err != nil {
			return err
		}
		if err := __VDLWrite20_map(enc, &x.T); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite8_map(enc vdl.Encoder, x *map[bool]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[bool]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*bool)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeBool(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite9_map(enc vdl.Encoder, x *map[byte]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[byte]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*byte)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite10_map(enc vdl.Encoder, x *map[uint16]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint16]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite11_map(enc vdl.Encoder, x *map[uint32]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint32]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite12_map(enc vdl.Encoder, x *map[uint64]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint64]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite13_map(enc vdl.Encoder, x *map[int16]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int16]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite14_map(enc vdl.Encoder, x *map[int32]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int32]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite15_map(enc vdl.Encoder, x *map[int64]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int64]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite16_map(enc vdl.Encoder, x *map[float32]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[float32]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*float32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(float64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite17_map(enc vdl.Encoder, x *map[float64]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[float64]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*float64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite18_map(enc vdl.Encoder, x *map[string]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite19_map(enc vdl.Encoder, x *map[string]map[string]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[string]map[string]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
		if err := __VDLWrite18_map(enc, &elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite20_map(enc vdl.Encoder, x *map[time.Time]string) error {
	if err := enc.StartValue(vdl.TypeOf((*map[time.Time]string)(nil))); err != nil {
		return err
	}
	for key, elem := range *x {
		var wire time_2.Time
		if err := time_2.TimeFromNative(&wire, key); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(elem); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type ManySets struct {
	B   map[bool]struct{}
	By  map[byte]struct{}
	U16 map[uint16]struct{}
	U32 map[uint32]struct{}
	U64 map[uint64]struct{}
	I16 map[int16]struct{}
	I32 map[int32]struct{}
	I64 map[int64]struct{}
	F32 map[float32]struct{}
	F64 map[float64]struct{}
	S   map[string]struct{}
	T   map[time.Time]struct{}
}

func (ManySets) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.ManySets"`
}) {
}

func (m *ManySets) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.B) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("B"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.B))
			if err != nil {
				return err
			}
			for key7 := range m.B {
				keyTarget6, err := setTarget5.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget6.FromBool(bool(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
					return err
				}
				if err := setTarget5.FinishKey(keyTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishSet(setTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var10 bool
	if len(m.By) == 0 {
		var10 = true
	}
	if var10 {
		if err := fieldsTarget1.ZeroField("By"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("By")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget11, err := fieldTarget9.StartSet(tt.NonOptional().Field(1).Type, len(m.By))
			if err != nil {
				return err
			}
			for key13 := range m.By {
				keyTarget12, err := setTarget11.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget12.FromUint(uint64(key13), tt.NonOptional().Field(1).Type.Key()); err != nil {
					return err
				}
				if err := setTarget11.FinishKey(keyTarget12); err != nil {
					return err
				}
			}
			if err := fieldTarget9.FinishSet(setTarget11); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var var16 bool
	if len(m.U16) == 0 {
		var16 = true
	}
	if var16 {
		if err := fieldsTarget1.ZeroField("U16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("U16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget17, err := fieldTarget15.StartSet(tt.NonOptional().Field(2).Type, len(m.U16))
			if err != nil {
				return err
			}
			for key19 := range m.U16 {
				keyTarget18, err := setTarget17.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget18.FromUint(uint64(key19), tt.NonOptional().Field(2).Type.Key()); err != nil {
					return err
				}
				if err := setTarget17.FinishKey(keyTarget18); err != nil {
					return err
				}
			}
			if err := fieldTarget15.FinishSet(setTarget17); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
				return err
			}
		}
	}
	var var22 bool
	if len(m.U32) == 0 {
		var22 = true
	}
	if var22 {
		if err := fieldsTarget1.ZeroField("U32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("U32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget23, err := fieldTarget21.StartSet(tt.NonOptional().Field(3).Type, len(m.U32))
			if err != nil {
				return err
			}
			for key25 := range m.U32 {
				keyTarget24, err := setTarget23.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget24.FromUint(uint64(key25), tt.NonOptional().Field(3).Type.Key()); err != nil {
					return err
				}
				if err := setTarget23.FinishKey(keyTarget24); err != nil {
					return err
				}
			}
			if err := fieldTarget21.FinishSet(setTarget23); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
				return err
			}
		}
	}
	var var28 bool
	if len(m.U64) == 0 {
		var28 = true
	}
	if var28 {
		if err := fieldsTarget1.ZeroField("U64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("U64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget29, err := fieldTarget27.StartSet(tt.NonOptional().Field(4).Type, len(m.U64))
			if err != nil {
				return err
			}
			for key31 := range m.U64 {
				keyTarget30, err := setTarget29.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget30.FromUint(uint64(key31), tt.NonOptional().Field(4).Type.Key()); err != nil {
					return err
				}
				if err := setTarget29.FinishKey(keyTarget30); err != nil {
					return err
				}
			}
			if err := fieldTarget27.FinishSet(setTarget29); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
				return err
			}
		}
	}
	var var34 bool
	if len(m.I16) == 0 {
		var34 = true
	}
	if var34 {
		if err := fieldsTarget1.ZeroField("I16"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("I16")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget35, err := fieldTarget33.StartSet(tt.NonOptional().Field(5).Type, len(m.I16))
			if err != nil {
				return err
			}
			for key37 := range m.I16 {
				keyTarget36, err := setTarget35.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget36.FromInt(int64(key37), tt.NonOptional().Field(5).Type.Key()); err != nil {
					return err
				}
				if err := setTarget35.FinishKey(keyTarget36); err != nil {
					return err
				}
			}
			if err := fieldTarget33.FinishSet(setTarget35); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget32, fieldTarget33); err != nil {
				return err
			}
		}
	}
	var var40 bool
	if len(m.I32) == 0 {
		var40 = true
	}
	if var40 {
		if err := fieldsTarget1.ZeroField("I32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("I32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget41, err := fieldTarget39.StartSet(tt.NonOptional().Field(6).Type, len(m.I32))
			if err != nil {
				return err
			}
			for key43 := range m.I32 {
				keyTarget42, err := setTarget41.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget42.FromInt(int64(key43), tt.NonOptional().Field(6).Type.Key()); err != nil {
					return err
				}
				if err := setTarget41.FinishKey(keyTarget42); err != nil {
					return err
				}
			}
			if err := fieldTarget39.FinishSet(setTarget41); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
				return err
			}
		}
	}
	var var46 bool
	if len(m.I64) == 0 {
		var46 = true
	}
	if var46 {
		if err := fieldsTarget1.ZeroField("I64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("I64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget47, err := fieldTarget45.StartSet(tt.NonOptional().Field(7).Type, len(m.I64))
			if err != nil {
				return err
			}
			for key49 := range m.I64 {
				keyTarget48, err := setTarget47.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget48.FromInt(int64(key49), tt.NonOptional().Field(7).Type.Key()); err != nil {
					return err
				}
				if err := setTarget47.FinishKey(keyTarget48); err != nil {
					return err
				}
			}
			if err := fieldTarget45.FinishSet(setTarget47); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
				return err
			}
		}
	}
	var var52 bool
	if len(m.F32) == 0 {
		var52 = true
	}
	if var52 {
		if err := fieldsTarget1.ZeroField("F32"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("F32")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget53, err := fieldTarget51.StartSet(tt.NonOptional().Field(8).Type, len(m.F32))
			if err != nil {
				return err
			}
			for key55 := range m.F32 {
				keyTarget54, err := setTarget53.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget54.FromFloat(float64(key55), tt.NonOptional().Field(8).Type.Key()); err != nil {
					return err
				}
				if err := setTarget53.FinishKey(keyTarget54); err != nil {
					return err
				}
			}
			if err := fieldTarget51.FinishSet(setTarget53); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
				return err
			}
		}
	}
	var var58 bool
	if len(m.F64) == 0 {
		var58 = true
	}
	if var58 {
		if err := fieldsTarget1.ZeroField("F64"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget56, fieldTarget57, err := fieldsTarget1.StartField("F64")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget59, err := fieldTarget57.StartSet(tt.NonOptional().Field(9).Type, len(m.F64))
			if err != nil {
				return err
			}
			for key61 := range m.F64 {
				keyTarget60, err := setTarget59.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget60.FromFloat(float64(key61), tt.NonOptional().Field(9).Type.Key()); err != nil {
					return err
				}
				if err := setTarget59.FinishKey(keyTarget60); err != nil {
					return err
				}
			}
			if err := fieldTarget57.FinishSet(setTarget59); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget56, fieldTarget57); err != nil {
				return err
			}
		}
	}
	var var64 bool
	if len(m.S) == 0 {
		var64 = true
	}
	if var64 {
		if err := fieldsTarget1.ZeroField("S"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget62, fieldTarget63, err := fieldsTarget1.StartField("S")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget65, err := fieldTarget63.StartSet(tt.NonOptional().Field(10).Type, len(m.S))
			if err != nil {
				return err
			}
			for key67 := range m.S {
				keyTarget66, err := setTarget65.StartKey()
				if err != nil {
					return err
				}
				if err := keyTarget66.FromString(string(key67), tt.NonOptional().Field(10).Type.Key()); err != nil {
					return err
				}
				if err := setTarget65.FinishKey(keyTarget66); err != nil {
					return err
				}
			}
			if err := fieldTarget63.FinishSet(setTarget65); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget62, fieldTarget63); err != nil {
				return err
			}
		}
	}
	var var70 bool
	if len(m.T) == 0 {
		var70 = true
	}
	if var70 {
		if err := fieldsTarget1.ZeroField("T"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget68, fieldTarget69, err := fieldsTarget1.StartField("T")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			setTarget71, err := fieldTarget69.StartSet(tt.NonOptional().Field(11).Type, len(m.T))
			if err != nil {
				return err
			}
			for key73 := range m.T {
				keyTarget72, err := setTarget71.StartKey()
				if err != nil {
					return err
				}

				var wireValue74 time_2.Time
				if err := time_2.TimeFromNative(&wireValue74, key73); err != nil {
					return err
				}

				if err := wireValue74.FillVDLTarget(keyTarget72, tt.NonOptional().Field(11).Type.Key()); err != nil {
					return err
				}
				if err := setTarget71.FinishKey(keyTarget72); err != nil {
					return err
				}
			}
			if err := fieldTarget69.FinishSet(setTarget71); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget68, fieldTarget69); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ManySets) MakeVDLTarget() vdl.Target {
	return &ManySetsTarget{Value: m}
}

type ManySetsTarget struct {
	Value     *ManySets
	bTarget   __VDLTarget21_set
	byTarget  __VDLTarget22_set
	u16Target __VDLTarget23_set
	u32Target __VDLTarget24_set
	u64Target __VDLTarget25_set
	i16Target __VDLTarget26_set
	i32Target __VDLTarget27_set
	i64Target __VDLTarget28_set
	f32Target __VDLTarget29_set
	f64Target __VDLTarget30_set
	sTarget   __VDLTarget7_set
	tTarget   __VDLTarget31_set
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ManySetsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ManySets)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ManySetsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "By":
		t.byTarget.Value = &t.Value.By
		target, err := &t.byTarget, error(nil)
		return nil, target, err
	case "U16":
		t.u16Target.Value = &t.Value.U16
		target, err := &t.u16Target, error(nil)
		return nil, target, err
	case "U32":
		t.u32Target.Value = &t.Value.U32
		target, err := &t.u32Target, error(nil)
		return nil, target, err
	case "U64":
		t.u64Target.Value = &t.Value.U64
		target, err := &t.u64Target, error(nil)
		return nil, target, err
	case "I16":
		t.i16Target.Value = &t.Value.I16
		target, err := &t.i16Target, error(nil)
		return nil, target, err
	case "I32":
		t.i32Target.Value = &t.Value.I32
		target, err := &t.i32Target, error(nil)
		return nil, target, err
	case "I64":
		t.i64Target.Value = &t.Value.I64
		target, err := &t.i64Target, error(nil)
		return nil, target, err
	case "F32":
		t.f32Target.Value = &t.Value.F32
		target, err := &t.f32Target, error(nil)
		return nil, target, err
	case "F64":
		t.f64Target.Value = &t.Value.F64
		target, err := &t.f64Target, error(nil)
		return nil, target, err
	case "S":
		t.sTarget.Value = &t.Value.S
		target, err := &t.sTarget, error(nil)
		return nil, target, err
	case "T":
		t.tTarget.Value = &t.Value.T
		target, err := &t.tTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ManySets", name)
	}
}
func (t *ManySetsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ManySetsTarget) ZeroField(name string) error {
	switch name {
	case "B":
		t.Value.B = map[bool]struct{}(nil)
		return nil
	case "By":
		t.Value.By = map[byte]struct{}(nil)
		return nil
	case "U16":
		t.Value.U16 = map[uint16]struct{}(nil)
		return nil
	case "U32":
		t.Value.U32 = map[uint32]struct{}(nil)
		return nil
	case "U64":
		t.Value.U64 = map[uint64]struct{}(nil)
		return nil
	case "I16":
		t.Value.I16 = map[int16]struct{}(nil)
		return nil
	case "I32":
		t.Value.I32 = map[int32]struct{}(nil)
		return nil
	case "I64":
		t.Value.I64 = map[int64]struct{}(nil)
		return nil
	case "F32":
		t.Value.F32 = map[float32]struct{}(nil)
		return nil
	case "F64":
		t.Value.F64 = map[float64]struct{}(nil)
		return nil
	case "S":
		t.Value.S = map[string]struct{}(nil)
		return nil
	case "T":
		t.Value.T = map[time.Time]struct{}(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.ManySets", name)
	}
}
func (t *ManySetsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[bool]struct{}
type __VDLTarget21_set struct {
	Value     *map[bool]struct{}
	currKey   bool
	keyTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget21_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[bool]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[bool]struct{})
	return t, nil
}
func (t *__VDLTarget21_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = false
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget21_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget21_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[byte]struct{}
type __VDLTarget22_set struct {
	Value     *map[byte]struct{}
	currKey   byte
	keyTarget vdl.ByteTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget22_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[byte]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[byte]struct{})
	return t, nil
}
func (t *__VDLTarget22_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = byte(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget22_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget22_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint16]struct{}
type __VDLTarget23_set struct {
	Value     *map[uint16]struct{}
	currKey   uint16
	keyTarget vdl.Uint16Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget23_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint16]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint16]struct{})
	return t, nil
}
func (t *__VDLTarget23_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget23_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget23_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint32]struct{}
type __VDLTarget24_set struct {
	Value     *map[uint32]struct{}
	currKey   uint32
	keyTarget vdl.Uint32Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget24_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint32]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint32]struct{})
	return t, nil
}
func (t *__VDLTarget24_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget24_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget24_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[uint64]struct{}
type __VDLTarget25_set struct {
	Value     *map[uint64]struct{}
	currKey   uint64
	keyTarget vdl.Uint64Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget25_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[uint64]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[uint64]struct{})
	return t, nil
}
func (t *__VDLTarget25_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget25_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget25_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int16]struct{}
type __VDLTarget26_set struct {
	Value     *map[int16]struct{}
	currKey   int16
	keyTarget vdl.Int16Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget26_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[int16]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int16]struct{})
	return t, nil
}
func (t *__VDLTarget26_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = int16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget26_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget26_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int32]struct{}
type __VDLTarget27_set struct {
	Value     *map[int32]struct{}
	currKey   int32
	keyTarget vdl.Int32Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget27_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[int32]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int32]struct{})
	return t, nil
}
func (t *__VDLTarget27_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = int32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget27_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget27_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[int64]struct{}
type __VDLTarget28_set struct {
	Value     *map[int64]struct{}
	currKey   int64
	keyTarget vdl.Int64Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget28_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[int64]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int64]struct{})
	return t, nil
}
func (t *__VDLTarget28_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = int64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget28_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget28_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[float32]struct{}
type __VDLTarget29_set struct {
	Value     *map[float32]struct{}
	currKey   float32
	keyTarget vdl.Float32Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget29_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[float32]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[float32]struct{})
	return t, nil
}
func (t *__VDLTarget29_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = float32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget29_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget29_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[float64]struct{}
type __VDLTarget30_set struct {
	Value     *map[float64]struct{}
	currKey   float64
	keyTarget vdl.Float64Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget30_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[float64]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[float64]struct{})
	return t, nil
}
func (t *__VDLTarget30_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = float64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget30_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget30_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[time.Time]struct{}
type __VDLTarget31_set struct {
	Value     *map[time.Time]struct{}
	currKey   time.Time
	keyTarget time_2.TimeTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *__VDLTarget31_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*map[time.Time]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[time.Time]struct{})
	return t, nil
}
func (t *__VDLTarget31_set) StartKey() (key vdl.Target, _ error) {
	t.currKey = reflect.Zero(reflect.TypeOf(t.currKey)).Interface().(time.Time)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget31_set) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *__VDLTarget31_set) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

func (x *ManySets) VDLRead(dec vdl.Decoder) error {
	*x = ManySets{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "B":
			if err = __VDLRead21_set(dec, &x.B); err != nil {
				return err
			}
		case "By":
			if err = __VDLRead22_set(dec, &x.By); err != nil {
				return err
			}
		case "U16":
			if err = __VDLRead23_set(dec, &x.U16); err != nil {
				return err
			}
		case "U32":
			if err = __VDLRead24_set(dec, &x.U32); err != nil {
				return err
			}
		case "U64":
			if err = __VDLRead25_set(dec, &x.U64); err != nil {
				return err
			}
		case "I16":
			if err = __VDLRead26_set(dec, &x.I16); err != nil {
				return err
			}
		case "I32":
			if err = __VDLRead27_set(dec, &x.I32); err != nil {
				return err
			}
		case "I64":
			if err = __VDLRead28_set(dec, &x.I64); err != nil {
				return err
			}
		case "F32":
			if err = __VDLRead29_set(dec, &x.F32); err != nil {
				return err
			}
		case "F64":
			if err = __VDLRead30_set(dec, &x.F64); err != nil {
				return err
			}
		case "S":
			if err = __VDLRead7_set(dec, &x.S); err != nil {
				return err
			}
		case "T":
			if err = __VDLRead31_set(dec, &x.T); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead21_set(dec vdl.Decoder, x *map[bool]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[bool]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[bool]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key bool
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeBool(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[bool]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead22_set(dec vdl.Decoder, x *map[byte]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[byte]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[byte]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key byte
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(8)
			if err != nil {
				return err
			}
			key = byte(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[byte]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead23_set(dec vdl.Decoder, x *map[uint16]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint16]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint16]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(16)
			if err != nil {
				return err
			}
			key = uint16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint16]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead24_set(dec vdl.Decoder, x *map[uint32]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint32]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint32]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeUint(32)
			if err != nil {
				return err
			}
			key = uint32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint32]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead25_set(dec vdl.Decoder, x *map[uint64]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[uint64]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[uint64]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key uint64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[uint64]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead26_set(dec vdl.Decoder, x *map[int16]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int16]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int16]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int16
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(16)
			if err != nil {
				return err
			}
			key = int16(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int16]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead27_set(dec vdl.Decoder, x *map[int32]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int32]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int32]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeInt(32)
			if err != nil {
				return err
			}
			key = int32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int32]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead28_set(dec vdl.Decoder, x *map[int64]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[int64]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[int64]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key int64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeInt(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[int64]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead29_set(dec vdl.Decoder, x *map[float32]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[float32]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[float32]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key float32
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			tmp, err := dec.DecodeFloat(32)
			if err != nil {
				return err
			}
			key = float32(tmp)
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[float32]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead30_set(dec vdl.Decoder, x *map[float64]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[float64]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[float64]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key float64
		{
			if err = dec.StartValue(); err != nil {
				return err
			}
			if key, err = dec.DecodeFloat(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[float64]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func __VDLRead31_set(dec vdl.Decoder, x *map[time.Time]struct{}) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible set %T, from %v", *x, dec.Type())
	}
	var tmpMap map[time.Time]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[time.Time]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		}
		var key time.Time
		{
			var wire time_2.Time
			if err = wire.VDLRead(dec); err != nil {
				return err
			}
			if err = time_2.TimeToNative(wire, &key); err != nil {
				return err
			}
		}
		if tmpMap == nil {
			tmpMap = make(map[time.Time]struct{})
		}
		tmpMap[key] = struct{}{}
	}
}

func (x ManySets) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*ManySets)(nil)).Elem()); err != nil {
		return err
	}
	var var1 bool
	if len(x.B) == 0 {
		var1 = true
	}
	if !(var1) {
		if err := enc.NextField("B"); err != nil {
			return err
		}
		if err := __VDLWrite21_set(enc, &x.B); err != nil {
			return err
		}
	}
	var var2 bool
	if len(x.By) == 0 {
		var2 = true
	}
	if !(var2) {
		if err := enc.NextField("By"); err != nil {
			return err
		}
		if err := __VDLWrite22_set(enc, &x.By); err != nil {
			return err
		}
	}
	var var3 bool
	if len(x.U16) == 0 {
		var3 = true
	}
	if !(var3) {
		if err := enc.NextField("U16"); err != nil {
			return err
		}
		if err := __VDLWrite23_set(enc, &x.U16); err != nil {
			return err
		}
	}
	var var4 bool
	if len(x.U32) == 0 {
		var4 = true
	}
	if !(var4) {
		if err := enc.NextField("U32"); err != nil {
			return err
		}
		if err := __VDLWrite24_set(enc, &x.U32); err != nil {
			return err
		}
	}
	var var5 bool
	if len(x.U64) == 0 {
		var5 = true
	}
	if !(var5) {
		if err := enc.NextField("U64"); err != nil {
			return err
		}
		if err := __VDLWrite25_set(enc, &x.U64); err != nil {
			return err
		}
	}
	var var6 bool
	if len(x.I16) == 0 {
		var6 = true
	}
	if !(var6) {
		if err := enc.NextField("I16"); err != nil {
			return err
		}
		if err := __VDLWrite26_set(enc, &x.I16); err != nil {
			return err
		}
	}
	var var7 bool
	if len(x.I32) == 0 {
		var7 = true
	}
	if !(var7) {
		if err := enc.NextField("I32"); err != nil {
			return err
		}
		if err := __VDLWrite27_set(enc, &x.I32); err != nil {
			return err
		}
	}
	var var8 bool
	if len(x.I64) == 0 {
		var8 = true
	}
	if !(var8) {
		if err := enc.NextField("I64"); err != nil {
			return err
		}
		if err := __VDLWrite28_set(enc, &x.I64); err != nil {
			return err
		}
	}
	var var9 bool
	if len(x.F32) == 0 {
		var9 = true
	}
	if !(var9) {
		if err := enc.NextField("F32"); err != nil {
			return err
		}
		if err := __VDLWrite29_set(enc, &x.F32); err != nil {
			return err
		}
	}
	var var10 bool
	if len(x.F64) == 0 {
		var10 = true
	}
	if !(var10) {
		if err := enc.NextField("F64"); err != nil {
			return err
		}
		if err := __VDLWrite30_set(enc, &x.F64); err != nil {
			return err
		}
	}
	var var11 bool
	if len(x.S) == 0 {
		var11 = true
	}
	if !(var11) {
		if err := enc.NextField("S"); err != nil {
			return err
		}
		if err := __VDLWrite7_set(enc, &x.S); err != nil {
			return err
		}
	}
	var var12 bool
	if len(x.T) == 0 {
		var12 = true
	}
	if !(var12) {
		if err := enc.NextField("T"); err != nil {
			return err
		}
		if err := __VDLWrite31_set(enc, &x.T); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite21_set(enc vdl.Encoder, x *map[bool]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[bool]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*bool)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeBool(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite22_set(enc vdl.Encoder, x *map[byte]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[byte]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*byte)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite23_set(enc vdl.Encoder, x *map[uint16]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint16]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite24_set(enc vdl.Encoder, x *map[uint32]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint32]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(uint64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite25_set(enc vdl.Encoder, x *map[uint64]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[uint64]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*uint64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeUint(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite26_set(enc vdl.Encoder, x *map[int16]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int16]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int16)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite27_set(enc vdl.Encoder, x *map[int32]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int32]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(int64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite28_set(enc vdl.Encoder, x *map[int64]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[int64]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*int64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeInt(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite29_set(enc vdl.Encoder, x *map[float32]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[float32]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*float32)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(float64(key)); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite30_set(enc vdl.Encoder, x *map[float64]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[float64]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		if err := enc.StartValue(vdl.TypeOf((*float64)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeFloat(key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWrite31_set(enc vdl.Encoder, x *map[time.Time]struct{}) error {
	if err := enc.StartValue(vdl.TypeOf((*map[time.Time]struct{})(nil))); err != nil {
		return err
	}
	for key := range *x {
		var wire time_2.Time
		if err := time_2.TimeFromNative(&wire, key); err != nil {
			return err
		}
		if err := wire.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

type BigData struct {
	Key string // A dup of the key stored in the value.
}

func (BigData) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/query/engine/internal/testdata.BigData"`
}) {
}

func (m *BigData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Key == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("Key"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *BigData) MakeVDLTarget() vdl.Target {
	return &BigDataTarget{Value: m}
}

type BigDataTarget struct {
	Value     *BigData
	keyTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BigDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*BigData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *BigDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Key":
		t.keyTarget.Value = &t.Value.Key
		target, err := &t.keyTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BigData", name)
	}
}
func (t *BigDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *BigDataTarget) ZeroField(name string) error {
	switch name {
	case "Key":
		t.Value.Key = ""
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/v23/query/engine/internal/testdata.BigData", name)
	}
}
func (t *BigDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *BigData) VDLRead(dec vdl.Decoder) error {
	*x = BigData{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Key":
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Key, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func (x BigData) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(vdl.TypeOf((*BigData)(nil)).Elem()); err != nil {
		return err
	}
	var1 := (x.Key == "")
	if !(var1) {
		if err := enc.NextField("Key"); err != nil {
			return err
		}
		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
			return err
		}
		if err := enc.EncodeString(x.Key); err != nil {
			return err
		}
		if err := enc.FinishValue(); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*AddressInfo)(nil))
	vdl.Register((*CreditAgency)(nil))
	vdl.Register((*ExperianRating)(nil))
	vdl.Register((*RatingsArray)(nil))
	vdl.Register((*EquifaxCreditReport)(nil))
	vdl.Register((*Tdh)(nil))
	vdl.Register((*ExperianCreditReport)(nil))
	vdl.Register((*TransUnionCreditReport)(nil))
	vdl.Register((*AgencyReport)(nil))
	vdl.Register((*CreditReport)(nil))
	vdl.Register((*Customer)(nil))
	vdl.Register((*Invoice)(nil))
	vdl.Register((*Numbers)(nil))
	vdl.Register((*TitleOrValueType)(nil))
	vdl.Register((*BazType)(nil))
	vdl.Register((*BarType)(nil))
	vdl.Register((*FooType)(nil))
	vdl.Register((*K)(nil))
	vdl.Register((*V)(nil))
	vdl.Register((*FunWithMaps)(nil))
	vdl.Register((*FunWithTypes)(nil))
	vdl.Register((*ManyMaps)(nil))
	vdl.Register((*ManySets)(nil))
	vdl.Register((*BigData)(nil))

	return struct{}{}
}