// Code generated by go run gob_gen.go; DO NOT EDIT.

package cc

import (
	"bytes"
	"github.com/google/blueprint/gobtools"
)

func init() {
	SanitizeUserPropsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SanitizeUserProps) })
	PlatformSanitizeableInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PlatformSanitizeableInfo) })
	SanitizerRuntimeDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SanitizerRuntimeDepInfo) })
}

func (r SanitizeUserProps) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	val1 := r.Never == nil
	if err = gobtools.EncodeSimple(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = gobtools.EncodeSimple(buf, (*r.Never)); err != nil {
			return err
		}
	}

	val2 := r.Address == nil
	if err = gobtools.EncodeSimple(buf, val2); err != nil {
		return err
	}
	if !val2 {
		if err = gobtools.EncodeSimple(buf, (*r.Address)); err != nil {
			return err
		}
	}

	val3 := r.Thread == nil
	if err = gobtools.EncodeSimple(buf, val3); err != nil {
		return err
	}
	if !val3 {
		if err = gobtools.EncodeSimple(buf, (*r.Thread)); err != nil {
			return err
		}
	}

	val4 := r.Hwaddress == nil
	if err = gobtools.EncodeSimple(buf, val4); err != nil {
		return err
	}
	if !val4 {
		if err = gobtools.EncodeSimple(buf, (*r.Hwaddress)); err != nil {
			return err
		}
	}

	val5 := r.All_undefined == nil
	if err = gobtools.EncodeSimple(buf, val5); err != nil {
		return err
	}
	if !val5 {
		if err = gobtools.EncodeSimple(buf, (*r.All_undefined)); err != nil {
			return err
		}
	}

	val6 := r.Undefined == nil
	if err = gobtools.EncodeSimple(buf, val6); err != nil {
		return err
	}
	if !val6 {
		if err = gobtools.EncodeSimple(buf, (*r.Undefined)); err != nil {
			return err
		}
	}

	if r.Misc_undefined == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Misc_undefined))); err != nil {
			return err
		}
		for val7 := 0; val7 < len(r.Misc_undefined); val7++ {
			if err = gobtools.EncodeString(buf, r.Misc_undefined[val7]); err != nil {
				return err
			}
		}
	}

	val8 := r.Fuzzer == nil
	if err = gobtools.EncodeSimple(buf, val8); err != nil {
		return err
	}
	if !val8 {
		if err = gobtools.EncodeSimple(buf, (*r.Fuzzer)); err != nil {
			return err
		}
	}

	val9 := r.Safestack == nil
	if err = gobtools.EncodeSimple(buf, val9); err != nil {
		return err
	}
	if !val9 {
		if err = gobtools.EncodeSimple(buf, (*r.Safestack)); err != nil {
			return err
		}
	}

	val10 := r.Cfi == nil
	if err = gobtools.EncodeSimple(buf, val10); err != nil {
		return err
	}
	if !val10 {
		if err = gobtools.EncodeSimple(buf, (*r.Cfi)); err != nil {
			return err
		}
	}

	val11 := r.Integer_overflow == nil
	if err = gobtools.EncodeSimple(buf, val11); err != nil {
		return err
	}
	if !val11 {
		if err = gobtools.EncodeSimple(buf, (*r.Integer_overflow)); err != nil {
			return err
		}
	}

	val12 := r.Scudo == nil
	if err = gobtools.EncodeSimple(buf, val12); err != nil {
		return err
	}
	if !val12 {
		if err = gobtools.EncodeSimple(buf, (*r.Scudo)); err != nil {
			return err
		}
	}

	val13 := r.Scs == nil
	if err = gobtools.EncodeSimple(buf, val13); err != nil {
		return err
	}
	if !val13 {
		if err = gobtools.EncodeSimple(buf, (*r.Scs)); err != nil {
			return err
		}
	}

	val14 := r.Memtag_heap == nil
	if err = gobtools.EncodeSimple(buf, val14); err != nil {
		return err
	}
	if !val14 {
		if err = gobtools.EncodeSimple(buf, (*r.Memtag_heap)); err != nil {
			return err
		}
	}

	val15 := r.Memtag_stack == nil
	if err = gobtools.EncodeSimple(buf, val15); err != nil {
		return err
	}
	if !val15 {
		if err = gobtools.EncodeSimple(buf, (*r.Memtag_stack)); err != nil {
			return err
		}
	}

	val16 := r.Memtag_globals == nil
	if err = gobtools.EncodeSimple(buf, val16); err != nil {
		return err
	}
	if !val16 {
		if err = gobtools.EncodeSimple(buf, (*r.Memtag_globals)); err != nil {
			return err
		}
	}

	val17 := r.Writeonly == nil
	if err = gobtools.EncodeSimple(buf, val17); err != nil {
		return err
	}
	if !val17 {
		if err = gobtools.EncodeSimple(buf, (*r.Writeonly)); err != nil {
			return err
		}
	}

	val18 := r.Diag.Undefined == nil
	if err = gobtools.EncodeSimple(buf, val18); err != nil {
		return err
	}
	if !val18 {
		if err = gobtools.EncodeSimple(buf, (*r.Diag.Undefined)); err != nil {
			return err
		}
	}

	val19 := r.Diag.Cfi == nil
	if err = gobtools.EncodeSimple(buf, val19); err != nil {
		return err
	}
	if !val19 {
		if err = gobtools.EncodeSimple(buf, (*r.Diag.Cfi)); err != nil {
			return err
		}
	}

	val20 := r.Diag.Integer_overflow == nil
	if err = gobtools.EncodeSimple(buf, val20); err != nil {
		return err
	}
	if !val20 {
		if err = gobtools.EncodeSimple(buf, (*r.Diag.Integer_overflow)); err != nil {
			return err
		}
	}

	val21 := r.Diag.Memtag_heap == nil
	if err = gobtools.EncodeSimple(buf, val21); err != nil {
		return err
	}
	if !val21 {
		if err = gobtools.EncodeSimple(buf, (*r.Diag.Memtag_heap)); err != nil {
			return err
		}
	}

	if r.Diag.Misc_undefined == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Diag.Misc_undefined))); err != nil {
			return err
		}
		for val22 := 0; val22 < len(r.Diag.Misc_undefined); val22++ {
			if err = gobtools.EncodeString(buf, r.Diag.Misc_undefined[val22]); err != nil {
				return err
			}
		}
	}

	if r.Diag.No_recover == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Diag.No_recover))); err != nil {
			return err
		}
		for val23 := 0; val23 < len(r.Diag.No_recover); val23++ {
			if err = gobtools.EncodeString(buf, r.Diag.No_recover[val23]); err != nil {
				return err
			}
		}
	}

	val24 := r.Config.Cfi_assembly_support == nil
	if err = gobtools.EncodeSimple(buf, val24); err != nil {
		return err
	}
	if !val24 {
		if err = gobtools.EncodeSimple(buf, (*r.Config.Cfi_assembly_support)); err != nil {
			return err
		}
	}

	if r.Recover == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Recover))); err != nil {
			return err
		}
		for val25 := 0; val25 < len(r.Recover); val25++ {
			if err = gobtools.EncodeString(buf, r.Recover[val25]); err != nil {
				return err
			}
		}
	}

	val26 := r.Blocklist == nil
	if err = gobtools.EncodeSimple(buf, val26); err != nil {
		return err
	}
	if !val26 {
		if err = gobtools.EncodeString(buf, (*r.Blocklist)); err != nil {
			return err
		}
	}
	return err
}

func (r *SanitizeUserProps) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 bool
		err = gobtools.DecodeSimple[bool](buf, &val1)
		if err != nil {
			return err
		}
		r.Never = &val1
	}

	var val5 bool
	if err = gobtools.DecodeSimple(buf, &val5); err != nil {
		return err
	}
	if !val5 {
		var val4 bool
		err = gobtools.DecodeSimple[bool](buf, &val4)
		if err != nil {
			return err
		}
		r.Address = &val4
	}

	var val8 bool
	if err = gobtools.DecodeSimple(buf, &val8); err != nil {
		return err
	}
	if !val8 {
		var val7 bool
		err = gobtools.DecodeSimple[bool](buf, &val7)
		if err != nil {
			return err
		}
		r.Thread = &val7
	}

	var val11 bool
	if err = gobtools.DecodeSimple(buf, &val11); err != nil {
		return err
	}
	if !val11 {
		var val10 bool
		err = gobtools.DecodeSimple[bool](buf, &val10)
		if err != nil {
			return err
		}
		r.Hwaddress = &val10
	}

	var val14 bool
	if err = gobtools.DecodeSimple(buf, &val14); err != nil {
		return err
	}
	if !val14 {
		var val13 bool
		err = gobtools.DecodeSimple[bool](buf, &val13)
		if err != nil {
			return err
		}
		r.All_undefined = &val13
	}

	var val17 bool
	if err = gobtools.DecodeSimple(buf, &val17); err != nil {
		return err
	}
	if !val17 {
		var val16 bool
		err = gobtools.DecodeSimple[bool](buf, &val16)
		if err != nil {
			return err
		}
		r.Undefined = &val16
	}

	var val20 int32
	err = gobtools.DecodeSimple[int32](buf, &val20)
	if err != nil {
		return err
	}
	if val20 != -1 {
		r.Misc_undefined = make([]string, val20)
		for val21 := 0; val21 < int(val20); val21++ {
			err = gobtools.DecodeString(buf, &r.Misc_undefined[val21])
			if err != nil {
				return err
			}
		}
	}

	var val24 bool
	if err = gobtools.DecodeSimple(buf, &val24); err != nil {
		return err
	}
	if !val24 {
		var val23 bool
		err = gobtools.DecodeSimple[bool](buf, &val23)
		if err != nil {
			return err
		}
		r.Fuzzer = &val23
	}

	var val27 bool
	if err = gobtools.DecodeSimple(buf, &val27); err != nil {
		return err
	}
	if !val27 {
		var val26 bool
		err = gobtools.DecodeSimple[bool](buf, &val26)
		if err != nil {
			return err
		}
		r.Safestack = &val26
	}

	var val30 bool
	if err = gobtools.DecodeSimple(buf, &val30); err != nil {
		return err
	}
	if !val30 {
		var val29 bool
		err = gobtools.DecodeSimple[bool](buf, &val29)
		if err != nil {
			return err
		}
		r.Cfi = &val29
	}

	var val33 bool
	if err = gobtools.DecodeSimple(buf, &val33); err != nil {
		return err
	}
	if !val33 {
		var val32 bool
		err = gobtools.DecodeSimple[bool](buf, &val32)
		if err != nil {
			return err
		}
		r.Integer_overflow = &val32
	}

	var val36 bool
	if err = gobtools.DecodeSimple(buf, &val36); err != nil {
		return err
	}
	if !val36 {
		var val35 bool
		err = gobtools.DecodeSimple[bool](buf, &val35)
		if err != nil {
			return err
		}
		r.Scudo = &val35
	}

	var val39 bool
	if err = gobtools.DecodeSimple(buf, &val39); err != nil {
		return err
	}
	if !val39 {
		var val38 bool
		err = gobtools.DecodeSimple[bool](buf, &val38)
		if err != nil {
			return err
		}
		r.Scs = &val38
	}

	var val42 bool
	if err = gobtools.DecodeSimple(buf, &val42); err != nil {
		return err
	}
	if !val42 {
		var val41 bool
		err = gobtools.DecodeSimple[bool](buf, &val41)
		if err != nil {
			return err
		}
		r.Memtag_heap = &val41
	}

	var val45 bool
	if err = gobtools.DecodeSimple(buf, &val45); err != nil {
		return err
	}
	if !val45 {
		var val44 bool
		err = gobtools.DecodeSimple[bool](buf, &val44)
		if err != nil {
			return err
		}
		r.Memtag_stack = &val44
	}

	var val48 bool
	if err = gobtools.DecodeSimple(buf, &val48); err != nil {
		return err
	}
	if !val48 {
		var val47 bool
		err = gobtools.DecodeSimple[bool](buf, &val47)
		if err != nil {
			return err
		}
		r.Memtag_globals = &val47
	}

	var val51 bool
	if err = gobtools.DecodeSimple(buf, &val51); err != nil {
		return err
	}
	if !val51 {
		var val50 bool
		err = gobtools.DecodeSimple[bool](buf, &val50)
		if err != nil {
			return err
		}
		r.Writeonly = &val50
	}

	var val55 bool
	if err = gobtools.DecodeSimple(buf, &val55); err != nil {
		return err
	}
	if !val55 {
		var val54 bool
		err = gobtools.DecodeSimple[bool](buf, &val54)
		if err != nil {
			return err
		}
		r.Diag.Undefined = &val54
	}

	var val58 bool
	if err = gobtools.DecodeSimple(buf, &val58); err != nil {
		return err
	}
	if !val58 {
		var val57 bool
		err = gobtools.DecodeSimple[bool](buf, &val57)
		if err != nil {
			return err
		}
		r.Diag.Cfi = &val57
	}

	var val61 bool
	if err = gobtools.DecodeSimple(buf, &val61); err != nil {
		return err
	}
	if !val61 {
		var val60 bool
		err = gobtools.DecodeSimple[bool](buf, &val60)
		if err != nil {
			return err
		}
		r.Diag.Integer_overflow = &val60
	}

	var val64 bool
	if err = gobtools.DecodeSimple(buf, &val64); err != nil {
		return err
	}
	if !val64 {
		var val63 bool
		err = gobtools.DecodeSimple[bool](buf, &val63)
		if err != nil {
			return err
		}
		r.Diag.Memtag_heap = &val63
	}

	var val67 int32
	err = gobtools.DecodeSimple[int32](buf, &val67)
	if err != nil {
		return err
	}
	if val67 != -1 {
		r.Diag.Misc_undefined = make([]string, val67)
		for val68 := 0; val68 < int(val67); val68++ {
			err = gobtools.DecodeString(buf, &r.Diag.Misc_undefined[val68])
			if err != nil {
				return err
			}
		}
	}

	var val71 int32
	err = gobtools.DecodeSimple[int32](buf, &val71)
	if err != nil {
		return err
	}
	if val71 != -1 {
		r.Diag.No_recover = make([]string, val71)
		for val72 := 0; val72 < int(val71); val72++ {
			err = gobtools.DecodeString(buf, &r.Diag.No_recover[val72])
			if err != nil {
				return err
			}
		}
	}

	var val76 bool
	if err = gobtools.DecodeSimple(buf, &val76); err != nil {
		return err
	}
	if !val76 {
		var val75 bool
		err = gobtools.DecodeSimple[bool](buf, &val75)
		if err != nil {
			return err
		}
		r.Config.Cfi_assembly_support = &val75
	}

	var val79 int32
	err = gobtools.DecodeSimple[int32](buf, &val79)
	if err != nil {
		return err
	}
	if val79 != -1 {
		r.Recover = make([]string, val79)
		for val80 := 0; val80 < int(val79); val80++ {
			err = gobtools.DecodeString(buf, &r.Recover[val80])
			if err != nil {
				return err
			}
		}
	}

	var val83 bool
	if err = gobtools.DecodeSimple(buf, &val83); err != nil {
		return err
	}
	if !val83 {
		var val82 string
		err = gobtools.DecodeString(buf, &val82)
		if err != nil {
			return err
		}
		r.Blocklist = &val82
	}

	return err
}

var SanitizeUserPropsGobRegId int16

func (r SanitizeUserProps) GetTypeId() int16 {
	return SanitizeUserPropsGobRegId
}

func (r PlatformSanitizeableInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.IsSanitizerEnabled == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.IsSanitizerEnabled))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.IsSanitizerEnabled); val1++ {
			if err = gobtools.EncodeSimple(buf, r.IsSanitizerEnabled[val1]); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *PlatformSanitizeableInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 int32
	err = gobtools.DecodeSimple[int32](buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.IsSanitizerEnabled = make([]bool, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeSimple[bool](buf, &r.IsSanitizerEnabled[val3])
			if err != nil {
				return err
			}
		}
	}

	return err
}

var PlatformSanitizeableInfoGobRegId int16

func (r PlatformSanitizeableInfo) GetTypeId() int16 {
	return PlatformSanitizeableInfoGobRegId
}

func (r SanitizerRuntimeDepInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeSimple(buf, r.MinimalRuntimeNeeded); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.UbsanRuntimeNeeded); err != nil {
		return err
	}
	return err
}

func (r *SanitizerRuntimeDepInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeSimple[bool](buf, &r.MinimalRuntimeNeeded)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[bool](buf, &r.UbsanRuntimeNeeded)
	if err != nil {
		return err
	}

	return err
}

var SanitizerRuntimeDepInfoGobRegId int16

func (r SanitizerRuntimeDepInfo) GetTypeId() int16 {
	return SanitizerRuntimeDepInfoGobRegId
}