// Code generated by goderive DO NOT EDIT.

package test

import (
	"bytes"
	"fmt"
	extra "github.com/awalterschulze/goderive/test/extra"
	pickle "github.com/awalterschulze/goderive/test/nickname"
	"math"
	"reflect"
	"sort"
	"strings"
	"sync"
	"time"
	"unsafe"
)

// deriveTakeWhile returns the prefix of the list, where each item matches the predicate.
//
// Deprecated: In favour of generics.
func deriveTakeWhile(predicate func(int) bool, list []int) []int {
	out := make([]int, 0, len(list))
	for i, elem := range list {
		if !predicate(elem) {
			break
		}
		out = append(out, list[i])
	}
	return out
}

// deriveIntersectSetOfInt64s returns the intersection of the two maps' keys.
//
// Deprecated: In favour of generics.
func deriveIntersectSetOfInt64s(this, that map[int64]struct{}) map[int64]struct{} {
	intersect := make(map[int64]struct{}, deriveMinInt(len(this), len(that)))
	for k := range this {
		if _, ok := that[k]; ok {
			intersect[k] = struct{}{}
		}
	}
	return intersect
}

// deriveIntersectOfInt64s returns the intersection of the two lists' values
// It assumes that the first list only contains unique items.
//
// Deprecated: In favour of generics.
func deriveIntersectOfInt64s(this, that []int64) []int64 {
	intersect := make([]int64, 0, deriveMinInt(len(this), len(that)))
	for i, v := range this {
		if deriveContainsInt64s(that, v) {
			intersect = append(intersect, this[i])
		}
	}
	return intersect
}

// deriveTraverse returns a list where each element of the input list has been morphed by the input function or an error.
func deriveTraverse(f func(string) (int, error), list []string) ([]int, error) {
	out := make([]int, len(list))
	var err error
	for i, elem := range list {
		out[i], err = f(elem)
		if err != nil {
			return nil, err
		}
	}
	return out, nil
}

// derivePipeline composes f and g into a concurrent pipeline.
func derivePipeline(f func(lines []string) <-chan string, g func(line string) <-chan int) func([]string) <-chan int {
	return func(a []string) <-chan int {
		b := f(a)
		return deriveJoinChannels(deriveFmapChanChan(g, b))
	}
}

// deriveGoStringEmpty returns a recursive representation of this as a valid go string.
func deriveGoStringEmpty(this *Empty) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Empty {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "return &test.Empty{}\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringBuiltInTypes(this *BuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.BuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.BuiltInTypes{}\n")
		fmt.Fprintf(buf, "this.Bool = %#v\n", this.Bool)
		fmt.Fprintf(buf, "this.Byte = %#v\n", this.Byte)
		fmt.Fprintf(buf, "this.Complex128 = %#v\n", this.Complex128)
		fmt.Fprintf(buf, "this.Complex64 = %#v\n", this.Complex64)
		fmt.Fprintf(buf, "this.Float64 = %#v\n", this.Float64)
		fmt.Fprintf(buf, "this.Float32 = %#v\n", this.Float32)
		fmt.Fprintf(buf, "this.Int = %#v\n", this.Int)
		fmt.Fprintf(buf, "this.Int16 = %#v\n", this.Int16)
		fmt.Fprintf(buf, "this.Int32 = %#v\n", this.Int32)
		fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
		fmt.Fprintf(buf, "this.Int8 = %#v\n", this.Int8)
		fmt.Fprintf(buf, "this.Rune = %#v\n", this.Rune)
		fmt.Fprintf(buf, "this.String = %#v\n", this.String)
		fmt.Fprintf(buf, "this.Uint = %#v\n", this.Uint)
		fmt.Fprintf(buf, "this.Uint16 = %#v\n", this.Uint16)
		fmt.Fprintf(buf, "this.Uint32 = %#v\n", this.Uint32)
		fmt.Fprintf(buf, "this.Uint64 = %#v\n", this.Uint64)
		fmt.Fprintf(buf, "this.Uint8 = %#v\n", this.Uint8)
		fmt.Fprintf(buf, "this.UintPtr = %#v\n", this.UintPtr)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringPtrToBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringPtrToBuiltInTypes(this *PtrToBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.PtrToBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.PtrToBuiltInTypes{}\n")
		if this.Bool != nil {
			fmt.Fprintf(buf, "this.Bool = func (v bool) *bool { return &v }(%#v)\n", *this.Bool)
		}
		if this.Byte != nil {
			fmt.Fprintf(buf, "this.Byte = func (v byte) *byte { return &v }(%#v)\n", *this.Byte)
		}
		if this.Complex128 != nil {
			fmt.Fprintf(buf, "this.Complex128 = func (v complex128) *complex128 { return &v }(%#v)\n", *this.Complex128)
		}
		if this.Complex64 != nil {
			fmt.Fprintf(buf, "this.Complex64 = func (v complex64) *complex64 { return &v }(%#v)\n", *this.Complex64)
		}
		if this.Float64 != nil {
			fmt.Fprintf(buf, "this.Float64 = func (v float64) *float64 { return &v }(%#v)\n", *this.Float64)
		}
		if this.Float32 != nil {
			fmt.Fprintf(buf, "this.Float32 = func (v float32) *float32 { return &v }(%#v)\n", *this.Float32)
		}
		if this.Int != nil {
			fmt.Fprintf(buf, "this.Int = func (v int) *int { return &v }(%#v)\n", *this.Int)
		}
		if this.Int16 != nil {
			fmt.Fprintf(buf, "this.Int16 = func (v int16) *int16 { return &v }(%#v)\n", *this.Int16)
		}
		if this.Int32 != nil {
			fmt.Fprintf(buf, "this.Int32 = func (v int32) *int32 { return &v }(%#v)\n", *this.Int32)
		}
		if this.Int64 != nil {
			fmt.Fprintf(buf, "this.Int64 = func (v int64) *int64 { return &v }(%#v)\n", *this.Int64)
		}
		if this.Int8 != nil {
			fmt.Fprintf(buf, "this.Int8 = func (v int8) *int8 { return &v }(%#v)\n", *this.Int8)
		}
		if this.Rune != nil {
			fmt.Fprintf(buf, "this.Rune = func (v rune) *rune { return &v }(%#v)\n", *this.Rune)
		}
		if this.String != nil {
			fmt.Fprintf(buf, "this.String = func (v string) *string { return &v }(%#v)\n", *this.String)
		}
		if this.Uint != nil {
			fmt.Fprintf(buf, "this.Uint = func (v uint) *uint { return &v }(%#v)\n", *this.Uint)
		}
		if this.Uint16 != nil {
			fmt.Fprintf(buf, "this.Uint16 = func (v uint16) *uint16 { return &v }(%#v)\n", *this.Uint16)
		}
		if this.Uint32 != nil {
			fmt.Fprintf(buf, "this.Uint32 = func (v uint32) *uint32 { return &v }(%#v)\n", *this.Uint32)
		}
		if this.Uint64 != nil {
			fmt.Fprintf(buf, "this.Uint64 = func (v uint64) *uint64 { return &v }(%#v)\n", *this.Uint64)
		}
		if this.Uint8 != nil {
			fmt.Fprintf(buf, "this.Uint8 = func (v uint8) *uint8 { return &v }(%#v)\n", *this.Uint8)
		}
		if this.UintPtr != nil {
			fmt.Fprintf(buf, "this.UintPtr = func (v uintptr) *uintptr { return &v }(%#v)\n", *this.UintPtr)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringSliceOfBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringSliceOfBuiltInTypes(this *SliceOfBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.SliceOfBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.SliceOfBuiltInTypes{}\n")
		if this.Bool != nil {
			fmt.Fprintf(buf, "this.Bool = %#v\n", this.Bool)
		}
		if this.Byte != nil {
			fmt.Fprintf(buf, "this.Byte = %#v\n", this.Byte)
		}
		if this.Complex128 != nil {
			fmt.Fprintf(buf, "this.Complex128 = %#v\n", this.Complex128)
		}
		if this.Complex64 != nil {
			fmt.Fprintf(buf, "this.Complex64 = %#v\n", this.Complex64)
		}
		if this.Float64 != nil {
			fmt.Fprintf(buf, "this.Float64 = %#v\n", this.Float64)
		}
		if this.Float32 != nil {
			fmt.Fprintf(buf, "this.Float32 = %#v\n", this.Float32)
		}
		if this.Int != nil {
			fmt.Fprintf(buf, "this.Int = %#v\n", this.Int)
		}
		if this.Int16 != nil {
			fmt.Fprintf(buf, "this.Int16 = %#v\n", this.Int16)
		}
		if this.Int32 != nil {
			fmt.Fprintf(buf, "this.Int32 = %#v\n", this.Int32)
		}
		if this.Int64 != nil {
			fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
		}
		if this.Int8 != nil {
			fmt.Fprintf(buf, "this.Int8 = %#v\n", this.Int8)
		}
		if this.Rune != nil {
			fmt.Fprintf(buf, "this.Rune = %#v\n", this.Rune)
		}
		if this.String != nil {
			fmt.Fprintf(buf, "this.String = %#v\n", this.String)
		}
		if this.Uint != nil {
			fmt.Fprintf(buf, "this.Uint = %#v\n", this.Uint)
		}
		if this.Uint16 != nil {
			fmt.Fprintf(buf, "this.Uint16 = %#v\n", this.Uint16)
		}
		if this.Uint32 != nil {
			fmt.Fprintf(buf, "this.Uint32 = %#v\n", this.Uint32)
		}
		if this.Uint64 != nil {
			fmt.Fprintf(buf, "this.Uint64 = %#v\n", this.Uint64)
		}
		if this.Uint8 != nil {
			fmt.Fprintf(buf, "this.Uint8 = %#v\n", this.Uint8)
		}
		if this.UintPtr != nil {
			fmt.Fprintf(buf, "this.UintPtr = %#v\n", this.UintPtr)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringSliceOfPtrToBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringSliceOfPtrToBuiltInTypes(this *SliceOfPtrToBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.SliceOfPtrToBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.SliceOfPtrToBuiltInTypes{}\n")
		if this.Bool != nil {
			fmt.Fprintf(buf, "this.Bool = %s\n", deriveGoString(this.Bool))
		}
		if this.Byte != nil {
			fmt.Fprintf(buf, "this.Byte = %s\n", deriveGoString_(this.Byte))
		}
		if this.Complex128 != nil {
			fmt.Fprintf(buf, "this.Complex128 = %s\n", deriveGoString_1(this.Complex128))
		}
		if this.Complex64 != nil {
			fmt.Fprintf(buf, "this.Complex64 = %s\n", deriveGoString_2(this.Complex64))
		}
		if this.Float64 != nil {
			fmt.Fprintf(buf, "this.Float64 = %s\n", deriveGoString_3(this.Float64))
		}
		if this.Float32 != nil {
			fmt.Fprintf(buf, "this.Float32 = %s\n", deriveGoString_4(this.Float32))
		}
		if this.Int != nil {
			fmt.Fprintf(buf, "this.Int = %s\n", deriveGoString_5(this.Int))
		}
		if this.Int16 != nil {
			fmt.Fprintf(buf, "this.Int16 = %s\n", deriveGoString_6(this.Int16))
		}
		if this.Int32 != nil {
			fmt.Fprintf(buf, "this.Int32 = %s\n", deriveGoString_7(this.Int32))
		}
		if this.Int64 != nil {
			fmt.Fprintf(buf, "this.Int64 = %s\n", deriveGoString_8(this.Int64))
		}
		if this.Int8 != nil {
			fmt.Fprintf(buf, "this.Int8 = %s\n", deriveGoString_9(this.Int8))
		}
		if this.Rune != nil {
			fmt.Fprintf(buf, "this.Rune = %s\n", deriveGoString_7(this.Rune))
		}
		if this.String != nil {
			fmt.Fprintf(buf, "this.String = %s\n", deriveGoString_10(this.String))
		}
		if this.Uint != nil {
			fmt.Fprintf(buf, "this.Uint = %s\n", deriveGoString_11(this.Uint))
		}
		if this.Uint16 != nil {
			fmt.Fprintf(buf, "this.Uint16 = %s\n", deriveGoString_12(this.Uint16))
		}
		if this.Uint32 != nil {
			fmt.Fprintf(buf, "this.Uint32 = %s\n", deriveGoString_13(this.Uint32))
		}
		if this.Uint64 != nil {
			fmt.Fprintf(buf, "this.Uint64 = %s\n", deriveGoString_14(this.Uint64))
		}
		if this.Uint8 != nil {
			fmt.Fprintf(buf, "this.Uint8 = %s\n", deriveGoString_(this.Uint8))
		}
		if this.UintPtr != nil {
			fmt.Fprintf(buf, "this.UintPtr = %s\n", deriveGoString_15(this.UintPtr))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringArrayOfBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringArrayOfBuiltInTypes(this *ArrayOfBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.ArrayOfBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.ArrayOfBuiltInTypes{}\n")
		fmt.Fprintf(buf, "this.Bool = %#v\n", this.Bool)
		fmt.Fprintf(buf, "this.Byte = %#v\n", this.Byte)
		fmt.Fprintf(buf, "this.Complex128 = %#v\n", this.Complex128)
		fmt.Fprintf(buf, "this.Complex64 = %#v\n", this.Complex64)
		fmt.Fprintf(buf, "this.Float64 = %#v\n", this.Float64)
		fmt.Fprintf(buf, "this.Float32 = %#v\n", this.Float32)
		fmt.Fprintf(buf, "this.Int = %#v\n", this.Int)
		fmt.Fprintf(buf, "this.Int16 = %#v\n", this.Int16)
		fmt.Fprintf(buf, "this.Int32 = %#v\n", this.Int32)
		fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
		fmt.Fprintf(buf, "this.Int8 = %#v\n", this.Int8)
		fmt.Fprintf(buf, "this.Rune = %#v\n", this.Rune)
		fmt.Fprintf(buf, "this.String = %#v\n", this.String)
		fmt.Fprintf(buf, "this.Uint = %#v\n", this.Uint)
		fmt.Fprintf(buf, "this.Uint16 = %#v\n", this.Uint16)
		fmt.Fprintf(buf, "this.Uint32 = %#v\n", this.Uint32)
		fmt.Fprintf(buf, "this.Uint64 = %#v\n", this.Uint64)
		fmt.Fprintf(buf, "this.Uint8 = %#v\n", this.Uint8)
		fmt.Fprintf(buf, "this.UintPtr = %#v\n", this.UintPtr)
		fmt.Fprintf(buf, "this.AnotherBoolOfDifferentSize = %#v\n", this.AnotherBoolOfDifferentSize)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringArrayOfPtrToBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringArrayOfPtrToBuiltInTypes(this *ArrayOfPtrToBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.ArrayOfPtrToBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.ArrayOfPtrToBuiltInTypes{}\n")
		fmt.Fprintf(buf, "this.Bool = %s\n", deriveGoString_16(this.Bool))
		fmt.Fprintf(buf, "this.Byte = %s\n", deriveGoString_17(this.Byte))
		fmt.Fprintf(buf, "this.Complex128 = %s\n", deriveGoString_18(this.Complex128))
		fmt.Fprintf(buf, "this.Complex64 = %s\n", deriveGoString_19(this.Complex64))
		fmt.Fprintf(buf, "this.Float64 = %s\n", deriveGoString_20(this.Float64))
		fmt.Fprintf(buf, "this.Float32 = %s\n", deriveGoString_21(this.Float32))
		fmt.Fprintf(buf, "this.Int = %s\n", deriveGoString_22(this.Int))
		fmt.Fprintf(buf, "this.Int16 = %s\n", deriveGoString_23(this.Int16))
		fmt.Fprintf(buf, "this.Int32 = %s\n", deriveGoString_24(this.Int32))
		fmt.Fprintf(buf, "this.Int64 = %s\n", deriveGoString_25(this.Int64))
		fmt.Fprintf(buf, "this.Int8 = %s\n", deriveGoString_26(this.Int8))
		fmt.Fprintf(buf, "this.Rune = %s\n", deriveGoString_27(this.Rune))
		fmt.Fprintf(buf, "this.String = %s\n", deriveGoString_28(this.String))
		fmt.Fprintf(buf, "this.Uint = %s\n", deriveGoString_29(this.Uint))
		fmt.Fprintf(buf, "this.Uint16 = %s\n", deriveGoString_30(this.Uint16))
		fmt.Fprintf(buf, "this.Uint32 = %s\n", deriveGoString_31(this.Uint32))
		fmt.Fprintf(buf, "this.Uint64 = %s\n", deriveGoString_32(this.Uint64))
		fmt.Fprintf(buf, "this.Uint8 = %s\n", deriveGoString_33(this.Uint8))
		fmt.Fprintf(buf, "this.UintPtr = %s\n", deriveGoString_34(this.UintPtr))
		fmt.Fprintf(buf, "this.AnotherBoolOfDifferentSize = %s\n", deriveGoString_35(this.AnotherBoolOfDifferentSize))
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringMapsOfSimplerBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringMapsOfSimplerBuiltInTypes(this *MapsOfSimplerBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.MapsOfSimplerBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.MapsOfSimplerBuiltInTypes{}\n")
		if this.StringToUint32 != nil {
			fmt.Fprintf(buf, "this.StringToUint32 = %#v\n", this.StringToUint32)
		}
		if this.Uint64ToInt64 != nil {
			fmt.Fprintf(buf, "this.Uint64ToInt64 = %#v\n", this.Uint64ToInt64)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringMapsOfBuiltInTypes returns a recursive representation of this as a valid go string.
func deriveGoStringMapsOfBuiltInTypes(this *MapsOfBuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.MapsOfBuiltInTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.MapsOfBuiltInTypes{}\n")
		if this.BoolToString != nil {
			fmt.Fprintf(buf, "this.BoolToString = %#v\n", this.BoolToString)
		}
		if this.StringToBool != nil {
			fmt.Fprintf(buf, "this.StringToBool = %#v\n", this.StringToBool)
		}
		if this.Complex128ToComplex64 != nil {
			fmt.Fprintf(buf, "this.Complex128ToComplex64 = %#v\n", this.Complex128ToComplex64)
		}
		if this.Float64ToUint32 != nil {
			fmt.Fprintf(buf, "this.Float64ToUint32 = %#v\n", this.Float64ToUint32)
		}
		if this.Uint16ToUint8 != nil {
			fmt.Fprintf(buf, "this.Uint16ToUint8 = %#v\n", this.Uint16ToUint8)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringSliceToSlice returns a recursive representation of this as a valid go string.
func deriveGoStringSliceToSlice(this *SliceToSlice) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.SliceToSlice {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.SliceToSlice{}\n")
		if this.Ints != nil {
			fmt.Fprintf(buf, "this.Ints = %s\n", deriveGoString_36(this.Ints))
		}
		if this.Strings != nil {
			fmt.Fprintf(buf, "this.Strings = %s\n", deriveGoString_37(this.Strings))
		}
		if this.IntPtrs != nil {
			fmt.Fprintf(buf, "this.IntPtrs = %s\n", deriveGoString_38(this.IntPtrs))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringPtrTo returns a recursive representation of this as a valid go string.
func deriveGoStringPtrTo(this *PtrTo) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.PtrTo {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.PtrTo{}\n")
		if this.Basic != nil {
			fmt.Fprintf(buf, "this.Basic = func (v int) *int { return &v }(%#v)\n", *this.Basic)
		}
		if this.Slice != nil {
			fmt.Fprintf(buf, "this.Slice = %s\n", deriveGoStringIntPtrSlice(this.Slice))
		}
		if this.Array != nil {
			fmt.Fprintf(buf, "this.Array = %s\n", deriveGoString_39(this.Array))
		}
		if this.Map != nil {
			fmt.Fprintf(buf, "this.Map = %s\n", deriveGoStringIntPtrMap(this.Map))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringName returns a recursive representation of this as a valid go string.
func deriveGoStringName(this *Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.Name{}\n")
		fmt.Fprintf(buf, "this.Name = %#v\n", this.Name)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringStructs returns a recursive representation of this as a valid go string.
func deriveGoStringStructs(this *Structs) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Structs {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.Structs{}\n")
		fmt.Fprintf(buf, "this.Struct = %s\n", deriveGoString_N(this.Struct))
		if this.PtrToStruct != nil {
			fmt.Fprintf(buf, "this.PtrToStruct = %s\n", deriveGoStringName(this.PtrToStruct))
		}
		if this.SliceOfStructs != nil {
			fmt.Fprintf(buf, "this.SliceOfStructs = %s\n", deriveGoString_40(this.SliceOfStructs))
		}
		if this.SliceToPtrOfStruct != nil {
			fmt.Fprintf(buf, "this.SliceToPtrOfStruct = %s\n", deriveGoString_41(this.SliceToPtrOfStruct))
		}
		fmt.Fprintf(buf, "this.StructWithoutMethod = %s\n", deriveGoString_S(this.StructWithoutMethod))
		if this.PtrToStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.PtrToStructWithoutMethod = %s\n", deriveGoString_42(this.PtrToStructWithoutMethod))
		}
		if this.SliceOfStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.SliceOfStructWithoutMethod = %s\n", deriveGoString_43(this.SliceOfStructWithoutMethod))
		}
		if this.SliceToPtrOfStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.SliceToPtrOfStructWithoutMethod = %s\n", deriveGoString_44(this.SliceToPtrOfStructWithoutMethod))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringMapWithStructs returns a recursive representation of this as a valid go string.
func deriveGoStringMapWithStructs(this *MapWithStructs) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.MapWithStructs {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.MapWithStructs{}\n")
		if this.NameToString != nil {
			fmt.Fprintf(buf, "this.NameToString = %s\n", deriveGoString_45(this.NameToString))
		}
		if this.StringToName != nil {
			fmt.Fprintf(buf, "this.StringToName = %s\n", deriveGoString_46(this.StringToName))
		}
		if this.StringToPtrToName != nil {
			fmt.Fprintf(buf, "this.StringToPtrToName = %s\n", deriveGoString_47(this.StringToPtrToName))
		}
		if this.StringToSliceOfName != nil {
			fmt.Fprintf(buf, "this.StringToSliceOfName = %s\n", deriveGoString_48(this.StringToSliceOfName))
		}
		if this.StringToSliceOfPtrToName != nil {
			fmt.Fprintf(buf, "this.StringToSliceOfPtrToName = %s\n", deriveGoString_49(this.StringToSliceOfPtrToName))
		}
		if this.StringToStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.StringToStructWithoutMethod = %s\n", deriveGoString_50(this.StringToStructWithoutMethod))
		}
		if this.StructWithoutMethodToString != nil {
			fmt.Fprintf(buf, "this.StructWithoutMethodToString = %s\n", deriveGoString_51(this.StructWithoutMethodToString))
		}
		if this.StringToPtrToStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.StringToPtrToStructWithoutMethod = %s\n", deriveGoString_52(this.StringToPtrToStructWithoutMethod))
		}
		if this.StringToSliceOfStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.StringToSliceOfStructWithoutMethod = %s\n", deriveGoString_53(this.StringToSliceOfStructWithoutMethod))
		}
		if this.StringToSliceOfPtrToStructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.StringToSliceOfPtrToStructWithoutMethod = %s\n", deriveGoString_54(this.StringToSliceOfPtrToStructWithoutMethod))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringRecursiveType returns a recursive representation of this as a valid go string.
func deriveGoStringRecursiveType(this *RecursiveType) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.RecursiveType {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.RecursiveType{}\n")
		if this.Bytes != nil {
			fmt.Fprintf(buf, "this.Bytes = %#v\n", this.Bytes)
		}
		if this.N != nil {
			fmt.Fprintf(buf, "this.N = %s\n", deriveGoString_55(this.N))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringEmbeddedStruct1 returns a recursive representation of this as a valid go string.
func deriveGoStringEmbeddedStruct1(this *EmbeddedStruct1) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.EmbeddedStruct1 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.EmbeddedStruct1{}\n")
		fmt.Fprintf(buf, "this.Name = %s\n", deriveGoString_N(this.Name))
		fmt.Fprintf(buf, "this.StructWithoutMethod = %s\n", deriveGoString_S(this.StructWithoutMethod))
		if this.Structs != nil {
			fmt.Fprintf(buf, "this.Structs = %s\n", deriveGoStringStructs(this.Structs))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringEmbeddedStruct2 returns a recursive representation of this as a valid go string.
func deriveGoStringEmbeddedStruct2(this *EmbeddedStruct2) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.EmbeddedStruct2 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.EmbeddedStruct2{}\n")
		fmt.Fprintf(buf, "this.Structs = %s\n", deriveGoString_St(this.Structs))
		if this.Name != nil {
			fmt.Fprintf(buf, "this.Name = %s\n", deriveGoStringName(this.Name))
		}
		if this.StructWithoutMethod != nil {
			fmt.Fprintf(buf, "this.StructWithoutMethod = %s\n", deriveGoString_42(this.StructWithoutMethod))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringStructWithStructFieldWithoutEqualMethod returns a recursive representation of this as a valid go string.
func deriveGoStringStructWithStructFieldWithoutEqualMethod(this *StructWithStructFieldWithoutEqualMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.StructWithStructFieldWithoutEqualMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.StructWithStructFieldWithoutEqualMethod{}\n")
		if this.A != nil {
			fmt.Fprintf(buf, "this.A = %s\n", deriveGoString_56(this.A))
		}
		fmt.Fprintf(buf, "this.B = %s\n", deriveGoString_Str(this.B))
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringStructWithStructWithFromAnotherPackage returns a recursive representation of this as a valid go string.
func deriveGoStringStructWithStructWithFromAnotherPackage(this *StructWithStructWithFromAnotherPackage) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.StructWithStructWithFromAnotherPackage {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.StructWithStructWithFromAnotherPackage{}\n")
		if this.A != nil {
			fmt.Fprintf(buf, "this.A = %s\n", deriveGoString_57(this.A))
		}
		fmt.Fprintf(buf, "this.B = %s\n", deriveGoString_Stru(this.B))
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringEnums returns a recursive representation of this as a valid go string.
func deriveGoStringEnums(this *Enums) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Enums {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.Enums{}\n")
		fmt.Fprintf(buf, "this.Enum = %#v\n", this.Enum)
		if this.PtrToEnum != nil {
			fmt.Fprintf(buf, "this.PtrToEnum = %s\n", deriveGoString_58(this.PtrToEnum))
		}
		if this.SliceToEnum != nil {
			fmt.Fprintf(buf, "this.SliceToEnum = %s\n", deriveGoString_59(this.SliceToEnum))
		}
		if this.SliceToPtrToEnum != nil {
			fmt.Fprintf(buf, "this.SliceToPtrToEnum = %s\n", deriveGoString_60(this.SliceToPtrToEnum))
		}
		if this.MapToEnum != nil {
			fmt.Fprintf(buf, "this.MapToEnum = %s\n", deriveGoString_61(this.MapToEnum))
		}
		if this.EnumToMap != nil {
			fmt.Fprintf(buf, "this.EnumToMap = %s\n", deriveGoString_62(this.EnumToMap))
		}
		fmt.Fprintf(buf, "this.ArrayEnum = %s\n", deriveGoString_63(this.ArrayEnum))
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringNamedTypes returns a recursive representation of this as a valid go string.
func deriveGoStringNamedTypes(this *NamedTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.NamedTypes {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.NamedTypes{}\n")
		if this.Slice != nil {
			fmt.Fprintf(buf, "this.Slice = %#v\n", this.Slice)
		}
		if this.PtrToSlice != nil {
			fmt.Fprintf(buf, "this.PtrToSlice = %s\n", deriveGoString_64(this.PtrToSlice))
		}
		if this.SliceToSlice != nil {
			fmt.Fprintf(buf, "this.SliceToSlice = %s\n", deriveGoString_65(this.SliceToSlice))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringDuration returns a recursive representation of this as a valid go string.
func deriveGoStringDuration(this *Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Duration {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.Duration{}\n")
		fmt.Fprintf(buf, "this.D = %#v\n", this.D)
		if this.P != nil {
			fmt.Fprintf(buf, "this.P = %s\n", deriveGoString_66(this.P))
		}
		if this.Ds != nil {
			fmt.Fprintf(buf, "this.Ds = %s\n", deriveGoString_67(this.Ds))
		}
		if this.DPs != nil {
			fmt.Fprintf(buf, "this.DPs = %s\n", deriveGoString_68(this.DPs))
		}
		if this.MD != nil {
			fmt.Fprintf(buf, "this.MD = %s\n", deriveGoString_69(this.MD))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringNickname returns a recursive representation of this as a valid go string.
func deriveGoStringNickname(this *Nickname) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.Nickname {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.Nickname{}\n")
		if this.Alias != nil {
			fmt.Fprintf(buf, "this.Alias = %s\n", deriveGoString_70(this.Alias))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringPrivateEmbedded returns a recursive representation of this as a valid go string.
func deriveGoStringPrivateEmbedded(this *PrivateEmbedded) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.PrivateEmbedded {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.PrivateEmbedded{}\n")
		fmt.Fprintf(buf, "this.privateStruct = %s\n", deriveGoString_p(this.privateStruct))
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntSlices returns a recursive representation of this as a valid go string.
func deriveGoStringIntSlices(this []int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "return %#v\n", this)
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntArray returns a recursive representation of this as a valid go string.
func deriveGoStringIntArray(this [10]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [10]int {\n")
	fmt.Fprintf(buf, "return %#v\n", this)
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringMapOfIntToInt returns a recursive representation of this as a valid go string.
func deriveGoStringMapOfIntToInt(this map[int]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[int]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "return %#v\n", this)
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntPtr returns a recursive representation of this as a valid go string.
func deriveGoStringIntPtr(this *int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(int)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntPtrSlice returns a recursive representation of this as a valid go string.
func deriveGoStringIntPtrSlice(this *[]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *[]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new([]int)\n")
		if *this != nil {
			fmt.Fprintf(buf, "*this = %#v\n", *this)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntPtrArray returns a recursive representation of this as a valid go string.
func deriveGoStringIntPtrArray(this *[10]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *[10]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new([10]int)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringIntPtrMap returns a recursive representation of this as a valid go string.
func deriveGoStringIntPtrMap(this *map[int]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *map[int]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(map[int]int)\n")
		if *this != nil {
			fmt.Fprintf(buf, "*this = %#v\n", *this)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoStringNoPointerStruct returns a recursive representation of this as a valid go string.
func deriveGoStringNoPointerStruct(this BuiltInTypes) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.BuiltInTypes {\n")
	fmt.Fprintf(buf, "this := &test.BuiltInTypes{}\n")
	fmt.Fprintf(buf, "this.Bool = %#v\n", this.Bool)
	fmt.Fprintf(buf, "this.Byte = %#v\n", this.Byte)
	fmt.Fprintf(buf, "this.Complex128 = %#v\n", this.Complex128)
	fmt.Fprintf(buf, "this.Complex64 = %#v\n", this.Complex64)
	fmt.Fprintf(buf, "this.Float64 = %#v\n", this.Float64)
	fmt.Fprintf(buf, "this.Float32 = %#v\n", this.Float32)
	fmt.Fprintf(buf, "this.Int = %#v\n", this.Int)
	fmt.Fprintf(buf, "this.Int16 = %#v\n", this.Int16)
	fmt.Fprintf(buf, "this.Int32 = %#v\n", this.Int32)
	fmt.Fprintf(buf, "this.Int64 = %#v\n", this.Int64)
	fmt.Fprintf(buf, "this.Int8 = %#v\n", this.Int8)
	fmt.Fprintf(buf, "this.Rune = %#v\n", this.Rune)
	fmt.Fprintf(buf, "this.String = %#v\n", this.String)
	fmt.Fprintf(buf, "this.Uint = %#v\n", this.Uint)
	fmt.Fprintf(buf, "this.Uint16 = %#v\n", this.Uint16)
	fmt.Fprintf(buf, "this.Uint32 = %#v\n", this.Uint32)
	fmt.Fprintf(buf, "this.Uint64 = %#v\n", this.Uint64)
	fmt.Fprintf(buf, "this.Uint8 = %#v\n", this.Uint8)
	fmt.Fprintf(buf, "this.UintPtr = %#v\n", this.UintPtr)
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveDeepCopyPtrToEmpty recursively copies the contents of src into dst.
func deriveDeepCopyPtrToEmpty(dst, src *Empty) {
}

// deriveDeepCopyPtrToBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToBuiltInTypes(dst, src *BuiltInTypes) {
	dst.Bool = src.Bool
	dst.Byte = src.Byte
	dst.Complex128 = src.Complex128
	dst.Complex64 = src.Complex64
	dst.Float64 = src.Float64
	dst.Float32 = src.Float32
	dst.Int = src.Int
	dst.Int16 = src.Int16
	dst.Int32 = src.Int32
	dst.Int64 = src.Int64
	dst.Int8 = src.Int8
	dst.Rune = src.Rune
	dst.String = src.String
	dst.Uint = src.Uint
	dst.Uint16 = src.Uint16
	dst.Uint32 = src.Uint32
	dst.Uint64 = src.Uint64
	dst.Uint8 = src.Uint8
	dst.UintPtr = src.UintPtr
}

// deriveDeepCopyPtrToPrivateBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToPrivateBuiltInTypes(dst, src *PrivateBuiltInTypes) {
	dst.privateBool = src.privateBool
	dst.privateByte = src.privateByte
	dst.privateComplex128 = src.privateComplex128
	dst.privateComplex64 = src.privateComplex64
	dst.privateFloat64 = src.privateFloat64
	dst.privateFloat32 = src.privateFloat32
	dst.privateInt = src.privateInt
	dst.privateInt16 = src.privateInt16
	dst.privateInt32 = src.privateInt32
	dst.privateInt64 = src.privateInt64
	dst.privateInt8 = src.privateInt8
	dst.privateRune = src.privateRune
	dst.privateString = src.privateString
	dst.privateUint = src.privateUint
	dst.privateUint16 = src.privateUint16
	dst.privateUint32 = src.privateUint32
	dst.privateUint64 = src.privateUint64
	dst.privateUint8 = src.privateUint8
	dst.privateUintPtr = src.privateUintPtr
}

// deriveDeepCopyPtrToPtrToBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToPtrToBuiltInTypes(dst, src *PtrToBuiltInTypes) {
	if src.Bool == nil {
		dst.Bool = nil
	} else {
		dst.Bool = new(bool)
		*dst.Bool = *src.Bool
	}
	if src.Byte == nil {
		dst.Byte = nil
	} else {
		dst.Byte = new(byte)
		*dst.Byte = *src.Byte
	}
	if src.Complex128 == nil {
		dst.Complex128 = nil
	} else {
		dst.Complex128 = new(complex128)
		*dst.Complex128 = *src.Complex128
	}
	if src.Complex64 == nil {
		dst.Complex64 = nil
	} else {
		dst.Complex64 = new(complex64)
		*dst.Complex64 = *src.Complex64
	}
	if src.Float64 == nil {
		dst.Float64 = nil
	} else {
		dst.Float64 = new(float64)
		*dst.Float64 = *src.Float64
	}
	if src.Float32 == nil {
		dst.Float32 = nil
	} else {
		dst.Float32 = new(float32)
		*dst.Float32 = *src.Float32
	}
	if src.Int == nil {
		dst.Int = nil
	} else {
		dst.Int = new(int)
		*dst.Int = *src.Int
	}
	if src.Int16 == nil {
		dst.Int16 = nil
	} else {
		dst.Int16 = new(int16)
		*dst.Int16 = *src.Int16
	}
	if src.Int32 == nil {
		dst.Int32 = nil
	} else {
		dst.Int32 = new(int32)
		*dst.Int32 = *src.Int32
	}
	if src.Int64 == nil {
		dst.Int64 = nil
	} else {
		dst.Int64 = new(int64)
		*dst.Int64 = *src.Int64
	}
	if src.Int8 == nil {
		dst.Int8 = nil
	} else {
		dst.Int8 = new(int8)
		*dst.Int8 = *src.Int8
	}
	if src.Rune == nil {
		dst.Rune = nil
	} else {
		dst.Rune = new(rune)
		*dst.Rune = *src.Rune
	}
	if src.String == nil {
		dst.String = nil
	} else {
		dst.String = new(string)
		*dst.String = *src.String
	}
	if src.Uint == nil {
		dst.Uint = nil
	} else {
		dst.Uint = new(uint)
		*dst.Uint = *src.Uint
	}
	if src.Uint16 == nil {
		dst.Uint16 = nil
	} else {
		dst.Uint16 = new(uint16)
		*dst.Uint16 = *src.Uint16
	}
	if src.Uint32 == nil {
		dst.Uint32 = nil
	} else {
		dst.Uint32 = new(uint32)
		*dst.Uint32 = *src.Uint32
	}
	if src.Uint64 == nil {
		dst.Uint64 = nil
	} else {
		dst.Uint64 = new(uint64)
		*dst.Uint64 = *src.Uint64
	}
	if src.Uint8 == nil {
		dst.Uint8 = nil
	} else {
		dst.Uint8 = new(uint8)
		*dst.Uint8 = *src.Uint8
	}
	if src.UintPtr == nil {
		dst.UintPtr = nil
	} else {
		dst.UintPtr = new(uintptr)
		*dst.UintPtr = *src.UintPtr
	}
}

// deriveDeepCopyPtrToSliceOfBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToSliceOfBuiltInTypes(dst, src *SliceOfBuiltInTypes) {
	if src.Bool == nil {
		dst.Bool = nil
	} else {
		if dst.Bool != nil {
			if len(src.Bool) > len(dst.Bool) {
				if cap(dst.Bool) >= len(src.Bool) {
					dst.Bool = (dst.Bool)[:len(src.Bool)]
				} else {
					dst.Bool = make([]bool, len(src.Bool))
				}
			} else if len(src.Bool) < len(dst.Bool) {
				dst.Bool = (dst.Bool)[:len(src.Bool)]
			}
		} else {
			dst.Bool = make([]bool, len(src.Bool))
		}
		copy(dst.Bool, src.Bool)
	}
	if src.Byte == nil {
		dst.Byte = nil
	} else {
		if dst.Byte != nil {
			if len(src.Byte) > len(dst.Byte) {
				if cap(dst.Byte) >= len(src.Byte) {
					dst.Byte = (dst.Byte)[:len(src.Byte)]
				} else {
					dst.Byte = make([]byte, len(src.Byte))
				}
			} else if len(src.Byte) < len(dst.Byte) {
				dst.Byte = (dst.Byte)[:len(src.Byte)]
			}
		} else {
			dst.Byte = make([]byte, len(src.Byte))
		}
		copy(dst.Byte, src.Byte)
	}
	if src.Complex128 == nil {
		dst.Complex128 = nil
	} else {
		if dst.Complex128 != nil {
			if len(src.Complex128) > len(dst.Complex128) {
				if cap(dst.Complex128) >= len(src.Complex128) {
					dst.Complex128 = (dst.Complex128)[:len(src.Complex128)]
				} else {
					dst.Complex128 = make([]complex128, len(src.Complex128))
				}
			} else if len(src.Complex128) < len(dst.Complex128) {
				dst.Complex128 = (dst.Complex128)[:len(src.Complex128)]
			}
		} else {
			dst.Complex128 = make([]complex128, len(src.Complex128))
		}
		copy(dst.Complex128, src.Complex128)
	}
	if src.Complex64 == nil {
		dst.Complex64 = nil
	} else {
		if dst.Complex64 != nil {
			if len(src.Complex64) > len(dst.Complex64) {
				if cap(dst.Complex64) >= len(src.Complex64) {
					dst.Complex64 = (dst.Complex64)[:len(src.Complex64)]
				} else {
					dst.Complex64 = make([]complex64, len(src.Complex64))
				}
			} else if len(src.Complex64) < len(dst.Complex64) {
				dst.Complex64 = (dst.Complex64)[:len(src.Complex64)]
			}
		} else {
			dst.Complex64 = make([]complex64, len(src.Complex64))
		}
		copy(dst.Complex64, src.Complex64)
	}
	if src.Float64 == nil {
		dst.Float64 = nil
	} else {
		if dst.Float64 != nil {
			if len(src.Float64) > len(dst.Float64) {
				if cap(dst.Float64) >= len(src.Float64) {
					dst.Float64 = (dst.Float64)[:len(src.Float64)]
				} else {
					dst.Float64 = make([]float64, len(src.Float64))
				}
			} else if len(src.Float64) < len(dst.Float64) {
				dst.Float64 = (dst.Float64)[:len(src.Float64)]
			}
		} else {
			dst.Float64 = make([]float64, len(src.Float64))
		}
		copy(dst.Float64, src.Float64)
	}
	if src.Float32 == nil {
		dst.Float32 = nil
	} else {
		if dst.Float32 != nil {
			if len(src.Float32) > len(dst.Float32) {
				if cap(dst.Float32) >= len(src.Float32) {
					dst.Float32 = (dst.Float32)[:len(src.Float32)]
				} else {
					dst.Float32 = make([]float32, len(src.Float32))
				}
			} else if len(src.Float32) < len(dst.Float32) {
				dst.Float32 = (dst.Float32)[:len(src.Float32)]
			}
		} else {
			dst.Float32 = make([]float32, len(src.Float32))
		}
		copy(dst.Float32, src.Float32)
	}
	if src.Int == nil {
		dst.Int = nil
	} else {
		if dst.Int != nil {
			if len(src.Int) > len(dst.Int) {
				if cap(dst.Int) >= len(src.Int) {
					dst.Int = (dst.Int)[:len(src.Int)]
				} else {
					dst.Int = make([]int, len(src.Int))
				}
			} else if len(src.Int) < len(dst.Int) {
				dst.Int = (dst.Int)[:len(src.Int)]
			}
		} else {
			dst.Int = make([]int, len(src.Int))
		}
		copy(dst.Int, src.Int)
	}
	if src.Int16 == nil {
		dst.Int16 = nil
	} else {
		if dst.Int16 != nil {
			if len(src.Int16) > len(dst.Int16) {
				if cap(dst.Int16) >= len(src.Int16) {
					dst.Int16 = (dst.Int16)[:len(src.Int16)]
				} else {
					dst.Int16 = make([]int16, len(src.Int16))
				}
			} else if len(src.Int16) < len(dst.Int16) {
				dst.Int16 = (dst.Int16)[:len(src.Int16)]
			}
		} else {
			dst.Int16 = make([]int16, len(src.Int16))
		}
		copy(dst.Int16, src.Int16)
	}
	if src.Int32 == nil {
		dst.Int32 = nil
	} else {
		if dst.Int32 != nil {
			if len(src.Int32) > len(dst.Int32) {
				if cap(dst.Int32) >= len(src.Int32) {
					dst.Int32 = (dst.Int32)[:len(src.Int32)]
				} else {
					dst.Int32 = make([]int32, len(src.Int32))
				}
			} else if len(src.Int32) < len(dst.Int32) {
				dst.Int32 = (dst.Int32)[:len(src.Int32)]
			}
		} else {
			dst.Int32 = make([]int32, len(src.Int32))
		}
		copy(dst.Int32, src.Int32)
	}
	if src.Int64 == nil {
		dst.Int64 = nil
	} else {
		if dst.Int64 != nil {
			if len(src.Int64) > len(dst.Int64) {
				if cap(dst.Int64) >= len(src.Int64) {
					dst.Int64 = (dst.Int64)[:len(src.Int64)]
				} else {
					dst.Int64 = make([]int64, len(src.Int64))
				}
			} else if len(src.Int64) < len(dst.Int64) {
				dst.Int64 = (dst.Int64)[:len(src.Int64)]
			}
		} else {
			dst.Int64 = make([]int64, len(src.Int64))
		}
		copy(dst.Int64, src.Int64)
	}
	if src.Int8 == nil {
		dst.Int8 = nil
	} else {
		if dst.Int8 != nil {
			if len(src.Int8) > len(dst.Int8) {
				if cap(dst.Int8) >= len(src.Int8) {
					dst.Int8 = (dst.Int8)[:len(src.Int8)]
				} else {
					dst.Int8 = make([]int8, len(src.Int8))
				}
			} else if len(src.Int8) < len(dst.Int8) {
				dst.Int8 = (dst.Int8)[:len(src.Int8)]
			}
		} else {
			dst.Int8 = make([]int8, len(src.Int8))
		}
		copy(dst.Int8, src.Int8)
	}
	if src.Rune == nil {
		dst.Rune = nil
	} else {
		if dst.Rune != nil {
			if len(src.Rune) > len(dst.Rune) {
				if cap(dst.Rune) >= len(src.Rune) {
					dst.Rune = (dst.Rune)[:len(src.Rune)]
				} else {
					dst.Rune = make([]rune, len(src.Rune))
				}
			} else if len(src.Rune) < len(dst.Rune) {
				dst.Rune = (dst.Rune)[:len(src.Rune)]
			}
		} else {
			dst.Rune = make([]rune, len(src.Rune))
		}
		copy(dst.Rune, src.Rune)
	}
	if src.String == nil {
		dst.String = nil
	} else {
		if dst.String != nil {
			if len(src.String) > len(dst.String) {
				if cap(dst.String) >= len(src.String) {
					dst.String = (dst.String)[:len(src.String)]
				} else {
					dst.String = make([]string, len(src.String))
				}
			} else if len(src.String) < len(dst.String) {
				dst.String = (dst.String)[:len(src.String)]
			}
		} else {
			dst.String = make([]string, len(src.String))
		}
		copy(dst.String, src.String)
	}
	if src.Uint == nil {
		dst.Uint = nil
	} else {
		if dst.Uint != nil {
			if len(src.Uint) > len(dst.Uint) {
				if cap(dst.Uint) >= len(src.Uint) {
					dst.Uint = (dst.Uint)[:len(src.Uint)]
				} else {
					dst.Uint = make([]uint, len(src.Uint))
				}
			} else if len(src.Uint) < len(dst.Uint) {
				dst.Uint = (dst.Uint)[:len(src.Uint)]
			}
		} else {
			dst.Uint = make([]uint, len(src.Uint))
		}
		copy(dst.Uint, src.Uint)
	}
	if src.Uint16 == nil {
		dst.Uint16 = nil
	} else {
		if dst.Uint16 != nil {
			if len(src.Uint16) > len(dst.Uint16) {
				if cap(dst.Uint16) >= len(src.Uint16) {
					dst.Uint16 = (dst.Uint16)[:len(src.Uint16)]
				} else {
					dst.Uint16 = make([]uint16, len(src.Uint16))
				}
			} else if len(src.Uint16) < len(dst.Uint16) {
				dst.Uint16 = (dst.Uint16)[:len(src.Uint16)]
			}
		} else {
			dst.Uint16 = make([]uint16, len(src.Uint16))
		}
		copy(dst.Uint16, src.Uint16)
	}
	if src.Uint32 == nil {
		dst.Uint32 = nil
	} else {
		if dst.Uint32 != nil {
			if len(src.Uint32) > len(dst.Uint32) {
				if cap(dst.Uint32) >= len(src.Uint32) {
					dst.Uint32 = (dst.Uint32)[:len(src.Uint32)]
				} else {
					dst.Uint32 = make([]uint32, len(src.Uint32))
				}
			} else if len(src.Uint32) < len(dst.Uint32) {
				dst.Uint32 = (dst.Uint32)[:len(src.Uint32)]
			}
		} else {
			dst.Uint32 = make([]uint32, len(src.Uint32))
		}
		copy(dst.Uint32, src.Uint32)
	}
	if src.Uint64 == nil {
		dst.Uint64 = nil
	} else {
		if dst.Uint64 != nil {
			if len(src.Uint64) > len(dst.Uint64) {
				if cap(dst.Uint64) >= len(src.Uint64) {
					dst.Uint64 = (dst.Uint64)[:len(src.Uint64)]
				} else {
					dst.Uint64 = make([]uint64, len(src.Uint64))
				}
			} else if len(src.Uint64) < len(dst.Uint64) {
				dst.Uint64 = (dst.Uint64)[:len(src.Uint64)]
			}
		} else {
			dst.Uint64 = make([]uint64, len(src.Uint64))
		}
		copy(dst.Uint64, src.Uint64)
	}
	if src.Uint8 == nil {
		dst.Uint8 = nil
	} else {
		if dst.Uint8 != nil {
			if len(src.Uint8) > len(dst.Uint8) {
				if cap(dst.Uint8) >= len(src.Uint8) {
					dst.Uint8 = (dst.Uint8)[:len(src.Uint8)]
				} else {
					dst.Uint8 = make([]uint8, len(src.Uint8))
				}
			} else if len(src.Uint8) < len(dst.Uint8) {
				dst.Uint8 = (dst.Uint8)[:len(src.Uint8)]
			}
		} else {
			dst.Uint8 = make([]uint8, len(src.Uint8))
		}
		copy(dst.Uint8, src.Uint8)
	}
	if src.UintPtr == nil {
		dst.UintPtr = nil
	} else {
		if dst.UintPtr != nil {
			if len(src.UintPtr) > len(dst.UintPtr) {
				if cap(dst.UintPtr) >= len(src.UintPtr) {
					dst.UintPtr = (dst.UintPtr)[:len(src.UintPtr)]
				} else {
					dst.UintPtr = make([]uintptr, len(src.UintPtr))
				}
			} else if len(src.UintPtr) < len(dst.UintPtr) {
				dst.UintPtr = (dst.UintPtr)[:len(src.UintPtr)]
			}
		} else {
			dst.UintPtr = make([]uintptr, len(src.UintPtr))
		}
		copy(dst.UintPtr, src.UintPtr)
	}
}

// deriveDeepCopyPtrToSliceOfPtrToBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToSliceOfPtrToBuiltInTypes(dst, src *SliceOfPtrToBuiltInTypes) {
	if src.Bool == nil {
		dst.Bool = nil
	} else {
		if dst.Bool != nil {
			if len(src.Bool) > len(dst.Bool) {
				if cap(dst.Bool) >= len(src.Bool) {
					dst.Bool = (dst.Bool)[:len(src.Bool)]
				} else {
					dst.Bool = make([]*bool, len(src.Bool))
				}
			} else if len(src.Bool) < len(dst.Bool) {
				dst.Bool = (dst.Bool)[:len(src.Bool)]
			}
		} else {
			dst.Bool = make([]*bool, len(src.Bool))
		}
		deriveDeepCopy(dst.Bool, src.Bool)
	}
	if src.Byte == nil {
		dst.Byte = nil
	} else {
		if dst.Byte != nil {
			if len(src.Byte) > len(dst.Byte) {
				if cap(dst.Byte) >= len(src.Byte) {
					dst.Byte = (dst.Byte)[:len(src.Byte)]
				} else {
					dst.Byte = make([]*byte, len(src.Byte))
				}
			} else if len(src.Byte) < len(dst.Byte) {
				dst.Byte = (dst.Byte)[:len(src.Byte)]
			}
		} else {
			dst.Byte = make([]*byte, len(src.Byte))
		}
		deriveDeepCopy_(dst.Byte, src.Byte)
	}
	if src.Complex128 == nil {
		dst.Complex128 = nil
	} else {
		if dst.Complex128 != nil {
			if len(src.Complex128) > len(dst.Complex128) {
				if cap(dst.Complex128) >= len(src.Complex128) {
					dst.Complex128 = (dst.Complex128)[:len(src.Complex128)]
				} else {
					dst.Complex128 = make([]*complex128, len(src.Complex128))
				}
			} else if len(src.Complex128) < len(dst.Complex128) {
				dst.Complex128 = (dst.Complex128)[:len(src.Complex128)]
			}
		} else {
			dst.Complex128 = make([]*complex128, len(src.Complex128))
		}
		deriveDeepCopy_1(dst.Complex128, src.Complex128)
	}
	if src.Complex64 == nil {
		dst.Complex64 = nil
	} else {
		if dst.Complex64 != nil {
			if len(src.Complex64) > len(dst.Complex64) {
				if cap(dst.Complex64) >= len(src.Complex64) {
					dst.Complex64 = (dst.Complex64)[:len(src.Complex64)]
				} else {
					dst.Complex64 = make([]*complex64, len(src.Complex64))
				}
			} else if len(src.Complex64) < len(dst.Complex64) {
				dst.Complex64 = (dst.Complex64)[:len(src.Complex64)]
			}
		} else {
			dst.Complex64 = make([]*complex64, len(src.Complex64))
		}
		deriveDeepCopy_2(dst.Complex64, src.Complex64)
	}
	if src.Float64 == nil {
		dst.Float64 = nil
	} else {
		if dst.Float64 != nil {
			if len(src.Float64) > len(dst.Float64) {
				if cap(dst.Float64) >= len(src.Float64) {
					dst.Float64 = (dst.Float64)[:len(src.Float64)]
				} else {
					dst.Float64 = make([]*float64, len(src.Float64))
				}
			} else if len(src.Float64) < len(dst.Float64) {
				dst.Float64 = (dst.Float64)[:len(src.Float64)]
			}
		} else {
			dst.Float64 = make([]*float64, len(src.Float64))
		}
		deriveDeepCopy_3(dst.Float64, src.Float64)
	}
	if src.Float32 == nil {
		dst.Float32 = nil
	} else {
		if dst.Float32 != nil {
			if len(src.Float32) > len(dst.Float32) {
				if cap(dst.Float32) >= len(src.Float32) {
					dst.Float32 = (dst.Float32)[:len(src.Float32)]
				} else {
					dst.Float32 = make([]*float32, len(src.Float32))
				}
			} else if len(src.Float32) < len(dst.Float32) {
				dst.Float32 = (dst.Float32)[:len(src.Float32)]
			}
		} else {
			dst.Float32 = make([]*float32, len(src.Float32))
		}
		deriveDeepCopy_4(dst.Float32, src.Float32)
	}
	if src.Int == nil {
		dst.Int = nil
	} else {
		if dst.Int != nil {
			if len(src.Int) > len(dst.Int) {
				if cap(dst.Int) >= len(src.Int) {
					dst.Int = (dst.Int)[:len(src.Int)]
				} else {
					dst.Int = make([]*int, len(src.Int))
				}
			} else if len(src.Int) < len(dst.Int) {
				dst.Int = (dst.Int)[:len(src.Int)]
			}
		} else {
			dst.Int = make([]*int, len(src.Int))
		}
		deriveDeepCopy_5(dst.Int, src.Int)
	}
	if src.Int16 == nil {
		dst.Int16 = nil
	} else {
		if dst.Int16 != nil {
			if len(src.Int16) > len(dst.Int16) {
				if cap(dst.Int16) >= len(src.Int16) {
					dst.Int16 = (dst.Int16)[:len(src.Int16)]
				} else {
					dst.Int16 = make([]*int16, len(src.Int16))
				}
			} else if len(src.Int16) < len(dst.Int16) {
				dst.Int16 = (dst.Int16)[:len(src.Int16)]
			}
		} else {
			dst.Int16 = make([]*int16, len(src.Int16))
		}
		deriveDeepCopy_6(dst.Int16, src.Int16)
	}
	if src.Int32 == nil {
		dst.Int32 = nil
	} else {
		if dst.Int32 != nil {
			if len(src.Int32) > len(dst.Int32) {
				if cap(dst.Int32) >= len(src.Int32) {
					dst.Int32 = (dst.Int32)[:len(src.Int32)]
				} else {
					dst.Int32 = make([]*int32, len(src.Int32))
				}
			} else if len(src.Int32) < len(dst.Int32) {
				dst.Int32 = (dst.Int32)[:len(src.Int32)]
			}
		} else {
			dst.Int32 = make([]*int32, len(src.Int32))
		}
		deriveDeepCopy_7(dst.Int32, src.Int32)
	}
	if src.Int64 == nil {
		dst.Int64 = nil
	} else {
		if dst.Int64 != nil {
			if len(src.Int64) > len(dst.Int64) {
				if cap(dst.Int64) >= len(src.Int64) {
					dst.Int64 = (dst.Int64)[:len(src.Int64)]
				} else {
					dst.Int64 = make([]*int64, len(src.Int64))
				}
			} else if len(src.Int64) < len(dst.Int64) {
				dst.Int64 = (dst.Int64)[:len(src.Int64)]
			}
		} else {
			dst.Int64 = make([]*int64, len(src.Int64))
		}
		deriveDeepCopy_8(dst.Int64, src.Int64)
	}
	if src.Int8 == nil {
		dst.Int8 = nil
	} else {
		if dst.Int8 != nil {
			if len(src.Int8) > len(dst.Int8) {
				if cap(dst.Int8) >= len(src.Int8) {
					dst.Int8 = (dst.Int8)[:len(src.Int8)]
				} else {
					dst.Int8 = make([]*int8, len(src.Int8))
				}
			} else if len(src.Int8) < len(dst.Int8) {
				dst.Int8 = (dst.Int8)[:len(src.Int8)]
			}
		} else {
			dst.Int8 = make([]*int8, len(src.Int8))
		}
		deriveDeepCopy_9(dst.Int8, src.Int8)
	}
	if src.Rune == nil {
		dst.Rune = nil
	} else {
		if dst.Rune != nil {
			if len(src.Rune) > len(dst.Rune) {
				if cap(dst.Rune) >= len(src.Rune) {
					dst.Rune = (dst.Rune)[:len(src.Rune)]
				} else {
					dst.Rune = make([]*rune, len(src.Rune))
				}
			} else if len(src.Rune) < len(dst.Rune) {
				dst.Rune = (dst.Rune)[:len(src.Rune)]
			}
		} else {
			dst.Rune = make([]*rune, len(src.Rune))
		}
		deriveDeepCopy_7(dst.Rune, src.Rune)
	}
	if src.String == nil {
		dst.String = nil
	} else {
		if dst.String != nil {
			if len(src.String) > len(dst.String) {
				if cap(dst.String) >= len(src.String) {
					dst.String = (dst.String)[:len(src.String)]
				} else {
					dst.String = make([]*string, len(src.String))
				}
			} else if len(src.String) < len(dst.String) {
				dst.String = (dst.String)[:len(src.String)]
			}
		} else {
			dst.String = make([]*string, len(src.String))
		}
		deriveDeepCopy_10(dst.String, src.String)
	}
	if src.Uint == nil {
		dst.Uint = nil
	} else {
		if dst.Uint != nil {
			if len(src.Uint) > len(dst.Uint) {
				if cap(dst.Uint) >= len(src.Uint) {
					dst.Uint = (dst.Uint)[:len(src.Uint)]
				} else {
					dst.Uint = make([]*uint, len(src.Uint))
				}
			} else if len(src.Uint) < len(dst.Uint) {
				dst.Uint = (dst.Uint)[:len(src.Uint)]
			}
		} else {
			dst.Uint = make([]*uint, len(src.Uint))
		}
		deriveDeepCopy_11(dst.Uint, src.Uint)
	}
	if src.Uint16 == nil {
		dst.Uint16 = nil
	} else {
		if dst.Uint16 != nil {
			if len(src.Uint16) > len(dst.Uint16) {
				if cap(dst.Uint16) >= len(src.Uint16) {
					dst.Uint16 = (dst.Uint16)[:len(src.Uint16)]
				} else {
					dst.Uint16 = make([]*uint16, len(src.Uint16))
				}
			} else if len(src.Uint16) < len(dst.Uint16) {
				dst.Uint16 = (dst.Uint16)[:len(src.Uint16)]
			}
		} else {
			dst.Uint16 = make([]*uint16, len(src.Uint16))
		}
		deriveDeepCopy_12(dst.Uint16, src.Uint16)
	}
	if src.Uint32 == nil {
		dst.Uint32 = nil
	} else {
		if dst.Uint32 != nil {
			if len(src.Uint32) > len(dst.Uint32) {
				if cap(dst.Uint32) >= len(src.Uint32) {
					dst.Uint32 = (dst.Uint32)[:len(src.Uint32)]
				} else {
					dst.Uint32 = make([]*uint32, len(src.Uint32))
				}
			} else if len(src.Uint32) < len(dst.Uint32) {
				dst.Uint32 = (dst.Uint32)[:len(src.Uint32)]
			}
		} else {
			dst.Uint32 = make([]*uint32, len(src.Uint32))
		}
		deriveDeepCopy_13(dst.Uint32, src.Uint32)
	}
	if src.Uint64 == nil {
		dst.Uint64 = nil
	} else {
		if dst.Uint64 != nil {
			if len(src.Uint64) > len(dst.Uint64) {
				if cap(dst.Uint64) >= len(src.Uint64) {
					dst.Uint64 = (dst.Uint64)[:len(src.Uint64)]
				} else {
					dst.Uint64 = make([]*uint64, len(src.Uint64))
				}
			} else if len(src.Uint64) < len(dst.Uint64) {
				dst.Uint64 = (dst.Uint64)[:len(src.Uint64)]
			}
		} else {
			dst.Uint64 = make([]*uint64, len(src.Uint64))
		}
		deriveDeepCopy_14(dst.Uint64, src.Uint64)
	}
	if src.Uint8 == nil {
		dst.Uint8 = nil
	} else {
		if dst.Uint8 != nil {
			if len(src.Uint8) > len(dst.Uint8) {
				if cap(dst.Uint8) >= len(src.Uint8) {
					dst.Uint8 = (dst.Uint8)[:len(src.Uint8)]
				} else {
					dst.Uint8 = make([]*uint8, len(src.Uint8))
				}
			} else if len(src.Uint8) < len(dst.Uint8) {
				dst.Uint8 = (dst.Uint8)[:len(src.Uint8)]
			}
		} else {
			dst.Uint8 = make([]*uint8, len(src.Uint8))
		}
		deriveDeepCopy_(dst.Uint8, src.Uint8)
	}
	if src.UintPtr == nil {
		dst.UintPtr = nil
	} else {
		if dst.UintPtr != nil {
			if len(src.UintPtr) > len(dst.UintPtr) {
				if cap(dst.UintPtr) >= len(src.UintPtr) {
					dst.UintPtr = (dst.UintPtr)[:len(src.UintPtr)]
				} else {
					dst.UintPtr = make([]*uintptr, len(src.UintPtr))
				}
			} else if len(src.UintPtr) < len(dst.UintPtr) {
				dst.UintPtr = (dst.UintPtr)[:len(src.UintPtr)]
			}
		} else {
			dst.UintPtr = make([]*uintptr, len(src.UintPtr))
		}
		deriveDeepCopy_15(dst.UintPtr, src.UintPtr)
	}
}

// deriveDeepCopyPtrToArrayOfBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToArrayOfBuiltInTypes(dst, src *ArrayOfBuiltInTypes) {
	dst.Bool = src.Bool
	dst.Byte = src.Byte
	dst.Complex128 = src.Complex128
	dst.Complex64 = src.Complex64
	dst.Float64 = src.Float64
	dst.Float32 = src.Float32
	dst.Int = src.Int
	dst.Int16 = src.Int16
	dst.Int32 = src.Int32
	dst.Int64 = src.Int64
	dst.Int8 = src.Int8
	dst.Rune = src.Rune
	dst.String = src.String
	dst.Uint = src.Uint
	dst.Uint16 = src.Uint16
	dst.Uint32 = src.Uint32
	dst.Uint64 = src.Uint64
	dst.Uint8 = src.Uint8
	dst.UintPtr = src.UintPtr
	dst.AnotherBoolOfDifferentSize = src.AnotherBoolOfDifferentSize
}

// deriveDeepCopyPtrToArrayOfPtrToBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToArrayOfPtrToBuiltInTypes(dst, src *ArrayOfPtrToBuiltInTypes) {
	for src_i, src_value := range src.Bool {
		if src_value == nil {
			dst.Bool[src_i] = nil
		} else {
			dst.Bool[src_i] = new(bool)
			*dst.Bool[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Byte {
		if src_value == nil {
			dst.Byte[src_i] = nil
		} else {
			dst.Byte[src_i] = new(byte)
			*dst.Byte[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Complex128 {
		if src_value == nil {
			dst.Complex128[src_i] = nil
		} else {
			dst.Complex128[src_i] = new(complex128)
			*dst.Complex128[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Complex64 {
		if src_value == nil {
			dst.Complex64[src_i] = nil
		} else {
			dst.Complex64[src_i] = new(complex64)
			*dst.Complex64[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Float64 {
		if src_value == nil {
			dst.Float64[src_i] = nil
		} else {
			dst.Float64[src_i] = new(float64)
			*dst.Float64[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Float32 {
		if src_value == nil {
			dst.Float32[src_i] = nil
		} else {
			dst.Float32[src_i] = new(float32)
			*dst.Float32[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Int {
		if src_value == nil {
			dst.Int[src_i] = nil
		} else {
			dst.Int[src_i] = new(int)
			*dst.Int[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Int16 {
		if src_value == nil {
			dst.Int16[src_i] = nil
		} else {
			dst.Int16[src_i] = new(int16)
			*dst.Int16[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Int32 {
		if src_value == nil {
			dst.Int32[src_i] = nil
		} else {
			dst.Int32[src_i] = new(int32)
			*dst.Int32[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Int64 {
		if src_value == nil {
			dst.Int64[src_i] = nil
		} else {
			dst.Int64[src_i] = new(int64)
			*dst.Int64[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Int8 {
		if src_value == nil {
			dst.Int8[src_i] = nil
		} else {
			dst.Int8[src_i] = new(int8)
			*dst.Int8[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Rune {
		if src_value == nil {
			dst.Rune[src_i] = nil
		} else {
			dst.Rune[src_i] = new(rune)
			*dst.Rune[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.String {
		if src_value == nil {
			dst.String[src_i] = nil
		} else {
			dst.String[src_i] = new(string)
			*dst.String[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Uint {
		if src_value == nil {
			dst.Uint[src_i] = nil
		} else {
			dst.Uint[src_i] = new(uint)
			*dst.Uint[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Uint16 {
		if src_value == nil {
			dst.Uint16[src_i] = nil
		} else {
			dst.Uint16[src_i] = new(uint16)
			*dst.Uint16[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Uint32 {
		if src_value == nil {
			dst.Uint32[src_i] = nil
		} else {
			dst.Uint32[src_i] = new(uint32)
			*dst.Uint32[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Uint64 {
		if src_value == nil {
			dst.Uint64[src_i] = nil
		} else {
			dst.Uint64[src_i] = new(uint64)
			*dst.Uint64[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.Uint8 {
		if src_value == nil {
			dst.Uint8[src_i] = nil
		} else {
			dst.Uint8[src_i] = new(uint8)
			*dst.Uint8[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.UintPtr {
		if src_value == nil {
			dst.UintPtr[src_i] = nil
		} else {
			dst.UintPtr[src_i] = new(uintptr)
			*dst.UintPtr[src_i] = *src_value
		}
	}
	for src_i, src_value := range src.AnotherBoolOfDifferentSize {
		if src_value == nil {
			dst.AnotherBoolOfDifferentSize[src_i] = nil
		} else {
			dst.AnotherBoolOfDifferentSize[src_i] = new(bool)
			*dst.AnotherBoolOfDifferentSize[src_i] = *src_value
		}
	}
}

// deriveDeepCopyPtrToMapsOfSimplerBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToMapsOfSimplerBuiltInTypes(dst, src *MapsOfSimplerBuiltInTypes) {
	if src.StringToUint32 != nil {
		dst.StringToUint32 = make(map[string]uint32, len(src.StringToUint32))
		deriveDeepCopy_16(dst.StringToUint32, src.StringToUint32)
	} else {
		dst.StringToUint32 = nil
	}
	if src.Uint64ToInt64 != nil {
		dst.Uint64ToInt64 = make(map[uint8]int64, len(src.Uint64ToInt64))
		deriveDeepCopy_17(dst.Uint64ToInt64, src.Uint64ToInt64)
	} else {
		dst.Uint64ToInt64 = nil
	}
}

// deriveDeepCopyPtrToMapsOfBuiltInTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToMapsOfBuiltInTypes(dst, src *MapsOfBuiltInTypes) {
	if src.BoolToString != nil {
		dst.BoolToString = make(map[bool]string, len(src.BoolToString))
		deriveDeepCopy_18(dst.BoolToString, src.BoolToString)
	} else {
		dst.BoolToString = nil
	}
	if src.StringToBool != nil {
		dst.StringToBool = make(map[string]bool, len(src.StringToBool))
		deriveDeepCopy_19(dst.StringToBool, src.StringToBool)
	} else {
		dst.StringToBool = nil
	}
	if src.Complex128ToComplex64 != nil {
		dst.Complex128ToComplex64 = make(map[complex128]complex64, len(src.Complex128ToComplex64))
		deriveDeepCopy_20(dst.Complex128ToComplex64, src.Complex128ToComplex64)
	} else {
		dst.Complex128ToComplex64 = nil
	}
	if src.Float64ToUint32 != nil {
		dst.Float64ToUint32 = make(map[float64]uint32, len(src.Float64ToUint32))
		deriveDeepCopy_21(dst.Float64ToUint32, src.Float64ToUint32)
	} else {
		dst.Float64ToUint32 = nil
	}
	if src.Uint16ToUint8 != nil {
		dst.Uint16ToUint8 = make(map[uint16]uint8, len(src.Uint16ToUint8))
		deriveDeepCopy_22(dst.Uint16ToUint8, src.Uint16ToUint8)
	} else {
		dst.Uint16ToUint8 = nil
	}
}

// deriveDeepCopyPtrToSliceToSlice recursively copies the contents of src into dst.
func deriveDeepCopyPtrToSliceToSlice(dst, src *SliceToSlice) {
	if src.Ints == nil {
		dst.Ints = nil
	} else {
		if dst.Ints != nil {
			if len(src.Ints) > len(dst.Ints) {
				if cap(dst.Ints) >= len(src.Ints) {
					dst.Ints = (dst.Ints)[:len(src.Ints)]
				} else {
					dst.Ints = make([][]int, len(src.Ints))
				}
			} else if len(src.Ints) < len(dst.Ints) {
				dst.Ints = (dst.Ints)[:len(src.Ints)]
			}
		} else {
			dst.Ints = make([][]int, len(src.Ints))
		}
		deriveDeepCopy_23(dst.Ints, src.Ints)
	}
	if src.Strings == nil {
		dst.Strings = nil
	} else {
		if dst.Strings != nil {
			if len(src.Strings) > len(dst.Strings) {
				if cap(dst.Strings) >= len(src.Strings) {
					dst.Strings = (dst.Strings)[:len(src.Strings)]
				} else {
					dst.Strings = make([][]string, len(src.Strings))
				}
			} else if len(src.Strings) < len(dst.Strings) {
				dst.Strings = (dst.Strings)[:len(src.Strings)]
			}
		} else {
			dst.Strings = make([][]string, len(src.Strings))
		}
		deriveDeepCopy_24(dst.Strings, src.Strings)
	}
	if src.IntPtrs == nil {
		dst.IntPtrs = nil
	} else {
		if dst.IntPtrs != nil {
			if len(src.IntPtrs) > len(dst.IntPtrs) {
				if cap(dst.IntPtrs) >= len(src.IntPtrs) {
					dst.IntPtrs = (dst.IntPtrs)[:len(src.IntPtrs)]
				} else {
					dst.IntPtrs = make([][]*int, len(src.IntPtrs))
				}
			} else if len(src.IntPtrs) < len(dst.IntPtrs) {
				dst.IntPtrs = (dst.IntPtrs)[:len(src.IntPtrs)]
			}
		} else {
			dst.IntPtrs = make([][]*int, len(src.IntPtrs))
		}
		deriveDeepCopy_25(dst.IntPtrs, src.IntPtrs)
	}
}

// deriveDeepCopyPtrToPtrTo recursively copies the contents of src into dst.
func deriveDeepCopyPtrToPtrTo(dst, src *PtrTo) {
	if src.Basic == nil {
		dst.Basic = nil
	} else {
		dst.Basic = new(int)
		*dst.Basic = *src.Basic
	}
	if src.Slice == nil {
		dst.Slice = nil
	} else {
		dst.Slice = new([]int)
		deriveDeepCopy_26(dst.Slice, src.Slice)
	}
	if src.Array == nil {
		dst.Array = nil
	} else {
		dst.Array = new([4]int)
		*dst.Array = *src.Array
	}
	if src.Map == nil {
		dst.Map = nil
	} else {
		dst.Map = new(map[int]int)
		deriveDeepCopy_27(dst.Map, src.Map)
	}
}

// deriveDeepCopyPtrToName recursively copies the contents of src into dst.
func deriveDeepCopyPtrToName(dst, src *Name) {
	dst.Name = src.Name
}

// deriveDeepCopyPtrToStructs recursively copies the contents of src into dst.
func deriveDeepCopyPtrToStructs(dst, src *Structs) {
	dst.Struct = src.Struct
	if src.PtrToStruct == nil {
		dst.PtrToStruct = nil
	} else {
		dst.PtrToStruct = new(Name)
		src.PtrToStruct.DeepCopy(dst.PtrToStruct)
	}
	if src.SliceOfStructs == nil {
		dst.SliceOfStructs = nil
	} else {
		if dst.SliceOfStructs != nil {
			if len(src.SliceOfStructs) > len(dst.SliceOfStructs) {
				if cap(dst.SliceOfStructs) >= len(src.SliceOfStructs) {
					dst.SliceOfStructs = (dst.SliceOfStructs)[:len(src.SliceOfStructs)]
				} else {
					dst.SliceOfStructs = make([]Name, len(src.SliceOfStructs))
				}
			} else if len(src.SliceOfStructs) < len(dst.SliceOfStructs) {
				dst.SliceOfStructs = (dst.SliceOfStructs)[:len(src.SliceOfStructs)]
			}
		} else {
			dst.SliceOfStructs = make([]Name, len(src.SliceOfStructs))
		}
		copy(dst.SliceOfStructs, src.SliceOfStructs)
	}
	if src.SliceToPtrOfStruct == nil {
		dst.SliceToPtrOfStruct = nil
	} else {
		if dst.SliceToPtrOfStruct != nil {
			if len(src.SliceToPtrOfStruct) > len(dst.SliceToPtrOfStruct) {
				if cap(dst.SliceToPtrOfStruct) >= len(src.SliceToPtrOfStruct) {
					dst.SliceToPtrOfStruct = (dst.SliceToPtrOfStruct)[:len(src.SliceToPtrOfStruct)]
				} else {
					dst.SliceToPtrOfStruct = make([]*Name, len(src.SliceToPtrOfStruct))
				}
			} else if len(src.SliceToPtrOfStruct) < len(dst.SliceToPtrOfStruct) {
				dst.SliceToPtrOfStruct = (dst.SliceToPtrOfStruct)[:len(src.SliceToPtrOfStruct)]
			}
		} else {
			dst.SliceToPtrOfStruct = make([]*Name, len(src.SliceToPtrOfStruct))
		}
		deriveDeepCopy_28(dst.SliceToPtrOfStruct, src.SliceToPtrOfStruct)
	}
	dst.StructWithoutMethod = src.StructWithoutMethod
	if src.PtrToStructWithoutMethod == nil {
		dst.PtrToStructWithoutMethod = nil
	} else {
		dst.PtrToStructWithoutMethod = new(StructWithoutMethod)
		*dst.PtrToStructWithoutMethod = *src.PtrToStructWithoutMethod
	}
	if src.SliceOfStructWithoutMethod == nil {
		dst.SliceOfStructWithoutMethod = nil
	} else {
		if dst.SliceOfStructWithoutMethod != nil {
			if len(src.SliceOfStructWithoutMethod) > len(dst.SliceOfStructWithoutMethod) {
				if cap(dst.SliceOfStructWithoutMethod) >= len(src.SliceOfStructWithoutMethod) {
					dst.SliceOfStructWithoutMethod = (dst.SliceOfStructWithoutMethod)[:len(src.SliceOfStructWithoutMethod)]
				} else {
					dst.SliceOfStructWithoutMethod = make([]StructWithoutMethod, len(src.SliceOfStructWithoutMethod))
				}
			} else if len(src.SliceOfStructWithoutMethod) < len(dst.SliceOfStructWithoutMethod) {
				dst.SliceOfStructWithoutMethod = (dst.SliceOfStructWithoutMethod)[:len(src.SliceOfStructWithoutMethod)]
			}
		} else {
			dst.SliceOfStructWithoutMethod = make([]StructWithoutMethod, len(src.SliceOfStructWithoutMethod))
		}
		copy(dst.SliceOfStructWithoutMethod, src.SliceOfStructWithoutMethod)
	}
	if src.SliceToPtrOfStructWithoutMethod == nil {
		dst.SliceToPtrOfStructWithoutMethod = nil
	} else {
		if dst.SliceToPtrOfStructWithoutMethod != nil {
			if len(src.SliceToPtrOfStructWithoutMethod) > len(dst.SliceToPtrOfStructWithoutMethod) {
				if cap(dst.SliceToPtrOfStructWithoutMethod) >= len(src.SliceToPtrOfStructWithoutMethod) {
					dst.SliceToPtrOfStructWithoutMethod = (dst.SliceToPtrOfStructWithoutMethod)[:len(src.SliceToPtrOfStructWithoutMethod)]
				} else {
					dst.SliceToPtrOfStructWithoutMethod = make([]*StructWithoutMethod, len(src.SliceToPtrOfStructWithoutMethod))
				}
			} else if len(src.SliceToPtrOfStructWithoutMethod) < len(dst.SliceToPtrOfStructWithoutMethod) {
				dst.SliceToPtrOfStructWithoutMethod = (dst.SliceToPtrOfStructWithoutMethod)[:len(src.SliceToPtrOfStructWithoutMethod)]
			}
		} else {
			dst.SliceToPtrOfStructWithoutMethod = make([]*StructWithoutMethod, len(src.SliceToPtrOfStructWithoutMethod))
		}
		deriveDeepCopy_29(dst.SliceToPtrOfStructWithoutMethod, src.SliceToPtrOfStructWithoutMethod)
	}
}

// deriveDeepCopyPtrToMapWithStructs recursively copies the contents of src into dst.
func deriveDeepCopyPtrToMapWithStructs(dst, src *MapWithStructs) {
	if src.NameToString != nil {
		dst.NameToString = make(map[Name]string, len(src.NameToString))
		deriveDeepCopy_30(dst.NameToString, src.NameToString)
	} else {
		dst.NameToString = nil
	}
	if src.StringToName != nil {
		dst.StringToName = make(map[string]Name, len(src.StringToName))
		deriveDeepCopy_31(dst.StringToName, src.StringToName)
	} else {
		dst.StringToName = nil
	}
	if src.StringToPtrToName != nil {
		dst.StringToPtrToName = make(map[string]*Name, len(src.StringToPtrToName))
		deriveDeepCopy_32(dst.StringToPtrToName, src.StringToPtrToName)
	} else {
		dst.StringToPtrToName = nil
	}
	if src.StringToSliceOfName != nil {
		dst.StringToSliceOfName = make(map[string][]Name, len(src.StringToSliceOfName))
		deriveDeepCopy_33(dst.StringToSliceOfName, src.StringToSliceOfName)
	} else {
		dst.StringToSliceOfName = nil
	}
	if src.StringToSliceOfPtrToName != nil {
		dst.StringToSliceOfPtrToName = make(map[string][]*Name, len(src.StringToSliceOfPtrToName))
		deriveDeepCopy_34(dst.StringToSliceOfPtrToName, src.StringToSliceOfPtrToName)
	} else {
		dst.StringToSliceOfPtrToName = nil
	}
	if src.StringToStructWithoutMethod != nil {
		dst.StringToStructWithoutMethod = make(map[string]StructWithoutMethod, len(src.StringToStructWithoutMethod))
		deriveDeepCopy_35(dst.StringToStructWithoutMethod, src.StringToStructWithoutMethod)
	} else {
		dst.StringToStructWithoutMethod = nil
	}
	if src.StructWithoutMethodToString != nil {
		dst.StructWithoutMethodToString = make(map[StructWithoutMethod]string, len(src.StructWithoutMethodToString))
		deriveDeepCopy_36(dst.StructWithoutMethodToString, src.StructWithoutMethodToString)
	} else {
		dst.StructWithoutMethodToString = nil
	}
	if src.StringToPtrToStructWithoutMethod != nil {
		dst.StringToPtrToStructWithoutMethod = make(map[string]*StructWithoutMethod, len(src.StringToPtrToStructWithoutMethod))
		deriveDeepCopy_37(dst.StringToPtrToStructWithoutMethod, src.StringToPtrToStructWithoutMethod)
	} else {
		dst.StringToPtrToStructWithoutMethod = nil
	}
	if src.StringToSliceOfStructWithoutMethod != nil {
		dst.StringToSliceOfStructWithoutMethod = make(map[string][]StructWithoutMethod, len(src.StringToSliceOfStructWithoutMethod))
		deriveDeepCopy_38(dst.StringToSliceOfStructWithoutMethod, src.StringToSliceOfStructWithoutMethod)
	} else {
		dst.StringToSliceOfStructWithoutMethod = nil
	}
	if src.StringToSliceOfPtrToStructWithoutMethod != nil {
		dst.StringToSliceOfPtrToStructWithoutMethod = make(map[string][]*StructWithoutMethod, len(src.StringToSliceOfPtrToStructWithoutMethod))
		deriveDeepCopy_39(dst.StringToSliceOfPtrToStructWithoutMethod, src.StringToSliceOfPtrToStructWithoutMethod)
	} else {
		dst.StringToSliceOfPtrToStructWithoutMethod = nil
	}
}

// deriveDeepCopyPtrToRecursiveType recursively copies the contents of src into dst.
func deriveDeepCopyPtrToRecursiveType(dst, src *RecursiveType) {
	if src.Bytes == nil {
		dst.Bytes = nil
	} else {
		if dst.Bytes != nil {
			if len(src.Bytes) > len(dst.Bytes) {
				if cap(dst.Bytes) >= len(src.Bytes) {
					dst.Bytes = (dst.Bytes)[:len(src.Bytes)]
				} else {
					dst.Bytes = make([]byte, len(src.Bytes))
				}
			} else if len(src.Bytes) < len(dst.Bytes) {
				dst.Bytes = (dst.Bytes)[:len(src.Bytes)]
			}
		} else {
			dst.Bytes = make([]byte, len(src.Bytes))
		}
		copy(dst.Bytes, src.Bytes)
	}
	if src.N != nil {
		dst.N = make(map[int]RecursiveType, len(src.N))
		deriveDeepCopy_40(dst.N, src.N)
	} else {
		dst.N = nil
	}
}

// deriveDeepCopyPtrToEmbeddedStruct1 recursively copies the contents of src into dst.
func deriveDeepCopyPtrToEmbeddedStruct1(dst, src *EmbeddedStruct1) {
	dst.Name = src.Name
	dst.StructWithoutMethod = src.StructWithoutMethod
	if src.Structs == nil {
		dst.Structs = nil
	} else {
		dst.Structs = new(Structs)
		src.Structs.DeepCopy(dst.Structs)
	}
}

// deriveDeepCopyPtrToEmbeddedStruct2 recursively copies the contents of src into dst.
func deriveDeepCopyPtrToEmbeddedStruct2(dst, src *EmbeddedStruct2) {
	{
		field := new(Structs)
		src.Structs.DeepCopy(field)
		dst.Structs = *field
	}
	if src.Name == nil {
		dst.Name = nil
	} else {
		dst.Name = new(Name)
		src.Name.DeepCopy(dst.Name)
	}
	if src.StructWithoutMethod == nil {
		dst.StructWithoutMethod = nil
	} else {
		dst.StructWithoutMethod = new(StructWithoutMethod)
		*dst.StructWithoutMethod = *src.StructWithoutMethod
	}
}

// deriveDeepCopyPtrToUnnamedStruct recursively copies the contents of src into dst.
func deriveDeepCopyPtrToUnnamedStruct(dst, src *UnnamedStruct) {
	dst.Unnamed = src.Unnamed
}

// deriveDeepCopyPtrToStructWithStructFieldWithoutEqualMethod recursively copies the contents of src into dst.
func deriveDeepCopyPtrToStructWithStructFieldWithoutEqualMethod(dst, src *StructWithStructFieldWithoutEqualMethod) {
	if src.A == nil {
		dst.A = nil
	} else {
		dst.A = new(StructWithoutEqualMethod)
		*dst.A = *src.A
	}
	dst.B = src.B
}

// deriveDeepCopyPtrToStructWithStructWithFromAnotherPackage recursively copies the contents of src into dst.
func deriveDeepCopyPtrToStructWithStructWithFromAnotherPackage(dst, src *StructWithStructWithFromAnotherPackage) {
	if src.A == nil {
		dst.A = nil
	} else {
		dst.A = new(extra.StructWithoutEqualMethod)
		*dst.A = *src.A
	}
	dst.B = src.B
}

// deriveDeepCopyPtrToFieldWithStructWithPrivateFields recursively copies the contents of src into dst.
func deriveDeepCopyPtrToFieldWithStructWithPrivateFields(dst, src *FieldWithStructWithPrivateFields) {
	if src.A == nil {
		dst.A = nil
	} else {
		dst.A = new(extra.PrivateFieldAndNoEqualMethod)
		deriveDeepCopy_41(dst.A, src.A)
	}
}

// deriveDeepCopyPtrToEnums recursively copies the contents of src into dst.
func deriveDeepCopyPtrToEnums(dst, src *Enums) {
	dst.Enum = src.Enum
	if src.PtrToEnum == nil {
		dst.PtrToEnum = nil
	} else {
		dst.PtrToEnum = new(MyEnum)
		*dst.PtrToEnum = *src.PtrToEnum
	}
	if src.SliceToEnum == nil {
		dst.SliceToEnum = nil
	} else {
		if dst.SliceToEnum != nil {
			if len(src.SliceToEnum) > len(dst.SliceToEnum) {
				if cap(dst.SliceToEnum) >= len(src.SliceToEnum) {
					dst.SliceToEnum = (dst.SliceToEnum)[:len(src.SliceToEnum)]
				} else {
					dst.SliceToEnum = make([]MyEnum, len(src.SliceToEnum))
				}
			} else if len(src.SliceToEnum) < len(dst.SliceToEnum) {
				dst.SliceToEnum = (dst.SliceToEnum)[:len(src.SliceToEnum)]
			}
		} else {
			dst.SliceToEnum = make([]MyEnum, len(src.SliceToEnum))
		}
		copy(dst.SliceToEnum, src.SliceToEnum)
	}
	if src.SliceToPtrToEnum == nil {
		dst.SliceToPtrToEnum = nil
	} else {
		if dst.SliceToPtrToEnum != nil {
			if len(src.SliceToPtrToEnum) > len(dst.SliceToPtrToEnum) {
				if cap(dst.SliceToPtrToEnum) >= len(src.SliceToPtrToEnum) {
					dst.SliceToPtrToEnum = (dst.SliceToPtrToEnum)[:len(src.SliceToPtrToEnum)]
				} else {
					dst.SliceToPtrToEnum = make([]*MyEnum, len(src.SliceToPtrToEnum))
				}
			} else if len(src.SliceToPtrToEnum) < len(dst.SliceToPtrToEnum) {
				dst.SliceToPtrToEnum = (dst.SliceToPtrToEnum)[:len(src.SliceToPtrToEnum)]
			}
		} else {
			dst.SliceToPtrToEnum = make([]*MyEnum, len(src.SliceToPtrToEnum))
		}
		deriveDeepCopy_42(dst.SliceToPtrToEnum, src.SliceToPtrToEnum)
	}
	if src.MapToEnum != nil {
		dst.MapToEnum = make(map[int32]MyEnum, len(src.MapToEnum))
		deriveDeepCopy_43(dst.MapToEnum, src.MapToEnum)
	} else {
		dst.MapToEnum = nil
	}
	if src.EnumToMap != nil {
		dst.EnumToMap = make(map[MyEnum]int32, len(src.EnumToMap))
		deriveDeepCopy_44(dst.EnumToMap, src.EnumToMap)
	} else {
		dst.EnumToMap = nil
	}
	dst.ArrayEnum = src.ArrayEnum
}

// deriveDeepCopyPtrToNamedTypes recursively copies the contents of src into dst.
func deriveDeepCopyPtrToNamedTypes(dst, src *NamedTypes) {
	if src.Slice == nil {
		dst.Slice = nil
	} else {
		if dst.Slice != nil {
			if len(src.Slice) > len(dst.Slice) {
				if cap(dst.Slice) >= len(src.Slice) {
					dst.Slice = (dst.Slice)[:len(src.Slice)]
				} else {
					dst.Slice = make([]int64, len(src.Slice))
				}
			} else if len(src.Slice) < len(dst.Slice) {
				dst.Slice = (dst.Slice)[:len(src.Slice)]
			}
		} else {
			dst.Slice = make([]int64, len(src.Slice))
		}
		copy(dst.Slice, src.Slice)
	}
	if src.PtrToSlice == nil {
		dst.PtrToSlice = nil
	} else {
		dst.PtrToSlice = new(MySlice)
		deriveDeepCopy_45(dst.PtrToSlice, src.PtrToSlice)
	}
	if src.SliceToSlice == nil {
		dst.SliceToSlice = nil
	} else {
		if dst.SliceToSlice != nil {
			if len(src.SliceToSlice) > len(dst.SliceToSlice) {
				if cap(dst.SliceToSlice) >= len(src.SliceToSlice) {
					dst.SliceToSlice = (dst.SliceToSlice)[:len(src.SliceToSlice)]
				} else {
					dst.SliceToSlice = make([]MySlice, len(src.SliceToSlice))
				}
			} else if len(src.SliceToSlice) < len(dst.SliceToSlice) {
				dst.SliceToSlice = (dst.SliceToSlice)[:len(src.SliceToSlice)]
			}
		} else {
			dst.SliceToSlice = make([]MySlice, len(src.SliceToSlice))
		}
		deriveDeepCopy_46(dst.SliceToSlice, src.SliceToSlice)
	}
}

// deriveDeepCopyPtrToDuration recursively copies the contents of src into dst.
func deriveDeepCopyPtrToDuration(dst, src *Duration) {
	dst.D = src.D
	if src.P == nil {
		dst.P = nil
	} else {
		dst.P = new(time.Duration)
		*dst.P = *src.P
	}
	if src.Ds == nil {
		dst.Ds = nil
	} else {
		if dst.Ds != nil {
			if len(src.Ds) > len(dst.Ds) {
				if cap(dst.Ds) >= len(src.Ds) {
					dst.Ds = (dst.Ds)[:len(src.Ds)]
				} else {
					dst.Ds = make([]time.Duration, len(src.Ds))
				}
			} else if len(src.Ds) < len(dst.Ds) {
				dst.Ds = (dst.Ds)[:len(src.Ds)]
			}
		} else {
			dst.Ds = make([]time.Duration, len(src.Ds))
		}
		copy(dst.Ds, src.Ds)
	}
	if src.DPs == nil {
		dst.DPs = nil
	} else {
		if dst.DPs != nil {
			if len(src.DPs) > len(dst.DPs) {
				if cap(dst.DPs) >= len(src.DPs) {
					dst.DPs = (dst.DPs)[:len(src.DPs)]
				} else {
					dst.DPs = make([]*time.Duration, len(src.DPs))
				}
			} else if len(src.DPs) < len(dst.DPs) {
				dst.DPs = (dst.DPs)[:len(src.DPs)]
			}
		} else {
			dst.DPs = make([]*time.Duration, len(src.DPs))
		}
		deriveDeepCopy_47(dst.DPs, src.DPs)
	}
	if src.MD != nil {
		dst.MD = make(map[int]time.Duration, len(src.MD))
		deriveDeepCopy_48(dst.MD, src.MD)
	} else {
		dst.MD = nil
	}
}

// deriveDeepCopyPtrToNickname recursively copies the contents of src into dst.
func deriveDeepCopyPtrToNickname(dst, src *Nickname) {
	if src.Alias != nil {
		dst.Alias = make(map[string][]*pickle.Rick, len(src.Alias))
		deriveDeepCopy_49(dst.Alias, src.Alias)
	} else {
		dst.Alias = nil
	}
}

// deriveDeepCopyPtrToPrivateEmbedded recursively copies the contents of src into dst.
func deriveDeepCopyPtrToPrivateEmbedded(dst, src *PrivateEmbedded) {
	{
		field := new(privateStruct)
		deriveDeepCopy_50(field, &src.privateStruct)
		dst.privateStruct = *field
	}
}

// deriveDeepCopyPtrToStructOfStructs recursively copies the contents of src into dst.
func deriveDeepCopyPtrToStructOfStructs(dst, src *StructOfStructs) {
	{
		field := new(Structs)
		src.S1.DeepCopy(field)
		dst.S1 = *field
	}
	{
		field := new(Structs)
		src.S2.DeepCopy(field)
		dst.S2 = *field
	}
}

// deriveDeepCopySimpleStructWithDeepCopy recursively copies the contents of src into dst.
func deriveDeepCopySimpleStructWithDeepCopy(dst, src *SimpleStructWithDeepCopy) {
	dst.Level = src.Level
}

// deriveDeepCopyAliasWithMethod recursively copies the contents of src into dst.
func deriveDeepCopyAliasWithMethod(dst, src *aliasWithMethod) {
	dst.Level = src.Level
}

// deriveContainsInt64s returns whether the item is contained in the list.
//
// Deprecated: In favour of generics.
func deriveContainsInt64s(list []int64, item int64) bool {
	for _, v := range list {
		if v == item {
			return true
		}
	}
	return false
}

// deriveContainsStruct returns whether the item is contained in the list.
//
// Deprecated: In favour of generics.
func deriveContainsStruct(list []*BuiltInTypes, item *BuiltInTypes) bool {
	for _, v := range list {
		if deriveEqualPtrToBuiltInTypes(v, item) {
			return true
		}
	}
	return false
}

// deriveContainsStructPtr returns whether the item is contained in the list.
//
// Deprecated: In favour of generics.
func deriveContainsStructPtr(list []PtrToBuiltInTypes, item PtrToBuiltInTypes) bool {
	for _, v := range list {
		if deriveEqual(v, item) {
			return true
		}
	}
	return false
}

// deriveUncurryMarshal combines a function that returns a function, into one function.
func deriveUncurryMarshal(f func(data []byte) func(v any) error) func(data []byte, v any) error {
	return func(data []byte, v any) error {
		return f(data)(v)
	}
}

// deriveUncurry3 combines a function that returns a function, into one function.
func deriveUncurry3(f func(a int) func(b string, c bool) string) func(a int, b string, c bool) string {
	return func(a int, b string, c bool) string {
		return f(a)(b, c)
	}
}

// deriveUncurryCurried combines a function that returns a function, into one function.
func deriveUncurryCurried(f func(b string) func(c bool) string) func(b string, c bool) string {
	return func(b string, c bool) string {
		return f(b)(c)
	}
}

// deriveUncurryBlankIdentifier combines a function that returns a function, into one function.
func deriveUncurryBlankIdentifier(f func(param_0 string) func(innerParam_0 bool, c int) string) func(param_0 string, innerParam_0 bool, c int) string {
	return func(param_0 string, innerParam_0 bool, c int) string {
		return f(param_0)(innerParam_0, c)
	}
}

// deriveToError0 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError0(err error, f func() bool) func() error {
	return func() error {
		success := f()
		if success {
			return nil
		}
		return err
	}
}

// deriveToError1 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError1(err error, f func() (int, bool)) func() (int, error) {
	return func() (int, error) {
		out0, success := f()
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveToError2 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError2(err error, f func(a int) (int, bool)) func(a int) (int, error) {
	return func(a int) (int, error) {
		out0, success := f(a)
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveToError3 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError3(err error, f func(a int, b int) (int, bool)) func(a int, b int) (int, error) {
	return func(a int, b int) (int, error) {
		out0, success := f(a, b)
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveToError4 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError4(err error, f func(a int, b int) (int, int, bool)) func(a int, b int) (int, int, error) {
	return func(a int, b int) (int, int, error) {
		out0, out1, success := f(a, b)
		if success {
			return out0, out1, nil
		}
		return out0, out1, err
	}
}

// deriveToError5 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError5(err error, f func(lt *LocalType) (*LocalType, bool)) func(lt *LocalType) (*LocalType, error) {
	return func(lt *LocalType) (*LocalType, error) {
		out0, success := f(lt)
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveToError6 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError6(err error, f func(t *time.Time) (*time.Time, bool)) func(t *time.Time) (*time.Time, error) {
	return func(t *time.Time) (*time.Time, error) {
		out0, success := f(t)
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveToError7 transforms the given function's last bool type into an error type. The transformed function returns the given error when the result of the given function is false, otherwise it returns nil.
func deriveToError7(err error, f func(param_0 string) (string, bool)) func(param_0 string) (string, error) {
	return func(param_0 string) (string, error) {
		out0, success := f(param_0)
		if success {
			return out0, nil
		}
		return out0, err
	}
}

// deriveCompose composes functions f0 and f1 into one function, that takes the parameters from f0 and returns the results from f1.
func deriveCompose(f0 func() (string, error), f1 func(string) (float64, error)) func() (float64, error) {
	return func() (float64, error) {
		v_1_0, err0 := f0()
		if err0 != nil {
			return 0, err0
		}
		v_2_0, err1 := f1(v_1_0)
		if err1 != nil {
			return 0, err1
		}
		return v_2_0, nil
	}
}

// deriveComposeA composes functions f0 and f1 into one function, that takes the parameters from f0 and returns the results from f1.
func deriveComposeA(f0 func(string) (string, error), f1 func(string) (float64, error)) func(string) (float64, error) {
	return func(v_0_0 string) (float64, error) {
		v_1_0, err0 := f0(v_0_0)
		if err0 != nil {
			return 0, err0
		}
		v_2_0, err1 := f1(v_1_0)
		if err1 != nil {
			return 0, err1
		}
		return v_2_0, nil
	}
}

// deriveCompose2 composes functions f0 and f1 into one function, that takes the parameters from f0 and returns the results from f1.
func deriveCompose2(f0 func(string, string) ([]string, string, error), f1 func([]string, string) (float64, error)) func(string, string) (float64, error) {
	return func(v_0_0 string, v_0_1 string) (float64, error) {
		v_1_0, v_1_1, err0 := f0(v_0_0, v_0_1)
		if err0 != nil {
			return 0, err0
		}
		v_2_0, err1 := f1(v_1_0, v_1_1)
		if err1 != nil {
			return 0, err1
		}
		return v_2_0, nil
	}
}

// deriveComposeRetBool composes functions f0 and f1 into one function, that takes the parameters from f0 and returns the results from f1.
func deriveComposeRetBool(f0 func(string) (string, error), f1 func(string) (bool, error)) func(string) (bool, error) {
	return func(v_0_0 string) (bool, error) {
		v_1_0, err0 := f0(v_0_0)
		if err0 != nil {
			return false, err0
		}
		v_2_0, err1 := f1(v_1_0)
		if err1 != nil {
			return false, err1
		}
		return v_2_0, nil
	}
}

// deriveComposeVariadic composes functions f0, f1 and f2 into one function, that takes the parameters from f0 and returns the results from f2.
func deriveComposeVariadic(f0 func(string) (string, error), f1 func(string) (float64, error), f2 func(float64) (int, error)) func(string) (int, error) {
	return func(v_0_0 string) (int, error) {
		v_1_0, err0 := f0(v_0_0)
		if err0 != nil {
			return 0, err0
		}
		v_2_0, err1 := f1(v_1_0)
		if err1 != nil {
			return 0, err1
		}
		v_3_0, err2 := f2(v_2_0)
		if err2 != nil {
			return 0, err2
		}
		return v_3_0, nil
	}
}

// deriveComparePtrToEmpty returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToEmpty(this, that *Empty) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return 0
}

// deriveComparePtrToBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToBuiltInTypes(this, that *BuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := deriveCompare_(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompareComplex64(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompareComplex32(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_f(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_fl(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_i(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_in(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_int(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_int6(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_int8(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_int(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := strings.Compare(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_u(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_ui(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_uin(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_uint(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := deriveCompare_(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_1(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToPrivateBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToPrivateBuiltInTypes(this, that *PrivateBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare(this.privateBool, that.privateBool); c != 0 {
		return c
	}
	if c := deriveCompare_(this.privateByte, that.privateByte); c != 0 {
		return c
	}
	if c := deriveCompareComplex64(this.privateComplex128, that.privateComplex128); c != 0 {
		return c
	}
	if c := deriveCompareComplex32(this.privateComplex64, that.privateComplex64); c != 0 {
		return c
	}
	if c := deriveCompare_f(this.privateFloat64, that.privateFloat64); c != 0 {
		return c
	}
	if c := deriveCompare_fl(this.privateFloat32, that.privateFloat32); c != 0 {
		return c
	}
	if c := deriveCompare_i(this.privateInt, that.privateInt); c != 0 {
		return c
	}
	if c := deriveCompare_in(this.privateInt16, that.privateInt16); c != 0 {
		return c
	}
	if c := deriveCompare_int(this.privateInt32, that.privateInt32); c != 0 {
		return c
	}
	if c := deriveCompare_int6(this.privateInt64, that.privateInt64); c != 0 {
		return c
	}
	if c := deriveCompare_int8(this.privateInt8, that.privateInt8); c != 0 {
		return c
	}
	if c := deriveCompare_int(this.privateRune, that.privateRune); c != 0 {
		return c
	}
	if c := strings.Compare(this.privateString, that.privateString); c != 0 {
		return c
	}
	if c := deriveCompare_u(this.privateUint, that.privateUint); c != 0 {
		return c
	}
	if c := deriveCompare_ui(this.privateUint16, that.privateUint16); c != 0 {
		return c
	}
	if c := deriveCompare_uin(this.privateUint32, that.privateUint32); c != 0 {
		return c
	}
	if c := deriveCompare_uint(this.privateUint64, that.privateUint64); c != 0 {
		return c
	}
	if c := deriveCompare_(this.privateUint8, that.privateUint8); c != 0 {
		return c
	}
	if c := deriveCompare_1(this.privateUintPtr, that.privateUintPtr); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToPtrToBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToPtrToBuiltInTypes(this, that *PtrToBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_2(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := deriveCompare_3(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompare_4(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompare_5(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_6(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_7(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_8(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_9(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_10(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_11(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_12(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_10(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := deriveCompare_13(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_14(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_15(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_16(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_17(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := deriveCompare_3(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_18(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToSliceOfBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToSliceOfBuiltInTypes(this, that *SliceOfBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_19(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := bytes.Compare(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompare_20(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompare_21(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_22(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_23(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_24(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_25(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_26(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_27(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_28(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_26(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := deriveCompare_29(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_30(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_31(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_32(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_33(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := bytes.Compare(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_34(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToSliceOfPtrToBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToSliceOfPtrToBuiltInTypes(this, that *SliceOfPtrToBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_35(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := deriveCompare_36(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompare_37(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompare_38(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_39(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_40(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_41(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_42(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_43(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_44(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_45(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_43(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := deriveCompare_46(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_47(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_48(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_49(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_50(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := deriveCompare_36(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_51(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToArrayOfBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToArrayOfBuiltInTypes(this, that *ArrayOfBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_52(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := deriveCompare_53(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompare_54(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompare_55(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_56(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_57(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_58(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_59(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_60(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_61(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_62(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_63(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := deriveCompare_64(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_65(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_66(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_67(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_68(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := deriveCompare_69(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_70(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	if c := deriveCompare_71(this.AnotherBoolOfDifferentSize, that.AnotherBoolOfDifferentSize); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToArrayOfPtrToBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToArrayOfPtrToBuiltInTypes(this, that *ArrayOfPtrToBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_72(this.Bool, that.Bool); c != 0 {
		return c
	}
	if c := deriveCompare_73(this.Byte, that.Byte); c != 0 {
		return c
	}
	if c := deriveCompare_74(this.Complex128, that.Complex128); c != 0 {
		return c
	}
	if c := deriveCompare_75(this.Complex64, that.Complex64); c != 0 {
		return c
	}
	if c := deriveCompare_76(this.Float64, that.Float64); c != 0 {
		return c
	}
	if c := deriveCompare_77(this.Float32, that.Float32); c != 0 {
		return c
	}
	if c := deriveCompare_78(this.Int, that.Int); c != 0 {
		return c
	}
	if c := deriveCompare_79(this.Int16, that.Int16); c != 0 {
		return c
	}
	if c := deriveCompare_80(this.Int32, that.Int32); c != 0 {
		return c
	}
	if c := deriveCompare_81(this.Int64, that.Int64); c != 0 {
		return c
	}
	if c := deriveCompare_82(this.Int8, that.Int8); c != 0 {
		return c
	}
	if c := deriveCompare_83(this.Rune, that.Rune); c != 0 {
		return c
	}
	if c := deriveCompare_84(this.String, that.String); c != 0 {
		return c
	}
	if c := deriveCompare_85(this.Uint, that.Uint); c != 0 {
		return c
	}
	if c := deriveCompare_86(this.Uint16, that.Uint16); c != 0 {
		return c
	}
	if c := deriveCompare_87(this.Uint32, that.Uint32); c != 0 {
		return c
	}
	if c := deriveCompare_88(this.Uint64, that.Uint64); c != 0 {
		return c
	}
	if c := deriveCompare_89(this.Uint8, that.Uint8); c != 0 {
		return c
	}
	if c := deriveCompare_90(this.UintPtr, that.UintPtr); c != 0 {
		return c
	}
	if c := deriveCompare_91(this.AnotherBoolOfDifferentSize, that.AnotherBoolOfDifferentSize); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToMapsOfSimplerBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToMapsOfSimplerBuiltInTypes(this, that *MapsOfSimplerBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_92(this.StringToUint32, that.StringToUint32); c != 0 {
		return c
	}
	if c := deriveCompare_93(this.Uint64ToInt64, that.Uint64ToInt64); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToMapsOfBuiltInTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToMapsOfBuiltInTypes(this, that *MapsOfBuiltInTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_94(this.BoolToString, that.BoolToString); c != 0 {
		return c
	}
	if c := deriveCompare_95(this.StringToBool, that.StringToBool); c != 0 {
		return c
	}
	if c := deriveCompare_96(this.Complex128ToComplex64, that.Complex128ToComplex64); c != 0 {
		return c
	}
	if c := deriveCompare_97(this.Float64ToUint32, that.Float64ToUint32); c != 0 {
		return c
	}
	if c := deriveCompare_98(this.Uint16ToUint8, that.Uint16ToUint8); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToSliceToSlice returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToSliceToSlice(this, that *SliceToSlice) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_99(this.Ints, that.Ints); c != 0 {
		return c
	}
	if c := deriveCompare_100(this.Strings, that.Strings); c != 0 {
		return c
	}
	if c := deriveCompare_101(this.IntPtrs, that.IntPtrs); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToPtrTo returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToPtrTo(this, that *PtrTo) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_8(this.Basic, that.Basic); c != 0 {
		return c
	}
	if c := deriveCompare_102(this.Slice, that.Slice); c != 0 {
		return c
	}
	if c := deriveCompare_103(this.Array, that.Array); c != 0 {
		return c
	}
	if c := deriveCompare_104(this.Map, that.Map); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToName returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToName(this, that *Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := strings.Compare(this.Name, that.Name); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToStructs returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToStructs(this, that *Structs) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := this.Struct.Compare(&that.Struct); c != 0 {
		return c
	}
	if c := this.PtrToStruct.Compare(that.PtrToStruct); c != 0 {
		return c
	}
	if c := deriveCompare_105(this.SliceOfStructs, that.SliceOfStructs); c != 0 {
		return c
	}
	if c := deriveCompare_106(this.SliceToPtrOfStruct, that.SliceToPtrOfStruct); c != 0 {
		return c
	}
	if c := deriveCompare_107(&this.StructWithoutMethod, &that.StructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_107(this.PtrToStructWithoutMethod, that.PtrToStructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_108(this.SliceOfStructWithoutMethod, that.SliceOfStructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_109(this.SliceToPtrOfStructWithoutMethod, that.SliceToPtrOfStructWithoutMethod); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToMapWithStructs returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToMapWithStructs(this, that *MapWithStructs) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_110(this.NameToString, that.NameToString); c != 0 {
		return c
	}
	if c := deriveCompare_111(this.StringToName, that.StringToName); c != 0 {
		return c
	}
	if c := deriveCompare_112(this.StringToPtrToName, that.StringToPtrToName); c != 0 {
		return c
	}
	if c := deriveCompare_113(this.StringToSliceOfName, that.StringToSliceOfName); c != 0 {
		return c
	}
	if c := deriveCompare_114(this.StringToSliceOfPtrToName, that.StringToSliceOfPtrToName); c != 0 {
		return c
	}
	if c := deriveCompare_115(this.StringToStructWithoutMethod, that.StringToStructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_116(this.StructWithoutMethodToString, that.StructWithoutMethodToString); c != 0 {
		return c
	}
	if c := deriveCompare_117(this.StringToPtrToStructWithoutMethod, that.StringToPtrToStructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_118(this.StringToSliceOfStructWithoutMethod, that.StringToSliceOfStructWithoutMethod); c != 0 {
		return c
	}
	if c := deriveCompare_119(this.StringToSliceOfPtrToStructWithoutMethod, that.StringToSliceOfPtrToStructWithoutMethod); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToRecursiveType returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToRecursiveType(this, that *RecursiveType) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := bytes.Compare(this.Bytes, that.Bytes); c != 0 {
		return c
	}
	if c := deriveCompare_120(this.N, that.N); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToEmbeddedStruct1 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToEmbeddedStruct1(this, that *EmbeddedStruct1) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := this.Name.Compare(&that.Name); c != 0 {
		return c
	}
	if c := deriveCompare_107(&this.StructWithoutMethod, &that.StructWithoutMethod); c != 0 {
		return c
	}
	if c := this.Structs.Compare(that.Structs); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToEmbeddedStruct2 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToEmbeddedStruct2(this, that *EmbeddedStruct2) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := this.Structs.Compare(&that.Structs); c != 0 {
		return c
	}
	if c := this.Name.Compare(that.Name); c != 0 {
		return c
	}
	if c := deriveCompare_107(this.StructWithoutMethod, that.StructWithoutMethod); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToStructWithStructFieldWithoutEqualMethod returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToStructWithStructFieldWithoutEqualMethod(this, that *StructWithStructFieldWithoutEqualMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_121(this.A, that.A); c != 0 {
		return c
	}
	if c := deriveCompare_121(&this.B, &that.B); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToStructWithStructWithFromAnotherPackage returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToStructWithStructWithFromAnotherPackage(this, that *StructWithStructWithFromAnotherPackage) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_122(this.A, that.A); c != 0 {
		return c
	}
	if c := deriveCompare_122(&this.B, &that.B); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToFieldWithStructWithPrivateFields returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToFieldWithStructWithPrivateFields(this, that *FieldWithStructWithPrivateFields) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_123(this.A, that.A); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToEnums returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToEnums(this, that *Enums) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_M(this.Enum, that.Enum); c != 0 {
		return c
	}
	if c := deriveCompare_124(this.PtrToEnum, that.PtrToEnum); c != 0 {
		return c
	}
	if c := deriveCompare_125(this.SliceToEnum, that.SliceToEnum); c != 0 {
		return c
	}
	if c := deriveCompare_126(this.SliceToPtrToEnum, that.SliceToPtrToEnum); c != 0 {
		return c
	}
	if c := deriveCompare_127(this.MapToEnum, that.MapToEnum); c != 0 {
		return c
	}
	if c := deriveCompare_128(this.EnumToMap, that.EnumToMap); c != 0 {
		return c
	}
	if c := deriveCompare_129(this.ArrayEnum, that.ArrayEnum); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToNamedTypes returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToNamedTypes(this, that *NamedTypes) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_27(this.Slice, that.Slice); c != 0 {
		return c
	}
	if c := deriveCompare_130(this.PtrToSlice, that.PtrToSlice); c != 0 {
		return c
	}
	if c := deriveCompare_131(this.SliceToSlice, that.SliceToSlice); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToDuration returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToDuration(this, that *Duration) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_D(this.D, that.D); c != 0 {
		return c
	}
	if c := deriveCompare_132(this.P, that.P); c != 0 {
		return c
	}
	if c := deriveCompare_133(this.Ds, that.Ds); c != 0 {
		return c
	}
	if c := deriveCompare_134(this.DPs, that.DPs); c != 0 {
		return c
	}
	if c := deriveCompare_135(this.MD, that.MD); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToNickname returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToNickname(this, that *Nickname) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_136(this.Alias, that.Alias); c != 0 {
		return c
	}
	return 0
}

// deriveComparePtrToPrivateEmbedded returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveComparePtrToPrivateEmbedded(this, that *PrivateEmbedded) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_137(&this.privateStruct, &that.privateStruct); c != 0 {
		return c
	}
	return 0
}

// deriveCompareComplex32 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareComplex32(this, that complex64) int {
	if thisr, thatr := real(this), real(that); thisr == thatr {
		if thisi, thati := imag(this), imag(that); thisi == thati {
			return 0
		} else if thisi < thati {
			return -1
		} else {
			return 1
		}
	} else if thisr < thatr {
		return -1
	} else {
		return 1
	}
}

// deriveCompareComplex64 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareComplex64(this, that complex128) int {
	if thisr, thatr := real(this), real(that); thisr == thatr {
		if thisi, thati := imag(this), imag(that); thisi == thati {
			return 0
		} else if thisi < thati {
			return -1
		} else {
			return 1
		}
	} else if thisr < thatr {
		return -1
	} else {
		return 1
	}
}

// deriveCompareCurryComplex64 returns a curried compare function, which returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareCurryComplex64(this complex128) func(complex128) int {
	return func(that complex128) int {
		if thisr, thatr := real(this), real(that); thisr == thatr {
			if thisi, thati := imag(this), imag(that); thisi == thati {
				return 0
			} else if thisi < thati {
				return -1
			} else {
				return 1
			}
		} else if thisr < thatr {
			return -1
		} else {
			return 1
		}
	}
}

// deriveCompareStringAlias returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareStringAlias(this, that stringAlias) int {
	return strings.Compare(string(this), string(that))
}

// deriveCompareStructWithStringAlias returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareStructWithStringAlias(this, that StructWithStringAlias) int {
	return deriveCompare_138(&this, &that)
}

// deriveCompareDeriveTheDerived returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompareDeriveTheDerived(this, that *DeriveTheDerived) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_i(this.Field, that.Field); c != 0 {
		return c
	}
	return 0
}

// deriveUniqueInt64s returns a list containing only the unique items from the input list.
// It does this by reusing the input list.
//
// Deprecated: In favour of generics.
func deriveUniqueInt64s(list []int64) []int64 {
	if len(list) == 0 {
		return nil
	}
	return deriveKeysForInt64s(deriveSetInt64s(list))
}

// deriveUniqueStructs returns a list containing only the unique items from the input list.
// It does this by reusing the input list.
//
// Deprecated: In favour of generics.
func deriveUniqueStructs(list []*BuiltInTypes) []*BuiltInTypes {
	if len(list) == 0 {
		return nil
	}
	table := make(map[uint64][]int)
	u := 0
	for i := 0; i < len(list); i++ {
		contains := false
		hash := deriveHashBuiltInTypes(list[i])
		indexes := table[hash]
		for _, index := range indexes {
			if deriveEqualPtrToBuiltInTypes(list[index], list[i]) {
				contains = true
				break
			}
		}
		if contains {
			continue
		}
		if i != u {
			list[u] = list[i]
		}
		table[hash] = append(table[hash], u)
		u++
	}
	return list[:u]
}

// deriveUniqueStructsPtrs returns a list containing only the unique items from the input list.
// It does this by reusing the input list.
//
// Deprecated: In favour of generics.
func deriveUniqueStructsPtrs(list []PtrToBuiltInTypes) []PtrToBuiltInTypes {
	if len(list) == 0 {
		return nil
	}
	table := make(map[uint64][]int)
	u := 0
	for i := 0; i < len(list); i++ {
		contains := false
		hash := deriveHash(list[i])
		indexes := table[hash]
		for _, index := range indexes {
			if deriveEqual(list[index], list[i]) {
				contains = true
				break
			}
		}
		if contains {
			continue
		}
		if i != u {
			list[u] = list[i]
		}
		table[hash] = append(table[hash], u)
		u++
	}
	return list[:u]
}

// deriveFilter returns a list of all items in the list that matches the predicate.
//
// Deprecated: In favour of generics.
func deriveFilter(predicate func(int) bool, list []int) []int {
	j := 0
	for i, elem := range list {
		if predicate(elem) {
			if i != j {
				list[j] = list[i]
			}
			j++
		}
	}
	return list[:j]
}

// deriveFilterJudy returns a list of all items in the list that matches the predicate.
//
// Deprecated: In favour of generics.
func deriveFilterJudy(predicate func(string) bool, list []string) []string {
	j := 0
	for i, elem := range list {
		if predicate(elem) {
			if i != j {
				list[j] = list[i]
			}
			j++
		}
	}
	return list[:j]
}

// deriveUnionSetOfInt64s returns the union of two maps, with respect to the keys.
// It does this by adding the keys to the first map.
//
// Deprecated: In favour of generics.
func deriveUnionSetOfInt64s(union, that map[int64]struct{}) map[int64]struct{} {
	for k := range that {
		union[k] = struct{}{}
	}
	return union
}

// deriveUnionOfInt64s returns the union of the items of the two input lists.
// It does this by append items to the first list.
//
// Deprecated: In favour of generics.
func deriveUnionOfInt64s(this, that []int64) []int64 {
	for i, v := range that {
		if !deriveContainsInt64s(this, v) {
			this = append(this, that[i])
		}
	}
	return this
}

// deriveTuple1 returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple1(v0 int) func() int {
	return func() int {
		return v0
	}
}

// deriveTuple2 returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple2(v0 int, v1 string) func() (int, string) {
	return func() (int, string) {
		return v0, v1
	}
}

// deriveTuple3 returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple3(v0 int, v1 string, v2 *BuiltInTypes) func() (int, string, *BuiltInTypes) {
	return func() (int, string, *BuiltInTypes) {
		return v0, v1, v2
	}
}

// deriveTupleError returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTupleError(v0 []byte, v1 error) func() ([]byte, error) {
	return func() ([]byte, error) {
		return v0, v1
	}
}

// deriveEqualPtrToEmpty returns whether this and that are equal.
func deriveEqualPtrToEmpty(this, that *Empty) bool {
	return (this == nil && that == nil) || (this != nil) && (that != nil)
}

// deriveEqualPtrToBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToBuiltInTypes(this, that *BuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Bool == that.Bool &&
			this.Byte == that.Byte &&
			this.Complex128 == that.Complex128 &&
			this.Complex64 == that.Complex64 &&
			this.Float64 == that.Float64 &&
			this.Float32 == that.Float32 &&
			this.Int == that.Int &&
			this.Int16 == that.Int16 &&
			this.Int32 == that.Int32 &&
			this.Int64 == that.Int64 &&
			this.Int8 == that.Int8 &&
			this.Rune == that.Rune &&
			this.String == that.String &&
			this.Uint == that.Uint &&
			this.Uint16 == that.Uint16 &&
			this.Uint32 == that.Uint32 &&
			this.Uint64 == that.Uint64 &&
			this.Uint8 == that.Uint8 &&
			this.UintPtr == that.UintPtr
}

// deriveEqualPtrToPrivateBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToPrivateBuiltInTypes(this, that *PrivateBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.privateBool == that.privateBool &&
			this.privateByte == that.privateByte &&
			this.privateComplex128 == that.privateComplex128 &&
			this.privateComplex64 == that.privateComplex64 &&
			this.privateFloat64 == that.privateFloat64 &&
			this.privateFloat32 == that.privateFloat32 &&
			this.privateInt == that.privateInt &&
			this.privateInt16 == that.privateInt16 &&
			this.privateInt32 == that.privateInt32 &&
			this.privateInt64 == that.privateInt64 &&
			this.privateInt8 == that.privateInt8 &&
			this.privateRune == that.privateRune &&
			this.privateString == that.privateString &&
			this.privateUint == that.privateUint &&
			this.privateUint16 == that.privateUint16 &&
			this.privateUint32 == that.privateUint32 &&
			this.privateUint64 == that.privateUint64 &&
			this.privateUint8 == that.privateUint8 &&
			this.privateUintPtr == that.privateUintPtr
}

// deriveEqualPtrToPtrToBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToPtrToBuiltInTypes(this, that *PtrToBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			((this.Bool == nil && that.Bool == nil) || (this.Bool != nil && that.Bool != nil && *(this.Bool) == *(that.Bool))) &&
			((this.Byte == nil && that.Byte == nil) || (this.Byte != nil && that.Byte != nil && *(this.Byte) == *(that.Byte))) &&
			((this.Complex128 == nil && that.Complex128 == nil) || (this.Complex128 != nil && that.Complex128 != nil && *(this.Complex128) == *(that.Complex128))) &&
			((this.Complex64 == nil && that.Complex64 == nil) || (this.Complex64 != nil && that.Complex64 != nil && *(this.Complex64) == *(that.Complex64))) &&
			((this.Float64 == nil && that.Float64 == nil) || (this.Float64 != nil && that.Float64 != nil && *(this.Float64) == *(that.Float64))) &&
			((this.Float32 == nil && that.Float32 == nil) || (this.Float32 != nil && that.Float32 != nil && *(this.Float32) == *(that.Float32))) &&
			((this.Int == nil && that.Int == nil) || (this.Int != nil && that.Int != nil && *(this.Int) == *(that.Int))) &&
			((this.Int16 == nil && that.Int16 == nil) || (this.Int16 != nil && that.Int16 != nil && *(this.Int16) == *(that.Int16))) &&
			((this.Int32 == nil && that.Int32 == nil) || (this.Int32 != nil && that.Int32 != nil && *(this.Int32) == *(that.Int32))) &&
			((this.Int64 == nil && that.Int64 == nil) || (this.Int64 != nil && that.Int64 != nil && *(this.Int64) == *(that.Int64))) &&
			((this.Int8 == nil && that.Int8 == nil) || (this.Int8 != nil && that.Int8 != nil && *(this.Int8) == *(that.Int8))) &&
			((this.Rune == nil && that.Rune == nil) || (this.Rune != nil && that.Rune != nil && *(this.Rune) == *(that.Rune))) &&
			((this.String == nil && that.String == nil) || (this.String != nil && that.String != nil && *(this.String) == *(that.String))) &&
			((this.Uint == nil && that.Uint == nil) || (this.Uint != nil && that.Uint != nil && *(this.Uint) == *(that.Uint))) &&
			((this.Uint16 == nil && that.Uint16 == nil) || (this.Uint16 != nil && that.Uint16 != nil && *(this.Uint16) == *(that.Uint16))) &&
			((this.Uint32 == nil && that.Uint32 == nil) || (this.Uint32 != nil && that.Uint32 != nil && *(this.Uint32) == *(that.Uint32))) &&
			((this.Uint64 == nil && that.Uint64 == nil) || (this.Uint64 != nil && that.Uint64 != nil && *(this.Uint64) == *(that.Uint64))) &&
			((this.Uint8 == nil && that.Uint8 == nil) || (this.Uint8 != nil && that.Uint8 != nil && *(this.Uint8) == *(that.Uint8))) &&
			((this.UintPtr == nil && that.UintPtr == nil) || (this.UintPtr != nil && that.UintPtr != nil && *(this.UintPtr) == *(that.UintPtr)))
}

// deriveEqualPtrToSliceOfBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToSliceOfBuiltInTypes(this, that *SliceOfBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_(this.Bool, that.Bool) &&
			bytes.Equal(this.Byte, that.Byte) &&
			deriveEqual_1(this.Complex128, that.Complex128) &&
			deriveEqual_2(this.Complex64, that.Complex64) &&
			deriveEqual_3(this.Float64, that.Float64) &&
			deriveEqual_4(this.Float32, that.Float32) &&
			deriveEqualSliceOfint(this.Int, that.Int) &&
			deriveEqual_5(this.Int16, that.Int16) &&
			deriveEqual_6(this.Int32, that.Int32) &&
			deriveEqual_7(this.Int64, that.Int64) &&
			deriveEqual_8(this.Int8, that.Int8) &&
			deriveEqual_6(this.Rune, that.Rune) &&
			deriveEqual_9(this.String, that.String) &&
			deriveEqual_10(this.Uint, that.Uint) &&
			deriveEqual_11(this.Uint16, that.Uint16) &&
			deriveEqual_12(this.Uint32, that.Uint32) &&
			deriveEqual_13(this.Uint64, that.Uint64) &&
			bytes.Equal(this.Uint8, that.Uint8) &&
			deriveEqual_14(this.UintPtr, that.UintPtr)
}

// deriveEqualPtrToSliceOfPtrToBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToSliceOfPtrToBuiltInTypes(this, that *SliceOfPtrToBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_15(this.Bool, that.Bool) &&
			deriveEqual_16(this.Byte, that.Byte) &&
			deriveEqual_17(this.Complex128, that.Complex128) &&
			deriveEqual_18(this.Complex64, that.Complex64) &&
			deriveEqual_19(this.Float64, that.Float64) &&
			deriveEqual_20(this.Float32, that.Float32) &&
			deriveEqual_21(this.Int, that.Int) &&
			deriveEqual_22(this.Int16, that.Int16) &&
			deriveEqual_23(this.Int32, that.Int32) &&
			deriveEqual_24(this.Int64, that.Int64) &&
			deriveEqual_25(this.Int8, that.Int8) &&
			deriveEqual_23(this.Rune, that.Rune) &&
			deriveEqual_26(this.String, that.String) &&
			deriveEqual_27(this.Uint, that.Uint) &&
			deriveEqual_28(this.Uint16, that.Uint16) &&
			deriveEqual_29(this.Uint32, that.Uint32) &&
			deriveEqual_30(this.Uint64, that.Uint64) &&
			deriveEqual_16(this.Uint8, that.Uint8) &&
			deriveEqual_31(this.UintPtr, that.UintPtr)
}

// deriveEqualPtrToArrayOfBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToArrayOfBuiltInTypes(this, that *ArrayOfBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Bool == that.Bool &&
			this.Byte == that.Byte &&
			this.Complex128 == that.Complex128 &&
			this.Complex64 == that.Complex64 &&
			this.Float64 == that.Float64 &&
			this.Float32 == that.Float32 &&
			this.Int == that.Int &&
			this.Int16 == that.Int16 &&
			this.Int32 == that.Int32 &&
			this.Int64 == that.Int64 &&
			this.Int8 == that.Int8 &&
			this.Rune == that.Rune &&
			this.String == that.String &&
			this.Uint == that.Uint &&
			this.Uint16 == that.Uint16 &&
			this.Uint32 == that.Uint32 &&
			this.Uint64 == that.Uint64 &&
			this.Uint8 == that.Uint8 &&
			this.UintPtr == that.UintPtr &&
			this.AnotherBoolOfDifferentSize == that.AnotherBoolOfDifferentSize
}

// deriveEqualPtrToArrayOfPtrToBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToArrayOfPtrToBuiltInTypes(this, that *ArrayOfPtrToBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_32(this.Bool, that.Bool) &&
			deriveEqual_33(this.Byte, that.Byte) &&
			deriveEqual_34(this.Complex128, that.Complex128) &&
			deriveEqual_35(this.Complex64, that.Complex64) &&
			deriveEqual_36(this.Float64, that.Float64) &&
			deriveEqual_37(this.Float32, that.Float32) &&
			deriveEqual_38(this.Int, that.Int) &&
			deriveEqual_39(this.Int16, that.Int16) &&
			deriveEqual_40(this.Int32, that.Int32) &&
			deriveEqual_41(this.Int64, that.Int64) &&
			deriveEqual_42(this.Int8, that.Int8) &&
			deriveEqual_43(this.Rune, that.Rune) &&
			deriveEqual_44(this.String, that.String) &&
			deriveEqual_45(this.Uint, that.Uint) &&
			deriveEqual_46(this.Uint16, that.Uint16) &&
			deriveEqual_47(this.Uint32, that.Uint32) &&
			deriveEqual_48(this.Uint64, that.Uint64) &&
			deriveEqual_49(this.Uint8, that.Uint8) &&
			deriveEqual_50(this.UintPtr, that.UintPtr) &&
			deriveEqual_51(this.AnotherBoolOfDifferentSize, that.AnotherBoolOfDifferentSize)
}

// deriveEqualPtrToMapsOfSimplerBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToMapsOfSimplerBuiltInTypes(this, that *MapsOfSimplerBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_52(this.StringToUint32, that.StringToUint32) &&
			deriveEqual_53(this.Uint64ToInt64, that.Uint64ToInt64)
}

// deriveEqualPtrToMapsOfBuiltInTypes returns whether this and that are equal.
func deriveEqualPtrToMapsOfBuiltInTypes(this, that *MapsOfBuiltInTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_54(this.BoolToString, that.BoolToString) &&
			deriveEqual_55(this.StringToBool, that.StringToBool) &&
			deriveEqual_56(this.Complex128ToComplex64, that.Complex128ToComplex64) &&
			deriveEqual_57(this.Float64ToUint32, that.Float64ToUint32) &&
			deriveEqual_58(this.Uint16ToUint8, that.Uint16ToUint8)
}

// deriveEqualPtrToSliceToSlice returns whether this and that are equal.
func deriveEqualPtrToSliceToSlice(this, that *SliceToSlice) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_59(this.Ints, that.Ints) &&
			deriveEqual_60(this.Strings, that.Strings) &&
			deriveEqual_61(this.IntPtrs, that.IntPtrs)
}

// deriveEqualPtrToPtrTo returns whether this and that are equal.
func deriveEqualPtrToPtrTo(this, that *PtrTo) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			((this.Basic == nil && that.Basic == nil) || (this.Basic != nil && that.Basic != nil && *(this.Basic) == *(that.Basic))) &&
			((this.Slice == nil && that.Slice == nil) || (this.Slice != nil && that.Slice != nil && deriveEqualSliceOfint(*(this.Slice), *(that.Slice)))) &&
			((this.Array == nil && that.Array == nil) || (this.Array != nil && that.Array != nil && *(this.Array) == *(that.Array))) &&
			((this.Map == nil && that.Map == nil) || (this.Map != nil && that.Map != nil && deriveEqualMapOfintToint(*(this.Map), *(that.Map))))
}

// deriveEqualPtrToName returns whether this and that are equal.
func deriveEqualPtrToName(this, that *Name) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Name == that.Name
}

// deriveEqualPtrToStructs returns whether this and that are equal.
func deriveEqualPtrToStructs(this, that *Structs) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Struct.Equal(&that.Struct) &&
			this.PtrToStruct.Equal(that.PtrToStruct) &&
			deriveEqual_62(this.SliceOfStructs, that.SliceOfStructs) &&
			deriveEqual_63(this.SliceToPtrOfStruct, that.SliceToPtrOfStruct) &&
			this.StructWithoutMethod == that.StructWithoutMethod &&
			deriveEqual_64(this.PtrToStructWithoutMethod, that.PtrToStructWithoutMethod) &&
			deriveEqual_65(this.SliceOfStructWithoutMethod, that.SliceOfStructWithoutMethod) &&
			deriveEqual_66(this.SliceToPtrOfStructWithoutMethod, that.SliceToPtrOfStructWithoutMethod)
}

// deriveEqualPtrToMapWithStructs returns whether this and that are equal.
func deriveEqualPtrToMapWithStructs(this, that *MapWithStructs) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_67(this.NameToString, that.NameToString) &&
			deriveEqual_68(this.StringToName, that.StringToName) &&
			deriveEqual_69(this.StringToPtrToName, that.StringToPtrToName) &&
			deriveEqual_70(this.StringToSliceOfName, that.StringToSliceOfName) &&
			deriveEqual_71(this.StringToSliceOfPtrToName, that.StringToSliceOfPtrToName) &&
			deriveEqual_72(this.StringToStructWithoutMethod, that.StringToStructWithoutMethod) &&
			deriveEqual_73(this.StructWithoutMethodToString, that.StructWithoutMethodToString) &&
			deriveEqual_74(this.StringToPtrToStructWithoutMethod, that.StringToPtrToStructWithoutMethod) &&
			deriveEqual_75(this.StringToSliceOfStructWithoutMethod, that.StringToSliceOfStructWithoutMethod) &&
			deriveEqual_76(this.StringToSliceOfPtrToStructWithoutMethod, that.StringToSliceOfPtrToStructWithoutMethod)
}

// deriveEqualPtrToRecursiveType returns whether this and that are equal.
func deriveEqualPtrToRecursiveType(this, that *RecursiveType) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			bytes.Equal(this.Bytes, that.Bytes) &&
			deriveEqual_77(this.N, that.N)
}

// deriveEqualPtrToEmbeddedStruct1 returns whether this and that are equal.
func deriveEqualPtrToEmbeddedStruct1(this, that *EmbeddedStruct1) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Name.Equal(&that.Name) &&
			this.StructWithoutMethod == that.StructWithoutMethod &&
			this.Structs.Equal(that.Structs)
}

// deriveEqualPtrToEmbeddedStruct2 returns whether this and that are equal.
func deriveEqualPtrToEmbeddedStruct2(this, that *EmbeddedStruct2) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Structs.Equal(&that.Structs) &&
			this.Name.Equal(that.Name) &&
			deriveEqual_64(this.StructWithoutMethod, that.StructWithoutMethod)
}

// deriveEqualPtrToUnnamedStruct returns whether this and that are equal.
func deriveEqualPtrToUnnamedStruct(this, that *UnnamedStruct) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Unnamed == that.Unnamed
}

// deriveEqualPtrToStructWithStructFieldWithoutEqualMethod returns whether this and that are equal.
func deriveEqualPtrToStructWithStructFieldWithoutEqualMethod(this, that *StructWithStructFieldWithoutEqualMethod) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_78(this.A, that.A) &&
			this.B == that.B
}

// deriveEqualPtrToStructWithStructWithFromAnotherPackage returns whether this and that are equal.
func deriveEqualPtrToStructWithStructWithFromAnotherPackage(this, that *StructWithStructWithFromAnotherPackage) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_79(this.A, that.A) &&
			this.B == that.B
}

// deriveEqualPtrToFieldWithStructWithPrivateFields returns whether this and that are equal.
func deriveEqualPtrToFieldWithStructWithPrivateFields(this, that *FieldWithStructWithPrivateFields) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_80(this.A, that.A)
}

// deriveEqualPtrToEnums returns whether this and that are equal.
func deriveEqualPtrToEnums(this, that *Enums) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Enum == that.Enum &&
			deriveEqual_81(this.PtrToEnum, that.PtrToEnum) &&
			deriveEqual_82(this.SliceToEnum, that.SliceToEnum) &&
			deriveEqual_83(this.SliceToPtrToEnum, that.SliceToPtrToEnum) &&
			deriveEqual_84(this.MapToEnum, that.MapToEnum) &&
			deriveEqual_85(this.EnumToMap, that.EnumToMap) &&
			this.ArrayEnum == that.ArrayEnum
}

// deriveEqualPtrToNamedTypes returns whether this and that are equal.
func deriveEqualPtrToNamedTypes(this, that *NamedTypes) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_7(this.Slice, that.Slice) &&
			deriveEqual_86(this.PtrToSlice, that.PtrToSlice) &&
			deriveEqual_87(this.SliceToSlice, that.SliceToSlice)
}

// deriveEqualPtrToTime returns whether this and that are equal.
func deriveEqualPtrToTime(this, that *Time) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.T.Equal(that.T) &&
			((this.P == nil && that.P == nil) || (this.P != nil && that.P != nil && (*(this.P)).Equal(*(that.P))))
}

// deriveEqualPtrToDuration returns whether this and that are equal.
func deriveEqualPtrToDuration(this, that *Duration) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.D == that.D &&
			deriveEqual_88(this.P, that.P) &&
			deriveEqual_89(this.Ds, that.Ds) &&
			deriveEqual_90(this.DPs, that.DPs) &&
			deriveEqual_91(this.MD, that.MD)
}

// deriveEqualPtrToNickname returns whether this and that are equal.
func deriveEqualPtrToNickname(this, that *Nickname) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_92(this.Alias, that.Alias)
}

// deriveEqualPtrToPrivateEmbedded returns whether this and that are equal.
func deriveEqualPtrToPrivateEmbedded(this, that *PrivateEmbedded) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			deriveEqual_93(&this.privateStruct, &that.privateStruct)
}

// deriveEqualInefficientDeriveTheDerived returns whether this and that are equal.
func deriveEqualInefficientDeriveTheDerived(this, that int) bool {
	return this == that
}

// deriveEqualSliceOfint returns whether this and that are equal.
func deriveEqualSliceOfint(this, that []int) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqualMapOfintToint returns whether this and that are equal.
func deriveEqualMapOfintToint(this, that map[int]int) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqualPtrToint returns whether this and that are equal.
func deriveEqualPtrToint(this, that *int) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		return *this == *that
	}
	return false
}

// deriveEqualPtrToSliceOfint returns whether this and that are equal.
func deriveEqualPtrToSliceOfint(this, that *[]int) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		if *this == nil || *that == nil {
			return *this == nil && *that == nil
		}
		if len(*this) != len(*that) {
			return false
		}
		for i := 0; i < len(*this); i++ {
			if !((*this)[i] == (*that)[i]) {
				return false
			}
		}
		return true
	}
	return false
}

// deriveEqualPtrToArray10Ofint returns whether this and that are equal.
func deriveEqualPtrToArray10Ofint(this, that *[10]int) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		for i := 0; i < len(*this); i++ {
			if !((*this)[i] == (*that)[i]) {
				return false
			}
		}
		return true
	}
	return false
}

// deriveEqualPtrToMapOfintToint returns whether this and that are equal.
func deriveEqualPtrToMapOfintToint(this, that *map[int]int) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		if *this == nil || *that == nil {
			return *this == nil && *that == nil
		}
		if len(*this) != len(*that) {
			return false
		}
		for k, v := range *this {
			thatv, ok := (*that)[k]
			if !ok {
				return false
			}
			if !(v == thatv) {
				return false
			}
		}
		return true
	}
	return false
}

// deriveEqual1 returns whether this and that are equal.
func deriveEqual1(this, that BuiltInTypes) bool {
	return (&this).Equal(&that)
}

// deriveEqualCurry returns an equal closure, with the first parameter already filled in.
func deriveEqualCurry(this *BuiltInTypes) func(*BuiltInTypes) bool {
	return func(that *BuiltInTypes) bool {
		return (this == nil && that == nil) ||
			this != nil && that != nil &&
				this.Bool == that.Bool &&
				this.Byte == that.Byte &&
				this.Complex128 == that.Complex128 &&
				this.Complex64 == that.Complex64 &&
				this.Float64 == that.Float64 &&
				this.Float32 == that.Float32 &&
				this.Int == that.Int &&
				this.Int16 == that.Int16 &&
				this.Int32 == that.Int32 &&
				this.Int64 == that.Int64 &&
				this.Int8 == that.Int8 &&
				this.Rune == that.Rune &&
				this.String == that.String &&
				this.Uint == that.Uint &&
				this.Uint16 == that.Uint16 &&
				this.Uint32 == that.Uint32 &&
				this.Uint64 == that.Uint64 &&
				this.Uint8 == that.Uint8 &&
				this.UintPtr == that.UintPtr
	}
}

// deriveEqualMapTypes returns whether this and that are equal.
func deriveEqualMapTypes(this, that *SomeJson) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Name == that.Name &&
			this.Other.Equal(that.Other)
}

// deriveEqualVisitor returns whether this and that are equal.
func deriveEqualVisitor(this, that Visitor) bool {
	return deriveEqual_94(&this, &that)
}

// deriveEqual returns whether this and that are equal.
func deriveEqual(this, that PtrToBuiltInTypes) bool {
	return (&this).Equal(&that)
}

// deriveCurryMarshal returns a function that has one parameter, which corresponds to the input functions first parameter, and a result that is a function, which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveCurryMarshal(f func(data []byte, v any) error) func(data []byte) func(v any) error {
	return func(data []byte) func(v any) error {
		return func(v any) error {
			return f(data, v)
		}
	}
}

// deriveCurry3 returns a function that has one parameter, which corresponds to the input functions first parameter, and a result that is a function, which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveCurry3(f func(a int, b string, c bool) string) func(a int) func(b string, c bool) string {
	return func(a int) func(b string, c bool) string {
		return func(b string, c bool) string {
			return f(a, b, c)
		}
	}
}

// deriveCurryCurried returns a function that has one parameter, which corresponds to the input functions first parameter, and a result that is a function, which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveCurryCurried(f func(b string, c bool) string) func(b string) func(c bool) string {
	return func(b string) func(c bool) string {
		return func(c bool) string {
			return f(b, c)
		}
	}
}

// deriveCurryBlackIdentifier returns a function that has one parameter, which corresponds to the input functions first parameter, and a result that is a function, which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveCurryBlackIdentifier(f func(param_0 string, param_1 bool, param_2 int) string) func(param_0 string) func(param_1 bool, param_2 int) string {
	return func(param_0 string) func(param_1 bool, param_2 int) string {
		return func(param_1 bool, param_2 int) string {
			return f(param_0, param_1, param_2)
		}
	}
}

// deriveCloneEmpty returns a clone of the src parameter.
func deriveCloneEmpty(src *Empty) *Empty {
	if src == nil {
		return nil
	}
	dst := new(Empty)
	deriveDeepCopyPtrToEmpty(dst, src)
	return dst
}

// deriveCloneBuiltInTypes returns a clone of the src parameter.
func deriveCloneBuiltInTypes(src *BuiltInTypes) *BuiltInTypes {
	if src == nil {
		return nil
	}
	dst := new(BuiltInTypes)
	deriveDeepCopyPtrToBuiltInTypes(dst, src)
	return dst
}

// deriveClonePtrToBuiltInTypes returns a clone of the src parameter.
func deriveClonePtrToBuiltInTypes(src *PtrToBuiltInTypes) *PtrToBuiltInTypes {
	if src == nil {
		return nil
	}
	dst := new(PtrToBuiltInTypes)
	deriveDeepCopyPtrToPtrToBuiltInTypes(dst, src)
	return dst
}

// deriveCloneSliceOfint returns a clone of the src parameter.
func deriveCloneSliceOfint(src []int) []int {
	if src == nil {
		return nil
	}
	dst := make([]int, len(src))
	deriveDeepCopy_51(dst, src)
	return dst
}

// deriveCloneMapOfintToint returns a clone of the src parameter.
func deriveCloneMapOfintToint(src map[int]int) map[int]int {
	if src == nil {
		return nil
	}
	dst := make(map[int]int)
	deriveDeepCopy_52(dst, src)
	return dst
}

// deriveClonePtrToint returns a clone of the src parameter.
func deriveClonePtrToint(src *int) *int {
	if src == nil {
		return nil
	}
	dst := new(int)
	deriveDeepCopy_53(dst, src)
	return dst
}

// deriveClonePtrToSliceOfint returns a clone of the src parameter.
func deriveClonePtrToSliceOfint(src *[]int) *[]int {
	if src == nil {
		return nil
	}
	dst := new([]int)
	deriveDeepCopy_26(dst, src)
	return dst
}

// deriveClonePtrToArray10Ofint returns a clone of the src parameter.
func deriveClonePtrToArray10Ofint(src *[10]int) *[10]int {
	if src == nil {
		return nil
	}
	dst := new([10]int)
	deriveDeepCopy_54(dst, src)
	return dst
}

// deriveClonePtrToMapOfintToint returns a clone of the src parameter.
func deriveClonePtrToMapOfintToint(src *map[int]int) *map[int]int {
	if src == nil {
		return nil
	}
	dst := new(map[int]int)
	deriveDeepCopy_27(dst, src)
	return dst
}

// deriveClone1 returns a clone of the src parameter.
func deriveClone1(src BuiltInTypes) BuiltInTypes {
	dst := new(BuiltInTypes)
	deriveDeepCopyPtrToBuiltInTypes(dst, &src)
	return *dst
}

// deriveApplyMarshal applies the second argument to a given function's last argument and returns a function which which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveApplyMarshal(f func(v any) ([]byte, error), v any) func() ([]byte, error) {
	return func() ([]byte, error) {
		return f(v)
	}
}

// deriveApplyMultiple applies the second argument to a given function's last argument and returns a function which which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveApplyMultiple(f func(a int, b string, c bool) string, c bool) func(a int, b string) string {
	return func(a int, b string) string {
		return f(a, b, c)
	}
}

// deriveApply3 applies the second argument to a given function's last argument and returns a function which which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveApply3(f func(a string, b int, c bool) string, c bool) func(a string, b int) string {
	return func(a string, b int) string {
		return f(a, b, c)
	}
}

// deriveApplyApplied applies the second argument to a given function's last argument and returns a function which which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveApplyApplied(f func(a string, b int) string, b int) func(a string) string {
	return func(a string) string {
		return f(a, b)
	}
}

// deriveApplyBlankIdentifier applies the second argument to a given function's last argument and returns a function which which takes the rest of the parameters as input and finally returns the original input function's results.
func deriveApplyBlankIdentifier(f func(a string, param_1 bool, c int) string, c int) func(a string, param_1 bool) string {
	return func(a string, param_1 bool) string {
		return f(a, param_1, c)
	}
}

// deriveSortedInts sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedInts(list []int) []int {
	sort.Ints(list)
	return list
}

// deriveSortInt64s sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortInt64s(list []int64) []int64 {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSortStructs sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortStructs(list []*BuiltInTypes) []*BuiltInTypes {
	sort.Slice(list, func(i, j int) bool { return deriveComparePtrToBuiltInTypes(list[i], list[j]) < 0 })
	return list
}

// deriveSortedSliceIntAlias sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedSliceIntAlias(list []intAlias) []intAlias {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSortedSliceStringAlias sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedSliceStringAlias(list []stringAlias) []stringAlias {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSortedSliceFloat64Alias sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedSliceFloat64Alias(list []float64Alias) []float64Alias {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSortedStrings sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedStrings(list []string) []string {
	sort.Strings(list)
	return list
}

// deriveSortedStringKeyAlias sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSortedStringKeyAlias(list []stringKeyAlias) []stringKeyAlias {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveKeysForInt64s returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForInt64s(m map[int64]struct{}) []int64 {
	keys := make([]int64, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForFmap returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForFmap(m map[int]string) []int {
	keys := make([]int, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForMapStringToString returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForMapStringToString(m map[string]string) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForMapStringAliasToString returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForMapStringAliasToString(m map[stringKeyAlias]string) []stringKeyAlias {
	keys := make([]stringKeyAlias, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForMapStringToStringAlias returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForMapStringToStringAlias(m map[string]stringAlias) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForMapIntToInt64 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForMapIntToInt64(m map[int]int64) []int {
	keys := make([]int, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeysForMapInt64ToInt64 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeysForMapInt64ToInt64(m map[int64]int64) []int64 {
	keys := make([]int64, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveJoinSS concatenates the list of lists into one list.
func deriveJoinSS(listOfLists [][]string) []string {
	if listOfLists == nil {
		return nil
	}
	l := 0
	for _, elem := range listOfLists {
		l += len(elem)
	}
	res := make([]string, 0, l)
	for _, elem := range listOfLists {
		res = append(res, elem...)
	}
	return res
}

// deriveJoinEE returns the error or calls f and returns it's value and error.
func deriveJoinEE(f func() (int64, error), err error) (int64, error) {
	if err != nil {
		return 0, err
	}
	return f()
}

// deriveJoinChannels listens on all channels resulting from the input channel and sends all their results on the output channel.
func deriveJoinChannels(in <-chan (<-chan int)) <-chan int {
	out := make(chan int)
	go func() {
		wait := sync.WaitGroup{}
		for c := range in {
			wait.Add(1)
			res := c
			go func() {
				for r := range res {
					out <- r
				}
				wait.Done()
			}()
		}
		wait.Wait()
		close(out)
	}()
	return out
}

// deriveJoin concatenates the list of lists into one list.
func deriveJoin(listOfLists [][]int) []int {
	if listOfLists == nil {
		return nil
	}
	l := 0
	for _, elem := range listOfLists {
		l += len(elem)
	}
	res := make([]int, 0, l)
	for _, elem := range listOfLists {
		res = append(res, elem...)
	}
	return res
}

// deriveJoinString concatenates the list of strings into one string.
func deriveJoinString(list []string) string {
	return strings.Join(list, "")
}

// deriveJoinJustError returns the error or calls f and returns it's error.
func deriveJoinJustError(f func() error, err error) error {
	if err != nil {
		return err
	}
	return f()
}

// deriveJoinErrorAndString returns the error or calls f and returns it's value and error.
func deriveJoinErrorAndString(f func() (string, error), err error) (string, error) {
	if err != nil {
		return "", err
	}
	return f()
}

// deriveJoinErrorAndValues returns the error or calls f and returns it's value and error.
func deriveJoinErrorAndValues(f func() (string, int, error), err error) (string, int, error) {
	if err != nil {
		return "", 0, err
	}
	return f()
}

// deriveJoinSendRecvChannels listens on all channels resulting from the input channel and sends all their results on the output channel.
func deriveJoinSendRecvChannels(in chan (<-chan int64)) <-chan int64 {
	out := make(chan int64)
	go func() {
		wait := sync.WaitGroup{}
		for c := range in {
			wait.Add(1)
			res := c
			go func() {
				for r := range res {
					out <- r
				}
				wait.Done()
			}()
		}
		wait.Wait()
		close(out)
	}()
	return out
}

// deriveJoinSliceOfRecvChannels listens on all input channels and sends all their results onto the single output channel.
func deriveJoinSliceOfRecvChannels(in []<-chan int) <-chan int {
	out := make(chan int)
	go func() {
		wait := sync.WaitGroup{}
		for _, c := range in {
			wait.Add(1)
			res := c
			go func() {
				for r := range res {
					out <- r
				}
				wait.Done()
			}()
		}
		wait.Wait()
		close(out)
	}()
	return out
}

// deriveJoinSliceOfSendRecvChannels listens on all input channels and sends all their results onto the single output channel.
func deriveJoinSliceOfSendRecvChannels(in []chan int) <-chan int {
	out := make(chan int)
	go func() {
		wait := sync.WaitGroup{}
		for _, c := range in {
			wait.Add(1)
			res := c
			go func() {
				for r := range res {
					out <- r
				}
				wait.Done()
			}()
		}
		wait.Wait()
		close(out)
	}()
	return out
}

// deriveJoinVariantOfSendRecvChannels listens on all input channels c0 and c1, and sends all their results onto the single output channel.
func deriveJoinVariantOfSendRecvChannels(c0 chan int, c1 chan int) <-chan int {
	out := make(chan int)
	go func() {
		for c0 != nil || c1 != nil {
			select {
			case v0, ok0 := <-c0:
				if !ok0 {
					c0 = nil
				} else {
					out <- v0
				}
			case v1, ok1 := <-c1:
				if !ok1 {
					c1 = nil
				} else {
					out <- v1
				}
			}
		}
		close(out)
	}()
	return out
}

// deriveHashEmpty returns the hash of the object.
func deriveHashEmpty(object *Empty) uint64 {
	if object == nil {
		return 0
	}
	return 17
}

// deriveHashBuiltInTypes returns the hash of the object.
func deriveHashBuiltInTypes(object *BuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_(object.Bool)
	h = 31*h + uint64(object.Byte)
	h = 31*h + (31 * ((31 * 17) + math.Float64bits(real(object.Complex128)))) + math.Float64bits(imag(object.Complex128))
	h = 31*h + (31 * ((31 * 17) + uint64(math.Float32bits(real(object.Complex64))))) + uint64(math.Float32bits(imag(object.Complex64)))
	h = 31*h + math.Float64bits(object.Float64)
	h = 31*h + uint64(math.Float32bits(object.Float32))
	h = 31*h + uint64(object.Int)
	h = 31*h + uint64(object.Int16)
	h = 31*h + uint64(object.Int32)
	h = 31*h + uint64(object.Int64)
	h = 31*h + uint64(object.Int8)
	h = 31*h + uint64(object.Rune)
	h = 31*h + deriveHash_s(object.String)
	h = 31*h + uint64(object.Uint)
	h = 31*h + uint64(object.Uint16)
	h = 31*h + uint64(object.Uint32)
	h = 31*h + object.Uint64
	h = 31*h + uint64(object.Uint8)
	h = 31*h + uint64(object.UintPtr)
	return h
}

// deriveHashPtrToPrivateBuiltInTypes returns the hash of the object.
func deriveHashPtrToPrivateBuiltInTypes(object *PrivateBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_(object.privateBool)
	h = 31*h + uint64(object.privateByte)
	h = 31*h + (31 * ((31 * 17) + math.Float64bits(real(object.privateComplex128)))) + math.Float64bits(imag(object.privateComplex128))
	h = 31*h + (31 * ((31 * 17) + uint64(math.Float32bits(real(object.privateComplex64))))) + uint64(math.Float32bits(imag(object.privateComplex64)))
	h = 31*h + math.Float64bits(object.privateFloat64)
	h = 31*h + uint64(math.Float32bits(object.privateFloat32))
	h = 31*h + uint64(object.privateInt)
	h = 31*h + uint64(object.privateInt16)
	h = 31*h + uint64(object.privateInt32)
	h = 31*h + uint64(object.privateInt64)
	h = 31*h + uint64(object.privateInt8)
	h = 31*h + uint64(object.privateRune)
	h = 31*h + deriveHash_s(object.privateString)
	h = 31*h + uint64(object.privateUint)
	h = 31*h + uint64(object.privateUint16)
	h = 31*h + uint64(object.privateUint32)
	h = 31*h + object.privateUint64
	h = 31*h + uint64(object.privateUint8)
	h = 31*h + uint64(object.privateUintPtr)
	return h
}

// deriveHashPtrToBuiltInTypes returns the hash of the object.
func deriveHashPtrToBuiltInTypes(object *PtrToBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_1(object.Bool)
	h = 31*h + deriveHash_2(object.Byte)
	h = 31*h + deriveHash_3(object.Complex128)
	h = 31*h + deriveHash_4(object.Complex64)
	h = 31*h + deriveHash_5(object.Float64)
	h = 31*h + deriveHash_6(object.Float32)
	h = 31*h + deriveHashPtrToint(object.Int)
	h = 31*h + deriveHash_7(object.Int16)
	h = 31*h + deriveHash_8(object.Int32)
	h = 31*h + deriveHash_9(object.Int64)
	h = 31*h + deriveHash_10(object.Int8)
	h = 31*h + deriveHash_8(object.Rune)
	h = 31*h + deriveHash_11(object.String)
	h = 31*h + deriveHash_12(object.Uint)
	h = 31*h + deriveHash_13(object.Uint16)
	h = 31*h + deriveHash_14(object.Uint32)
	h = 31*h + deriveHash_15(object.Uint64)
	h = 31*h + deriveHash_2(object.Uint8)
	h = 31*h + deriveHash_16(object.UintPtr)
	return h
}

// deriveHashSliceOfBuiltInTypes returns the hash of the object.
func deriveHashSliceOfBuiltInTypes(object *SliceOfBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_17(object.Bool)
	h = 31*h + deriveHash_18(object.Byte)
	h = 31*h + deriveHash_19(object.Complex128)
	h = 31*h + deriveHash_20(object.Complex64)
	h = 31*h + deriveHash_21(object.Float64)
	h = 31*h + deriveHash_22(object.Float32)
	h = 31*h + deriveHashSliceOfint(object.Int)
	h = 31*h + deriveHash_23(object.Int16)
	h = 31*h + deriveHash_24(object.Int32)
	h = 31*h + deriveHash_25(object.Int64)
	h = 31*h + deriveHash_26(object.Int8)
	h = 31*h + deriveHash_24(object.Rune)
	h = 31*h + deriveHash_27(object.String)
	h = 31*h + deriveHash_28(object.Uint)
	h = 31*h + deriveHash_29(object.Uint16)
	h = 31*h + deriveHash_30(object.Uint32)
	h = 31*h + deriveHash_31(object.Uint64)
	h = 31*h + deriveHash_18(object.Uint8)
	h = 31*h + deriveHash_32(object.UintPtr)
	return h
}

// deriveHashSliceOfPtrToBuiltInTypes returns the hash of the object.
func deriveHashSliceOfPtrToBuiltInTypes(object *SliceOfPtrToBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_33(object.Bool)
	h = 31*h + deriveHash_34(object.Byte)
	h = 31*h + deriveHash_35(object.Complex128)
	h = 31*h + deriveHash_36(object.Complex64)
	h = 31*h + deriveHash_37(object.Float64)
	h = 31*h + deriveHash_38(object.Float32)
	h = 31*h + deriveHash_39(object.Int)
	h = 31*h + deriveHash_40(object.Int16)
	h = 31*h + deriveHash_41(object.Int32)
	h = 31*h + deriveHash_42(object.Int64)
	h = 31*h + deriveHash_43(object.Int8)
	h = 31*h + deriveHash_41(object.Rune)
	h = 31*h + deriveHash_44(object.String)
	h = 31*h + deriveHash_45(object.Uint)
	h = 31*h + deriveHash_46(object.Uint16)
	h = 31*h + deriveHash_47(object.Uint32)
	h = 31*h + deriveHash_48(object.Uint64)
	h = 31*h + deriveHash_34(object.Uint8)
	h = 31*h + deriveHash_49(object.UintPtr)
	return h
}

// deriveHashArrayOfBuiltInTypes returns the hash of the object.
func deriveHashArrayOfBuiltInTypes(object *ArrayOfBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_50(object.Bool)
	h = 31*h + deriveHash_51(object.Byte)
	h = 31*h + deriveHash_52(object.Complex128)
	h = 31*h + deriveHash_53(object.Complex64)
	h = 31*h + deriveHash_54(object.Float64)
	h = 31*h + deriveHash_55(object.Float32)
	h = 31*h + deriveHash_56(object.Int)
	h = 31*h + deriveHash_57(object.Int16)
	h = 31*h + deriveHash_58(object.Int32)
	h = 31*h + deriveHash_59(object.Int64)
	h = 31*h + deriveHash_60(object.Int8)
	h = 31*h + deriveHash_61(object.Rune)
	h = 31*h + deriveHash_62(object.String)
	h = 31*h + deriveHash_63(object.Uint)
	h = 31*h + deriveHash_64(object.Uint16)
	h = 31*h + deriveHash_65(object.Uint32)
	h = 31*h + deriveHash_66(object.Uint64)
	h = 31*h + deriveHash_67(object.Uint8)
	h = 31*h + deriveHash_68(object.UintPtr)
	h = 31*h + deriveHash_69(object.AnotherBoolOfDifferentSize)
	return h
}

// deriveHashArrayOfPtrToBuiltInTypes returns the hash of the object.
func deriveHashArrayOfPtrToBuiltInTypes(object *ArrayOfPtrToBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_70(object.Bool)
	h = 31*h + deriveHash_71(object.Byte)
	h = 31*h + deriveHash_72(object.Complex128)
	h = 31*h + deriveHash_73(object.Complex64)
	h = 31*h + deriveHash_74(object.Float64)
	h = 31*h + deriveHash_75(object.Float32)
	h = 31*h + deriveHash_76(object.Int)
	h = 31*h + deriveHash_77(object.Int16)
	h = 31*h + deriveHash_78(object.Int32)
	h = 31*h + deriveHash_79(object.Int64)
	h = 31*h + deriveHash_80(object.Int8)
	h = 31*h + deriveHash_81(object.Rune)
	h = 31*h + deriveHash_82(object.String)
	h = 31*h + deriveHash_83(object.Uint)
	h = 31*h + deriveHash_84(object.Uint16)
	h = 31*h + deriveHash_85(object.Uint32)
	h = 31*h + deriveHash_86(object.Uint64)
	h = 31*h + deriveHash_87(object.Uint8)
	h = 31*h + deriveHash_88(object.UintPtr)
	h = 31*h + deriveHash_89(object.AnotherBoolOfDifferentSize)
	return h
}

// deriveHashMapsOfSimplerBuiltInTypes returns the hash of the object.
func deriveHashMapsOfSimplerBuiltInTypes(object *MapsOfSimplerBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_90(object.StringToUint32)
	h = 31*h + deriveHash_91(object.Uint64ToInt64)
	return h
}

// deriveHashMapsOfBuiltInTypes returns the hash of the object.
func deriveHashMapsOfBuiltInTypes(object *MapsOfBuiltInTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_92(object.BoolToString)
	h = 31*h + deriveHash_93(object.StringToBool)
	h = 31*h + deriveHash_94(object.Complex128ToComplex64)
	h = 31*h + deriveHash_95(object.Float64ToUint32)
	h = 31*h + deriveHash_96(object.Uint16ToUint8)
	return h
}

// deriveHashSliceToSlice returns the hash of the object.
func deriveHashSliceToSlice(object *SliceToSlice) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_97(object.Ints)
	h = 31*h + deriveHash_98(object.Strings)
	h = 31*h + deriveHash_99(object.IntPtrs)
	return h
}

// deriveHashPtrTo returns the hash of the object.
func deriveHashPtrTo(object *PtrTo) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHashPtrToint(object.Basic)
	h = 31*h + deriveHashPtrToSliceOfint(object.Slice)
	h = 31*h + deriveHash_100(object.Array)
	h = 31*h + deriveHashPtrToMapOfintToint(object.Map)
	return h
}

// deriveHashName returns the hash of the object.
func deriveHashName(object *Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_s(object.Name)
	return h
}

// deriveHashStructs returns the hash of the object.
func deriveHashStructs(object *Structs) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_N(object.Struct)
	h = 31*h + deriveHashName(object.PtrToStruct)
	h = 31*h + deriveHash_101(object.SliceOfStructs)
	h = 31*h + deriveHash_102(object.SliceToPtrOfStruct)
	h = 31*h + deriveHash_S(object.StructWithoutMethod)
	h = 31*h + deriveHash_103(object.PtrToStructWithoutMethod)
	h = 31*h + deriveHash_104(object.SliceOfStructWithoutMethod)
	h = 31*h + deriveHash_105(object.SliceToPtrOfStructWithoutMethod)
	return h
}

// deriveHashMapWithStructs returns the hash of the object.
func deriveHashMapWithStructs(object *MapWithStructs) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_106(object.NameToString)
	h = 31*h + deriveHash_107(object.StringToName)
	h = 31*h + deriveHash_108(object.StringToPtrToName)
	h = 31*h + deriveHash_109(object.StringToSliceOfName)
	h = 31*h + deriveHash_110(object.StringToSliceOfPtrToName)
	h = 31*h + deriveHash_111(object.StringToStructWithoutMethod)
	h = 31*h + deriveHash_112(object.StructWithoutMethodToString)
	h = 31*h + deriveHash_113(object.StringToPtrToStructWithoutMethod)
	h = 31*h + deriveHash_114(object.StringToSliceOfStructWithoutMethod)
	h = 31*h + deriveHash_115(object.StringToSliceOfPtrToStructWithoutMethod)
	return h
}

// deriveHashRecursiveType returns the hash of the object.
func deriveHashRecursiveType(object *RecursiveType) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_18(object.Bytes)
	h = 31*h + deriveHash_116(object.N)
	return h
}

// deriveHashEmbeddedStruct1 returns the hash of the object.
func deriveHashEmbeddedStruct1(object *EmbeddedStruct1) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_N(object.Name)
	h = 31*h + deriveHash_S(object.StructWithoutMethod)
	h = 31*h + deriveHashStructs(object.Structs)
	return h
}

// deriveHashEmbeddedStruct2 returns the hash of the object.
func deriveHashEmbeddedStruct2(object *EmbeddedStruct2) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_St(object.Structs)
	h = 31*h + deriveHashName(object.Name)
	h = 31*h + deriveHash_103(object.StructWithoutMethod)
	return h
}

// deriveHashStructWithStructFieldWithoutEqualMethod returns the hash of the object.
func deriveHashStructWithStructFieldWithoutEqualMethod(object *StructWithStructFieldWithoutEqualMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_117(object.A)
	h = 31*h + deriveHash_Str(object.B)
	return h
}

// deriveHashStructWithStructWithFromAnotherPackage returns the hash of the object.
func deriveHashStructWithStructWithFromAnotherPackage(object *StructWithStructWithFromAnotherPackage) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_118(object.A)
	h = 31*h + deriveHash_Stru(object.B)
	return h
}

// deriveHashEnums returns the hash of the object.
func deriveHashEnums(object *Enums) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + uint64(object.Enum)
	h = 31*h + deriveHash_119(object.PtrToEnum)
	h = 31*h + deriveHash_120(object.SliceToEnum)
	h = 31*h + deriveHash_121(object.SliceToPtrToEnum)
	h = 31*h + deriveHash_122(object.MapToEnum)
	h = 31*h + deriveHash_123(object.EnumToMap)
	h = 31*h + deriveHash_124(object.ArrayEnum)
	return h
}

// deriveHashNamedTypes returns the hash of the object.
func deriveHashNamedTypes(object *NamedTypes) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_25(object.Slice)
	h = 31*h + deriveHash_125(object.PtrToSlice)
	h = 31*h + deriveHash_126(object.SliceToSlice)
	return h
}

// deriveHashDuration returns the hash of the object.
func deriveHashDuration(object *Duration) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + uint64(object.D)
	h = 31*h + deriveHash_127(object.P)
	h = 31*h + deriveHash_128(object.Ds)
	h = 31*h + deriveHash_129(object.DPs)
	h = 31*h + deriveHash_130(object.MD)
	return h
}

// deriveHashNickname returns the hash of the object.
func deriveHashNickname(object *Nickname) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_131(object.Alias)
	return h
}

// deriveHashPrivateEmbedded returns the hash of the object.
func deriveHashPrivateEmbedded(object *PrivateEmbedded) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_p(object.privateStruct)
	return h
}

// deriveHashSliceOfint returns the hash of the object.
func deriveHashSliceOfint(object []int) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHashMapOfintToint returns the hash of the object.
func deriveHashMapOfintToint(object map[int]int) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedInts(deriveKeys(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHashPtrToint returns the hash of the object.
func deriveHashPtrToint(object *int) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHashPtrToSliceOfint returns the hash of the object.
func deriveHashPtrToSliceOfint(object *[]int) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHashSliceOfint(*object)
}

// deriveHashPtrToArray10Ofint returns the hash of the object.
func deriveHashPtrToArray10Ofint(object *[10]int) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHash_132(*object)
}

// deriveHashPtrToMapOfintToint returns the hash of the object.
func deriveHashPtrToMapOfintToint(object *map[int]int) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHashMapOfintToint(*object)
}

// deriveHash1 returns the hash of the object.
func deriveHash1(object BuiltInTypes) uint64 {
	return deriveHashBuiltInTypes(&object)
}

// deriveHash returns the hash of the object.
func deriveHash(object PtrToBuiltInTypes) uint64 {
	return deriveHashPtrToBuiltInTypes(&object)
}

// deriveFmapForKeys returns a list where each element of the input list has been morphed by the input function.
func deriveFmapForKeys(f func(int) string, list []int) []string {
	out := make([]string, len(list))
	for i, elem := range list {
		out[i] = f(elem)
	}
	return out
}

// deriveFmap returns a list where each element of the input list has been morphed by the input function.
func deriveFmap(f func(int) int, list []int) []int {
	out := make([]int, len(list))
	for i, elem := range list {
		out[i] = f(elem)
	}
	return out
}

// deriveFmapString morphs a string into list by apply the input function to each rune.
func deriveFmapString(f func(rune) bool, ss string) []bool {
	out := make([]bool, len([]rune(ss)))
	for i, elem := range ss {
		out[i] = f(elem)
	}
	return out
}

// deriveFmapError returns an error if g returns one, otherwise it applies f to g's result and returns it.
func deriveFmapError(f func(int) int64, g func() (int, error)) (int64, error) {
	v, err := g()
	if err != nil {
		return 0, err
	}
	return f(v), nil
}

// deriveFmapEE returns an error if g returns one, otherwise it applies f to g's result and returns it.
func deriveFmapEE(f func(string) (int, error), g func() (string, error)) (func() (int, error), error) {
	v, err := g()
	if err != nil {
		return nil, err
	}
	return deriveTuple(f(v)), nil
}

// deriveFmapPrint returns an error if g returns one, otherwise it applies f to g's result.
func deriveFmapPrint(f func(string), g func() (string, error)) error {
	v, err := g()
	if err != nil {
		return err
	}
	f(v)
	return nil
}

// deriveFmapMore returns an error if g returns one, otherwise it applies f to g's result and returns it.
func deriveFmapMore(f func(string) (int, string, error), g func() (string, error)) (func() (int, string, error), error) {
	v, err := g()
	if err != nil {
		return nil, err
	}
	return deriveTuple_(f(v)), nil
}

// deriveFmapChan returns an output channel where the items are the result of the input function being applied to the items on the input channel.
func deriveFmapChan(f func(string) int, in <-chan string) <-chan int {
	out := make(chan int, cap(in))
	go func() {
		for a := range in {
			b := f(a)
			out <- b
		}
		close(out)
	}()
	return out
}

// deriveFmapSS returns a list where each element of the input list has been morphed by the input function.
func deriveFmapSS(f func(string) []string, list []string) [][]string {
	out := make([][]string, len(list))
	for i, elem := range list {
		out[i] = f(elem)
	}
	return out
}

// deriveFmapEE64 returns an error if g returns one, otherwise it applies f to g's result and returns it.
func deriveFmapEE64(f func(string) (int64, error), g func() (string, error)) (func() (int64, error), error) {
	v, err := g()
	if err != nil {
		return nil, err
	}
	return deriveTuple_i(f(v)), nil
}

// deriveFmapChanChan returns an output channel where the items are the result of the input function being applied to the items on the input channel.
func deriveFmapChanChan(f func(string) <-chan int, in <-chan string) <-chan (<-chan int) {
	out := make(chan (<-chan int), cap(in))
	go func() {
		for a := range in {
			b := f(a)
			out <- b
		}
		close(out)
	}()
	return out
}

// deriveFlipMarshal returns the input function, but where first two parameters are flipped.
func deriveFlipMarshal(f func(data []byte, v any) error) func(v any, data []byte) error {
	return func(v any, data []byte) error {
		return f(data, v)
	}
}

// deriveFlip3 returns the input function, but where first two parameters are flipped.
func deriveFlip3(f func(a int, b string, c bool) string) func(b string, a int, c bool) string {
	return func(b string, a int, c bool) string {
		return f(a, b, c)
	}
}

// deriveFlipBlankIdentifier returns the input function, but where first two parameters are flipped.
func deriveFlipBlankIdentifier(f func(a string, param_1 bool, c int) string) func(param_1 bool, a string, c int) string {
	return func(param_1 bool, a string, c int) string {
		return f(a, param_1, c)
	}
}

// deriveSetInt64s returns the input list as a map with the items of the list as the keys of the map.
//
// Deprecated: In favour of generics.
func deriveSetInt64s(list []int64) map[int64]struct{} {
	set := make(map[int64]struct{}, len(list))
	for _, v := range list {
		set[v] = struct{}{}
	}
	return set
}

// deriveMinInt64s returns the minimum value from the list, or the default value if the list is empty.
//
// Deprecated: In favour of generics.
func deriveMinInt64s(list []int64, def int64) int64 {
	if len(list) == 0 {
		return def
	}
	m := list[0]
	list = list[1:]
	for i, v := range list {
		if v < m {
			m = list[i]
		}
	}
	return m
}

// deriveMinInt returns the minimum of the two input values.
//
// Deprecated: In favour of generics.
func deriveMinInt(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// deriveMinStructs returns the minimum value from the list, or the default value if the list is empty.
//
// Deprecated: In favour of generics.
func deriveMinStructs(list []*BuiltInTypes, def *BuiltInTypes) *BuiltInTypes {
	if len(list) == 0 {
		return def
	}
	m := list[0]
	list = list[1:]
	for i, v := range list {
		if deriveComparePtrToBuiltInTypes(v, m) < 0 {
			m = list[i]
		}
	}
	return m
}

// deriveMemGet returns a memoized version of the input function.
func deriveMemGet(f func() *BuiltInTypes) func() *BuiltInTypes {
	memoized := false
	var res0 *BuiltInTypes
	return func() *BuiltInTypes {
		if !memoized {
			res0 = f()
			memoized = true
		}
		return res0
	}
}

// deriveMemInc returns a memoized version of the input function.
func deriveMemInc(f func(n int) int) func(n int) int {
	m := make(map[int]int)
	return func(param0 int) int {
		if v, ok := m[param0]; ok {
			return v
		}
		v := f(param0)
		m[param0] = v
		return v
	}
}

// deriveMemIncTo returns a memoized version of the input function.
func deriveMemIncTo(f func(a Adder) int) func(a Adder) int {
	m := make(map[Adder]int)
	return func(param0 Adder) int {
		if v, ok := m[param0]; ok {
			return v
		}
		v := f(param0)
		m[param0] = v
		return v
	}
}

// deriveMemAdd returns a memoized version of the input function.
func deriveMemAdd(f func(a int, b int) int) func(a int, b int) int {
	type input struct {
		Param0 int
		Param1 int
	}
	m := make(map[input]int)
	return func(param0 int, param1 int) int {
		in := input{param0, param1}
		if v, ok := m[in]; ok {
			return v
		}
		v := f(param0, param1)
		m[in] = v
		return v
	}
}

// deriveMemAddTo returns a memoized version of the input function.
func deriveMemAddTo(f func(a Adder, b int) int) func(a Adder, b int) int {
	type input struct {
		Param0 Adder
		Param1 int
	}
	m := make(map[input]int)
	return func(param0 Adder, param1 int) int {
		in := input{param0, param1}
		if v, ok := m[in]; ok {
			return v
		}
		v := f(param0, param1)
		m[in] = v
		return v
	}
}

// deriveMemSet returns a memoized version of the input function.
func deriveMemSet(f func(a *BuiltInTypes, b int) *BuiltInTypes) func(a *BuiltInTypes, b int) *BuiltInTypes {
	type input struct {
		Param0 *BuiltInTypes
		Param1 int
	}
	type mem struct {
		in  input
		out *BuiltInTypes
	}
	m := make(map[uint64][]mem)
	return func(param0 *BuiltInTypes, param1 int) *BuiltInTypes {
		in := input{param0, param1}
		h := deriveHash_133(in)
		vs, ok := m[h]
		if ok {
			for _, v := range vs {
				if deriveEqual_95(v.in, in) {
					return v.out
				}
			}
		}
		res0 := f(param0, param1)
		m[h] = append(m[h], mem{in, res0})
		return res0
	}
}

// deriveMemSetErr returns a memoized version of the input function.
func deriveMemSetErr(f func(a *BuiltInTypes, b int) (*BuiltInTypes, error)) func(a *BuiltInTypes, b int) (*BuiltInTypes, error) {
	type input struct {
		Param0 *BuiltInTypes
		Param1 int
	}
	type output struct {
		Res0 *BuiltInTypes
		Res1 error
	}
	type mem struct {
		in  input
		out output
	}
	m := make(map[uint64][]mem)
	return func(param0 *BuiltInTypes, param1 int) (*BuiltInTypes, error) {
		in := input{param0, param1}
		h := deriveHash_133(in)
		vs, ok := m[h]
		if ok {
			for _, v := range vs {
				if deriveEqual_95(v.in, in) {
					return v.out.Res0, v.out.Res1
				}
			}
		}
		res0, res1 := f(param0, param1)
		m[h] = append(m[h], mem{in, output{res0, res1}})
		return res0, res1
	}
}

// deriveMaxInt64s returns the maximum value from the input list and the default value, if the list is empty.
//
// Deprecated: In favour of generics.
func deriveMaxInt64s(list []int64, def int64) int64 {
	if len(list) == 0 {
		return def
	}
	m := list[0]
	list = list[1:]
	for i, v := range list {
		if v > m {
			m = list[i]
		}
	}
	return m
}

// deriveMaxInt returns the maximum of the two input values.
//
// Deprecated: In favour of generics.
func deriveMaxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// deriveMaxStructs returns the maximum value from the input list and the default value, if the list is empty.
//
// Deprecated: In favour of generics.
func deriveMaxStructs(list []*BuiltInTypes, def *BuiltInTypes) *BuiltInTypes {
	if len(list) == 0 {
		return def
	}
	m := list[0]
	list = list[1:]
	for i, v := range list {
		if deriveComparePtrToBuiltInTypes(v, m) > 0 {
			m = list[i]
		}
	}
	return m
}

// deriveDup duplicates messages received on c to both c1 and c2.
func deriveDup(c chan int) (c1, c2 <-chan int) {
	cc1, cc2 := make(chan int, cap(c)), make(chan int, cap(c))
	go func() {
		for v := range c {
			cc1 <- v
			cc2 <- v
		}
		close(cc1)
		close(cc2)
	}()
	return cc1, cc2
}

// deriveAny reports whether the predicate returns true for any of the elements in the given slice.
//
// Deprecated: In favour of generics.
func deriveAny(pred func(int) bool, list []int) bool {
	for _, elem := range list {
		if pred(elem) {
			return true
		}
	}
	return false
}

// deriveAnyEqualCurry reports whether the predicate returns true for any of the elements in the given slice.
//
// Deprecated: In favour of generics.
func deriveAnyEqualCurry(pred func(*BuiltInTypes) bool, list []*BuiltInTypes) bool {
	for _, elem := range list {
		if pred(elem) {
			return true
		}
	}
	return false
}

// deriveAll reports whether the predicate returns true for all of the elements in the given slice.
//
// Deprecated: In favour of generics.
func deriveAll(predicate func(int) bool, slice []int) bool {
	for _, elem := range slice {
		if !predicate(elem) {
			return false
		}
	}
	return true
}

// deriveDo concurrently executes the input functions f0 and f1 and when all functions are finished the first error, if any, and results are returned.
func deriveDo(f0 func() (string, error), f1 func() (int, error)) (string, int, error) {
	errChan := make(chan error)
	var v0 string
	go func() {
		var v0err error
		v0, v0err = f0()
		errChan <- v0err
	}()
	var v1 int
	go func() {
		var v1err error
		v1, v1err = f1()
		errChan <- v1err
	}()
	var err error
	for i := 0; i < 2; i++ {
		errc := <-errChan
		if errc != nil {
			if err == nil {
				err = errc
			}
		}
	}
	return v0, v1, err
}

// deriveGoString returns a recursive representation of this as a valid go string.
func deriveGoString(this []*bool) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*bool {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*bool, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_71(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_ returns a recursive representation of this as a valid go string.
func deriveGoString_(this []*byte) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*byte {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*byte, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_72(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_1 returns a recursive representation of this as a valid go string.
func deriveGoString_1(this []*complex128) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*complex128 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*complex128, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_73(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_2 returns a recursive representation of this as a valid go string.
func deriveGoString_2(this []*complex64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*complex64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*complex64, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_74(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_3 returns a recursive representation of this as a valid go string.
func deriveGoString_3(this []*float64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*float64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*float64, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_75(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_4 returns a recursive representation of this as a valid go string.
func deriveGoString_4(this []*float32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*float32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*float32, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_76(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_5 returns a recursive representation of this as a valid go string.
func deriveGoString_5(this []*int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*int, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoStringIntPtr(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_6 returns a recursive representation of this as a valid go string.
func deriveGoString_6(this []*int16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*int16 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*int16, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_77(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_7 returns a recursive representation of this as a valid go string.
func deriveGoString_7(this []*int32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*int32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*int32, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_78(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_8 returns a recursive representation of this as a valid go string.
func deriveGoString_8(this []*int64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*int64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*int64, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_79(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_9 returns a recursive representation of this as a valid go string.
func deriveGoString_9(this []*int8) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*int8 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*int8, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_80(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_10 returns a recursive representation of this as a valid go string.
func deriveGoString_10(this []*string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*string, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_81(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_11 returns a recursive representation of this as a valid go string.
func deriveGoString_11(this []*uint) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*uint {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*uint, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_82(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_12 returns a recursive representation of this as a valid go string.
func deriveGoString_12(this []*uint16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*uint16 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*uint16, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_83(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_13 returns a recursive representation of this as a valid go string.
func deriveGoString_13(this []*uint32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*uint32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*uint32, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_84(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_14 returns a recursive representation of this as a valid go string.
func deriveGoString_14(this []*uint64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*uint64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*uint64, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_85(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_15 returns a recursive representation of this as a valid go string.
func deriveGoString_15(this []*uintptr) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*uintptr {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*uintptr, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_86(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_16 returns a recursive representation of this as a valid go string.
func deriveGoString_16(this [1]*bool) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [1]*bool {\n")
	fmt.Fprintf(buf, "this := [1]*bool{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_71(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_17 returns a recursive representation of this as a valid go string.
func deriveGoString_17(this [2]*byte) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [2]*byte {\n")
	fmt.Fprintf(buf, "this := [2]*byte{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_72(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_18 returns a recursive representation of this as a valid go string.
func deriveGoString_18(this [3]*complex128) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [3]*complex128 {\n")
	fmt.Fprintf(buf, "this := [3]*complex128{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_73(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_19 returns a recursive representation of this as a valid go string.
func deriveGoString_19(this [4]*complex64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [4]*complex64 {\n")
	fmt.Fprintf(buf, "this := [4]*complex64{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_74(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_20 returns a recursive representation of this as a valid go string.
func deriveGoString_20(this [5]*float64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [5]*float64 {\n")
	fmt.Fprintf(buf, "this := [5]*float64{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_75(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_21 returns a recursive representation of this as a valid go string.
func deriveGoString_21(this [6]*float32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [6]*float32 {\n")
	fmt.Fprintf(buf, "this := [6]*float32{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_76(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_22 returns a recursive representation of this as a valid go string.
func deriveGoString_22(this [7]*int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [7]*int {\n")
	fmt.Fprintf(buf, "this := [7]*int{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoStringIntPtr(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_23 returns a recursive representation of this as a valid go string.
func deriveGoString_23(this [8]*int16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [8]*int16 {\n")
	fmt.Fprintf(buf, "this := [8]*int16{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_77(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_24 returns a recursive representation of this as a valid go string.
func deriveGoString_24(this [9]*int32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [9]*int32 {\n")
	fmt.Fprintf(buf, "this := [9]*int32{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_78(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_25 returns a recursive representation of this as a valid go string.
func deriveGoString_25(this [10]*int64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [10]*int64 {\n")
	fmt.Fprintf(buf, "this := [10]*int64{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_79(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_26 returns a recursive representation of this as a valid go string.
func deriveGoString_26(this [11]*int8) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [11]*int8 {\n")
	fmt.Fprintf(buf, "this := [11]*int8{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_80(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_27 returns a recursive representation of this as a valid go string.
func deriveGoString_27(this [12]*rune) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [12]*rune {\n")
	fmt.Fprintf(buf, "this := [12]*rune{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_78(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_28 returns a recursive representation of this as a valid go string.
func deriveGoString_28(this [13]*string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [13]*string {\n")
	fmt.Fprintf(buf, "this := [13]*string{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_81(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_29 returns a recursive representation of this as a valid go string.
func deriveGoString_29(this [14]*uint) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [14]*uint {\n")
	fmt.Fprintf(buf, "this := [14]*uint{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_82(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_30 returns a recursive representation of this as a valid go string.
func deriveGoString_30(this [15]*uint16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [15]*uint16 {\n")
	fmt.Fprintf(buf, "this := [15]*uint16{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_83(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_31 returns a recursive representation of this as a valid go string.
func deriveGoString_31(this [16]*uint32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [16]*uint32 {\n")
	fmt.Fprintf(buf, "this := [16]*uint32{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_84(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_32 returns a recursive representation of this as a valid go string.
func deriveGoString_32(this [17]*uint64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [17]*uint64 {\n")
	fmt.Fprintf(buf, "this := [17]*uint64{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_85(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_33 returns a recursive representation of this as a valid go string.
func deriveGoString_33(this [18]*uint8) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [18]*uint8 {\n")
	fmt.Fprintf(buf, "this := [18]*uint8{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_72(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_34 returns a recursive representation of this as a valid go string.
func deriveGoString_34(this [19]*uintptr) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [19]*uintptr {\n")
	fmt.Fprintf(buf, "this := [19]*uintptr{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_86(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_35 returns a recursive representation of this as a valid go string.
func deriveGoString_35(this [10]*bool) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [10]*bool {\n")
	fmt.Fprintf(buf, "this := [10]*bool{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_71(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_36 returns a recursive representation of this as a valid go string.
func deriveGoString_36(this [][]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [][]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([][]int, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoStringIntSlices(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_37 returns a recursive representation of this as a valid go string.
func deriveGoString_37(this [][]string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [][]string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([][]string, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_87(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_38 returns a recursive representation of this as a valid go string.
func deriveGoString_38(this [][]*int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [][]*int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([][]*int, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_5(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_39 returns a recursive representation of this as a valid go string.
func deriveGoString_39(this *[4]int) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *[4]int {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new([4]int)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_N returns a recursive representation of this as a valid go string.
func deriveGoString_N(this Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.Name {\n")
	fmt.Fprintf(buf, "this := &test.Name{}\n")
	fmt.Fprintf(buf, "this.Name = %#v\n", this.Name)
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_40 returns a recursive representation of this as a valid go string.
func deriveGoString_40(this []Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]test.Name, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_N(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_41 returns a recursive representation of this as a valid go string.
func deriveGoString_41(this []*Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*test.Name, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoStringName(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_S returns a recursive representation of this as a valid go string.
func deriveGoString_S(this StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.StructWithoutMethod {\n")
	fmt.Fprintf(buf, "this := &test.StructWithoutMethod{}\n")
	fmt.Fprintf(buf, "this.Name = %#v\n", this.Name)
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_42 returns a recursive representation of this as a valid go string.
func deriveGoString_42(this *StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.StructWithoutMethod{}\n")
		fmt.Fprintf(buf, "this.Name = %#v\n", this.Name)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_43 returns a recursive representation of this as a valid go string.
func deriveGoString_43(this []StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]test.StructWithoutMethod, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_S(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_44 returns a recursive representation of this as a valid go string.
func deriveGoString_44(this []*StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*test.StructWithoutMethod, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_42(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_45 returns a recursive representation of this as a valid go string.
func deriveGoString_45(this map[Name]string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[test.Name]string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[test.Name]string)\n")
		i := 0
		for k, v := range this {
			fmt.Fprintf(buf, "key%d := %s\n", i, deriveGoString_N(k))
			fmt.Fprintf(buf, "this[key%d] = %s\n", i, deriveGoString_s(v))
			i++
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_46 returns a recursive representation of this as a valid go string.
func deriveGoString_46(this map[string]Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string]test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string]test.Name)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_N(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_47 returns a recursive representation of this as a valid go string.
func deriveGoString_47(this map[string]*Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string]*test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string]*test.Name)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoStringName(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_48 returns a recursive representation of this as a valid go string.
func deriveGoString_48(this map[string][]Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string][]test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string][]test.Name)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_40(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_49 returns a recursive representation of this as a valid go string.
func deriveGoString_49(this map[string][]*Name) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string][]*test.Name {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string][]*test.Name)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_41(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_50 returns a recursive representation of this as a valid go string.
func deriveGoString_50(this map[string]StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string]test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string]test.StructWithoutMethod)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_S(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_51 returns a recursive representation of this as a valid go string.
func deriveGoString_51(this map[StructWithoutMethod]string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[test.StructWithoutMethod]string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[test.StructWithoutMethod]string)\n")
		i := 0
		for k, v := range this {
			fmt.Fprintf(buf, "key%d := %s\n", i, deriveGoString_S(k))
			fmt.Fprintf(buf, "this[key%d] = %s\n", i, deriveGoString_s(v))
			i++
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_52 returns a recursive representation of this as a valid go string.
func deriveGoString_52(this map[string]*StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string]*test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string]*test.StructWithoutMethod)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_42(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_53 returns a recursive representation of this as a valid go string.
func deriveGoString_53(this map[string][]StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string][]test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string][]test.StructWithoutMethod)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_43(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_54 returns a recursive representation of this as a valid go string.
func deriveGoString_54(this map[string][]*StructWithoutMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string][]*test.StructWithoutMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string][]*test.StructWithoutMethod)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_44(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_55 returns a recursive representation of this as a valid go string.
func deriveGoString_55(this map[int]RecursiveType) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[int]test.RecursiveType {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[int]test.RecursiveType)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_R(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_St returns a recursive representation of this as a valid go string.
func deriveGoString_St(this Structs) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.Structs {\n")
	fmt.Fprintf(buf, "this := &test.Structs{}\n")
	fmt.Fprintf(buf, "this.Struct = %s\n", deriveGoString_N(this.Struct))
	if this.PtrToStruct != nil {
		fmt.Fprintf(buf, "this.PtrToStruct = %s\n", deriveGoStringName(this.PtrToStruct))
	}
	if this.SliceOfStructs != nil {
		fmt.Fprintf(buf, "this.SliceOfStructs = %s\n", deriveGoString_40(this.SliceOfStructs))
	}
	if this.SliceToPtrOfStruct != nil {
		fmt.Fprintf(buf, "this.SliceToPtrOfStruct = %s\n", deriveGoString_41(this.SliceToPtrOfStruct))
	}
	fmt.Fprintf(buf, "this.StructWithoutMethod = %s\n", deriveGoString_S(this.StructWithoutMethod))
	if this.PtrToStructWithoutMethod != nil {
		fmt.Fprintf(buf, "this.PtrToStructWithoutMethod = %s\n", deriveGoString_42(this.PtrToStructWithoutMethod))
	}
	if this.SliceOfStructWithoutMethod != nil {
		fmt.Fprintf(buf, "this.SliceOfStructWithoutMethod = %s\n", deriveGoString_43(this.SliceOfStructWithoutMethod))
	}
	if this.SliceToPtrOfStructWithoutMethod != nil {
		fmt.Fprintf(buf, "this.SliceToPtrOfStructWithoutMethod = %s\n", deriveGoString_44(this.SliceToPtrOfStructWithoutMethod))
	}
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_56 returns a recursive representation of this as a valid go string.
func deriveGoString_56(this *StructWithoutEqualMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.StructWithoutEqualMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &test.StructWithoutEqualMethod{}\n")
		fmt.Fprintf(buf, "this.Num = %#v\n", this.Num)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_Str returns a recursive representation of this as a valid go string.
func deriveGoString_Str(this StructWithoutEqualMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.StructWithoutEqualMethod {\n")
	fmt.Fprintf(buf, "this := &test.StructWithoutEqualMethod{}\n")
	fmt.Fprintf(buf, "this.Num = %#v\n", this.Num)
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_57 returns a recursive representation of this as a valid go string.
func deriveGoString_57(this *extra.StructWithoutEqualMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *extra.StructWithoutEqualMethod {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &extra.StructWithoutEqualMethod{}\n")
		fmt.Fprintf(buf, "this.Number = %#v\n", this.Number)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_Stru returns a recursive representation of this as a valid go string.
func deriveGoString_Stru(this extra.StructWithoutEqualMethod) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() extra.StructWithoutEqualMethod {\n")
	fmt.Fprintf(buf, "this := &extra.StructWithoutEqualMethod{}\n")
	fmt.Fprintf(buf, "this.Number = %#v\n", this.Number)
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_58 returns a recursive representation of this as a valid go string.
func deriveGoString_58(this *MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.MyEnum {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(test.MyEnum)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_59 returns a recursive representation of this as a valid go string.
func deriveGoString_59(this []MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []test.MyEnum {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]test.MyEnum, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_M(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_60 returns a recursive representation of this as a valid go string.
func deriveGoString_60(this []*MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*test.MyEnum {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*test.MyEnum, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_58(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_61 returns a recursive representation of this as a valid go string.
func deriveGoString_61(this map[int32]MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[int32]test.MyEnum {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[int32]test.MyEnum)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_M(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_62 returns a recursive representation of this as a valid go string.
func deriveGoString_62(this map[MyEnum]int32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[test.MyEnum]int32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[test.MyEnum]int32)\n")
		i := 0
		for k, v := range this {
			fmt.Fprintf(buf, "key%d := %s\n", i, deriveGoString_M(k))
			fmt.Fprintf(buf, "this[key%d] = %s\n", i, deriveGoString_i(v))
			i++
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_63 returns a recursive representation of this as a valid go string.
func deriveGoString_63(this [2]MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() [2]test.MyEnum {\n")
	fmt.Fprintf(buf, "this := [2]test.MyEnum{}\n")
	for i := range this {
		fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_M(this[i]))
	}
	fmt.Fprintf(buf, "return this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_64 returns a recursive representation of this as a valid go string.
func deriveGoString_64(this *MySlice) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *test.MySlice {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(test.MySlice)\n")
		if *this != nil {
			fmt.Fprintf(buf, "*this = %#v\n", *this)
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_65 returns a recursive representation of this as a valid go string.
func deriveGoString_65(this []MySlice) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []test.MySlice {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]test.MySlice, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_My(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_66 returns a recursive representation of this as a valid go string.
func deriveGoString_66(this *time.Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *time.Duration {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(time.Duration)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_67 returns a recursive representation of this as a valid go string.
func deriveGoString_67(this []time.Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []time.Duration {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]time.Duration, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_D(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_68 returns a recursive representation of this as a valid go string.
func deriveGoString_68(this []*time.Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*time.Duration {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*time.Duration, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_66(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_69 returns a recursive representation of this as a valid go string.
func deriveGoString_69(this map[int]time.Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[int]time.Duration {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[int]time.Duration)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_D(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_70 returns a recursive representation of this as a valid go string.
func deriveGoString_70(this map[string][]*pickle.Rick) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() map[string][]*pickle.Rick {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make(map[string][]*pickle.Rick)\n")
		for k, v := range this {
			fmt.Fprintf(buf, "this[%#v] = %s\n", k, deriveGoString_88(v))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_p returns a recursive representation of this as a valid go string.
func deriveGoString_p(this privateStruct) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.privateStruct {\n")
	fmt.Fprintf(buf, "this := &test.privateStruct{}\n")
	if this.ptrfield != nil {
		fmt.Fprintf(buf, "this.ptrfield = func (v int) *int { return &v }(%#v)\n", *this.ptrfield)
	}
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveDeepCopy recursively copies the contents of src into dst.
func deriveDeepCopy(dst, src []*bool) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(bool)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_ recursively copies the contents of src into dst.
func deriveDeepCopy_(dst, src []*byte) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(byte)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_1 recursively copies the contents of src into dst.
func deriveDeepCopy_1(dst, src []*complex128) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(complex128)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_2 recursively copies the contents of src into dst.
func deriveDeepCopy_2(dst, src []*complex64) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(complex64)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_3 recursively copies the contents of src into dst.
func deriveDeepCopy_3(dst, src []*float64) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(float64)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_4 recursively copies the contents of src into dst.
func deriveDeepCopy_4(dst, src []*float32) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(float32)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_5 recursively copies the contents of src into dst.
func deriveDeepCopy_5(dst, src []*int) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(int)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_6 recursively copies the contents of src into dst.
func deriveDeepCopy_6(dst, src []*int16) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(int16)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_7 recursively copies the contents of src into dst.
func deriveDeepCopy_7(dst, src []*int32) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(int32)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_8 recursively copies the contents of src into dst.
func deriveDeepCopy_8(dst, src []*int64) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(int64)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_9 recursively copies the contents of src into dst.
func deriveDeepCopy_9(dst, src []*int8) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(int8)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_10 recursively copies the contents of src into dst.
func deriveDeepCopy_10(dst, src []*string) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(string)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_11 recursively copies the contents of src into dst.
func deriveDeepCopy_11(dst, src []*uint) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(uint)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_12 recursively copies the contents of src into dst.
func deriveDeepCopy_12(dst, src []*uint16) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(uint16)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_13 recursively copies the contents of src into dst.
func deriveDeepCopy_13(dst, src []*uint32) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(uint32)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_14 recursively copies the contents of src into dst.
func deriveDeepCopy_14(dst, src []*uint64) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(uint64)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_15 recursively copies the contents of src into dst.
func deriveDeepCopy_15(dst, src []*uintptr) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(uintptr)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_16 recursively copies the contents of src into dst.
func deriveDeepCopy_16(dst, src map[string]uint32) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_17 recursively copies the contents of src into dst.
func deriveDeepCopy_17(dst, src map[uint8]int64) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_18 recursively copies the contents of src into dst.
func deriveDeepCopy_18(dst, src map[bool]string) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_19 recursively copies the contents of src into dst.
func deriveDeepCopy_19(dst, src map[string]bool) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_20 recursively copies the contents of src into dst.
func deriveDeepCopy_20(dst, src map[complex128]complex64) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_21 recursively copies the contents of src into dst.
func deriveDeepCopy_21(dst, src map[float64]uint32) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_22 recursively copies the contents of src into dst.
func deriveDeepCopy_22(dst, src map[uint16]uint8) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_23 recursively copies the contents of src into dst.
func deriveDeepCopy_23(dst, src [][]int) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			if dst[src_i] != nil {
				if len(src_value) > len(dst[src_i]) {
					if cap(dst[src_i]) >= len(src_value) {
						dst[src_i] = (dst[src_i])[:len(src_value)]
					} else {
						dst[src_i] = make([]int, len(src_value))
					}
				} else if len(src_value) < len(dst[src_i]) {
					dst[src_i] = (dst[src_i])[:len(src_value)]
				}
			} else {
				dst[src_i] = make([]int, len(src_value))
			}
			copy(dst[src_i], src_value)
		}
	}
}

// deriveDeepCopy_24 recursively copies the contents of src into dst.
func deriveDeepCopy_24(dst, src [][]string) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			if dst[src_i] != nil {
				if len(src_value) > len(dst[src_i]) {
					if cap(dst[src_i]) >= len(src_value) {
						dst[src_i] = (dst[src_i])[:len(src_value)]
					} else {
						dst[src_i] = make([]string, len(src_value))
					}
				} else if len(src_value) < len(dst[src_i]) {
					dst[src_i] = (dst[src_i])[:len(src_value)]
				}
			} else {
				dst[src_i] = make([]string, len(src_value))
			}
			copy(dst[src_i], src_value)
		}
	}
}

// deriveDeepCopy_25 recursively copies the contents of src into dst.
func deriveDeepCopy_25(dst, src [][]*int) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			if dst[src_i] != nil {
				if len(src_value) > len(dst[src_i]) {
					if cap(dst[src_i]) >= len(src_value) {
						dst[src_i] = (dst[src_i])[:len(src_value)]
					} else {
						dst[src_i] = make([]*int, len(src_value))
					}
				} else if len(src_value) < len(dst[src_i]) {
					dst[src_i] = (dst[src_i])[:len(src_value)]
				}
			} else {
				dst[src_i] = make([]*int, len(src_value))
			}
			deriveDeepCopy_5(dst[src_i], src_value)
		}
	}
}

// deriveDeepCopy_26 recursively copies the contents of src into dst.
func deriveDeepCopy_26(dst, src *[]int) {
	if *src == nil {
		*dst = nil
	} else {
		if *dst != nil {
			if len(*src) > len(*dst) {
				if cap(*dst) >= len(*src) {
					*dst = (*dst)[:len(*src)]
				} else {
					*dst = make([]int, len(*src))
				}
			} else if len(*src) < len(*dst) {
				*dst = (*dst)[:len(*src)]
			}
		} else {
			*dst = make([]int, len(*src))
		}
		copy(*dst, *src)
	}
}

// deriveDeepCopy_27 recursively copies the contents of src into dst.
func deriveDeepCopy_27(dst, src *map[int]int) {
	if *src != nil {
		*dst = make(map[int]int, len(*src))
		deriveDeepCopy_52(*dst, *src)
	} else {
		*dst = nil
	}
}

// deriveDeepCopy_28 recursively copies the contents of src into dst.
func deriveDeepCopy_28(dst, src []*Name) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(Name)
			src_value.DeepCopy(dst[src_i])
		}
	}
}

// deriveDeepCopy_29 recursively copies the contents of src into dst.
func deriveDeepCopy_29(dst, src []*StructWithoutMethod) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(StructWithoutMethod)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_30 recursively copies the contents of src into dst.
func deriveDeepCopy_30(dst, src map[Name]string) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_31 recursively copies the contents of src into dst.
func deriveDeepCopy_31(dst, src map[string]Name) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_32 recursively copies the contents of src into dst.
func deriveDeepCopy_32(dst, src map[string]*Name) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			dst[src_key] = new(Name)
			src_value.DeepCopy(dst[src_key])
		}
	}
}

// deriveDeepCopy_33 recursively copies the contents of src into dst.
func deriveDeepCopy_33(dst, src map[string][]Name) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			if dst[src_key] != nil {
				if len(src_value) > len(dst[src_key]) {
					if cap(dst[src_key]) >= len(src_value) {
						dst[src_key] = (dst[src_key])[:len(src_value)]
					} else {
						dst[src_key] = make([]Name, len(src_value))
					}
				} else if len(src_value) < len(dst[src_key]) {
					dst[src_key] = (dst[src_key])[:len(src_value)]
				}
			} else {
				dst[src_key] = make([]Name, len(src_value))
			}
			copy(dst[src_key], src_value)
		}
	}
}

// deriveDeepCopy_34 recursively copies the contents of src into dst.
func deriveDeepCopy_34(dst, src map[string][]*Name) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			if dst[src_key] != nil {
				if len(src_value) > len(dst[src_key]) {
					if cap(dst[src_key]) >= len(src_value) {
						dst[src_key] = (dst[src_key])[:len(src_value)]
					} else {
						dst[src_key] = make([]*Name, len(src_value))
					}
				} else if len(src_value) < len(dst[src_key]) {
					dst[src_key] = (dst[src_key])[:len(src_value)]
				}
			} else {
				dst[src_key] = make([]*Name, len(src_value))
			}
			deriveDeepCopy_28(dst[src_key], src_value)
		}
	}
}

// deriveDeepCopy_35 recursively copies the contents of src into dst.
func deriveDeepCopy_35(dst, src map[string]StructWithoutMethod) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_36 recursively copies the contents of src into dst.
func deriveDeepCopy_36(dst, src map[StructWithoutMethod]string) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_37 recursively copies the contents of src into dst.
func deriveDeepCopy_37(dst, src map[string]*StructWithoutMethod) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			dst[src_key] = new(StructWithoutMethod)
			*dst[src_key] = *src_value
		}
	}
}

// deriveDeepCopy_38 recursively copies the contents of src into dst.
func deriveDeepCopy_38(dst, src map[string][]StructWithoutMethod) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			if dst[src_key] != nil {
				if len(src_value) > len(dst[src_key]) {
					if cap(dst[src_key]) >= len(src_value) {
						dst[src_key] = (dst[src_key])[:len(src_value)]
					} else {
						dst[src_key] = make([]StructWithoutMethod, len(src_value))
					}
				} else if len(src_value) < len(dst[src_key]) {
					dst[src_key] = (dst[src_key])[:len(src_value)]
				}
			} else {
				dst[src_key] = make([]StructWithoutMethod, len(src_value))
			}
			copy(dst[src_key], src_value)
		}
	}
}

// deriveDeepCopy_39 recursively copies the contents of src into dst.
func deriveDeepCopy_39(dst, src map[string][]*StructWithoutMethod) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			if dst[src_key] != nil {
				if len(src_value) > len(dst[src_key]) {
					if cap(dst[src_key]) >= len(src_value) {
						dst[src_key] = (dst[src_key])[:len(src_value)]
					} else {
						dst[src_key] = make([]*StructWithoutMethod, len(src_value))
					}
				} else if len(src_value) < len(dst[src_key]) {
					dst[src_key] = (dst[src_key])[:len(src_value)]
				}
			} else {
				dst[src_key] = make([]*StructWithoutMethod, len(src_value))
			}
			deriveDeepCopy_29(dst[src_key], src_value)
		}
	}
}

// deriveDeepCopy_40 recursively copies the contents of src into dst.
func deriveDeepCopy_40(dst, src map[int]RecursiveType) {
	for src_key, src_value := range src {
		{
			field := new(RecursiveType)
			src_value.DeepCopy(field)
			dst[src_key] = *field
		}
	}
}

// deriveDeepCopy_41 recursively copies the contents of src into dst.
func deriveDeepCopy_41(dst, src *extra.PrivateFieldAndNoEqualMethod) {
	src_v := reflect.Indirect(reflect.ValueOf(src))
	dst_v := reflect.Indirect(reflect.ValueOf(dst))
	*(*int64)(unsafe.Pointer(dst_v.FieldByName("number").UnsafeAddr())) = *(*int64)(unsafe.Pointer(src_v.FieldByName("number").UnsafeAddr()))
	if *(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr())) == nil {
		*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) = nil
	} else {
		if *(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) != nil {
			if len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr()))) > len(*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr()))) {
				if cap(*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr()))) >= len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr()))) {
					*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) = (*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())))[:len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr())))]
				} else {
					*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) = make([]int64, len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr()))))
				}
			} else if len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr()))) < len(*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr()))) {
				*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) = (*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())))[:len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr())))]
			}
		} else {
			*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())) = make([]int64, len(*(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr()))))
		}
		copy(*(*[]int64)(unsafe.Pointer(dst_v.FieldByName("numbers").UnsafeAddr())), *(*[]int64)(unsafe.Pointer(src_v.FieldByName("numbers").UnsafeAddr())))
	}
	if *(**int64)(unsafe.Pointer(src_v.FieldByName("ptr").UnsafeAddr())) == nil {
		*(**int64)(unsafe.Pointer(dst_v.FieldByName("ptr").UnsafeAddr())) = nil
	} else {
		*(**int64)(unsafe.Pointer(dst_v.FieldByName("ptr").UnsafeAddr())) = new(int64)
		**(**int64)(unsafe.Pointer(dst_v.FieldByName("ptr").UnsafeAddr())) = **(**int64)(unsafe.Pointer(src_v.FieldByName("ptr").UnsafeAddr()))
	}
	if *(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr())) == nil {
		*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) = nil
	} else {
		if *(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) != nil {
			if len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr()))) > len(*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr()))) {
				if cap(*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr()))) >= len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr()))) {
					*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) = (*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())))[:len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr())))]
				} else {
					*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) = make([]*int64, len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr()))))
				}
			} else if len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr()))) < len(*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr()))) {
				*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) = (*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())))[:len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr())))]
			}
		} else {
			*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())) = make([]*int64, len(*(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr()))))
		}
		deriveDeepCopy_8(*(*[]*int64)(unsafe.Pointer(dst_v.FieldByName("numberpts").UnsafeAddr())), *(*[]*int64)(unsafe.Pointer(src_v.FieldByName("numberpts").UnsafeAddr())))
	}
	if *(**extra.StructWithoutEqualMethod)(unsafe.Pointer(src_v.FieldByName("strct").UnsafeAddr())) == nil {
		*(**extra.StructWithoutEqualMethod)(unsafe.Pointer(dst_v.FieldByName("strct").UnsafeAddr())) = nil
	} else {
		*(**extra.StructWithoutEqualMethod)(unsafe.Pointer(dst_v.FieldByName("strct").UnsafeAddr())) = new(extra.StructWithoutEqualMethod)
		**(**extra.StructWithoutEqualMethod)(unsafe.Pointer(dst_v.FieldByName("strct").UnsafeAddr())) = **(**extra.StructWithoutEqualMethod)(unsafe.Pointer(src_v.FieldByName("strct").UnsafeAddr()))
	}
}

// deriveDeepCopy_42 recursively copies the contents of src into dst.
func deriveDeepCopy_42(dst, src []*MyEnum) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(MyEnum)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_43 recursively copies the contents of src into dst.
func deriveDeepCopy_43(dst, src map[int32]MyEnum) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_44 recursively copies the contents of src into dst.
func deriveDeepCopy_44(dst, src map[MyEnum]int32) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_45 recursively copies the contents of src into dst.
func deriveDeepCopy_45(dst, src *MySlice) {
	if *src == nil {
		*dst = nil
	} else {
		if *dst != nil {
			if len(*src) > len(*dst) {
				if cap(*dst) >= len(*src) {
					*dst = (*dst)[:len(*src)]
				} else {
					*dst = make([]int64, len(*src))
				}
			} else if len(*src) < len(*dst) {
				*dst = (*dst)[:len(*src)]
			}
		} else {
			*dst = make([]int64, len(*src))
		}
		copy(*dst, *src)
	}
}

// deriveDeepCopy_46 recursively copies the contents of src into dst.
func deriveDeepCopy_46(dst, src []MySlice) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			if dst[src_i] != nil {
				if len(src_value) > len(dst[src_i]) {
					if cap(dst[src_i]) >= len(src_value) {
						dst[src_i] = (dst[src_i])[:len(src_value)]
					} else {
						dst[src_i] = make([]int64, len(src_value))
					}
				} else if len(src_value) < len(dst[src_i]) {
					dst[src_i] = (dst[src_i])[:len(src_value)]
				}
			} else {
				dst[src_i] = make([]int64, len(src_value))
			}
			copy(dst[src_i], src_value)
		}
	}
}

// deriveDeepCopy_47 recursively copies the contents of src into dst.
func deriveDeepCopy_47(dst, src []*time.Duration) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(time.Duration)
			*dst[src_i] = *src_value
		}
	}
}

// deriveDeepCopy_48 recursively copies the contents of src into dst.
func deriveDeepCopy_48(dst, src map[int]time.Duration) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_49 recursively copies the contents of src into dst.
func deriveDeepCopy_49(dst, src map[string][]*pickle.Rick) {
	for src_key, src_value := range src {
		if src_value == nil {
			dst[src_key] = nil
		}
		if src_value == nil {
			dst[src_key] = nil
		} else {
			if dst[src_key] != nil {
				if len(src_value) > len(dst[src_key]) {
					if cap(dst[src_key]) >= len(src_value) {
						dst[src_key] = (dst[src_key])[:len(src_value)]
					} else {
						dst[src_key] = make([]*pickle.Rick, len(src_value))
					}
				} else if len(src_value) < len(dst[src_key]) {
					dst[src_key] = (dst[src_key])[:len(src_value)]
				}
			} else {
				dst[src_key] = make([]*pickle.Rick, len(src_value))
			}
			deriveDeepCopy_55(dst[src_key], src_value)
		}
	}
}

// deriveDeepCopy_50 recursively copies the contents of src into dst.
func deriveDeepCopy_50(dst, src *privateStruct) {
	if src.ptrfield == nil {
		dst.ptrfield = nil
	} else {
		dst.ptrfield = new(int)
		*dst.ptrfield = *src.ptrfield
	}
}

// deriveDeepCopy_51 recursively copies the contents of src into dst.
func deriveDeepCopy_51(dst, src []int) {
	copy(dst, src)
}

// deriveDeepCopy_52 recursively copies the contents of src into dst.
func deriveDeepCopy_52(dst, src map[int]int) {
	for src_key, src_value := range src {
		dst[src_key] = src_value
	}
}

// deriveDeepCopy_53 recursively copies the contents of src into dst.
func deriveDeepCopy_53(dst, src *int) {
	*dst = *src
}

// deriveDeepCopy_54 recursively copies the contents of src into dst.
func deriveDeepCopy_54(dst, src *[10]int) {
	*dst = *src
}

// deriveCompare returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare(this, that bool) int {
	if this == that {
		return 0
	}
	if that {
		return -1
	}
	return 1
}

// deriveCompare_ returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_(this, that byte) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_f returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_f(this, that float64) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_fl returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_fl(this, that float32) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_i returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_i(this, that int) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_in returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_in(this, that int16) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_int returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_int(this, that int32) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_int6 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_int6(this, that int64) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_int8 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_int8(this, that int8) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_u returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_u(this, that uint) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_ui returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_ui(this, that uint16) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_uin returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_uin(this, that uint32) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_uint returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_uint(this, that uint64) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_1 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_1(this, that uintptr) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_2 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_2(this, that *bool) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare(*this, *that)
}

// deriveCompare_3 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_3(this, that *byte) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_(*this, *that)
}

// deriveCompare_4 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_4(this, that *complex128) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompareComplex64(*this, *that)
}

// deriveCompare_5 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_5(this, that *complex64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompareComplex32(*this, *that)
}

// deriveCompare_6 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_6(this, that *float64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_f(*this, *that)
}

// deriveCompare_7 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_7(this, that *float32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_fl(*this, *that)
}

// deriveCompare_8 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_8(this, that *int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_i(*this, *that)
}

// deriveCompare_9 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_9(this, that *int16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_in(*this, *that)
}

// deriveCompare_10 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_10(this, that *int32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_int(*this, *that)
}

// deriveCompare_11 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_11(this, that *int64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_int6(*this, *that)
}

// deriveCompare_12 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_12(this, that *int8) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_int8(*this, *that)
}

// deriveCompare_13 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_13(this, that *string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_s(*this, *that)
}

// deriveCompare_14 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_14(this, that *uint) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_u(*this, *that)
}

// deriveCompare_15 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_15(this, that *uint16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_ui(*this, *that)
}

// deriveCompare_16 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_16(this, that *uint32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_uin(*this, *that)
}

// deriveCompare_17 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_17(this, that *uint64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_uint(*this, *that)
}

// deriveCompare_18 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_18(this, that *uintptr) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_1(*this, *that)
}

// deriveCompare_19 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_19(this, that []bool) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_20 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_20(this, that []complex128) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompareComplex64(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_21 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_21(this, that []complex64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompareComplex32(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_22 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_22(this, that []float64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_f(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_23 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_23(this, that []float32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_fl(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_24 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_24(this, that []int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_i(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_25 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_25(this, that []int16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_in(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_26 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_26(this, that []int32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_27 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_27(this, that []int64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int6(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_28 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_28(this, that []int8) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int8(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_29 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_29(this, that []string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := strings.Compare(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_30 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_30(this, that []uint) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_u(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_31 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_31(this, that []uint16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_ui(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_32 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_32(this, that []uint32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_uin(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_33 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_33(this, that []uint64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_uint(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_34 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_34(this, that []uintptr) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_1(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_35 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_35(this, that []*bool) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_2(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_36 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_36(this, that []*byte) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_3(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_37 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_37(this, that []*complex128) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_4(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_38 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_38(this, that []*complex64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_5(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_39 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_39(this, that []*float64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_6(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_40 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_40(this, that []*float32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_7(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_41 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_41(this, that []*int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_8(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_42 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_42(this, that []*int16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_9(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_43 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_43(this, that []*int32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_10(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_44 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_44(this, that []*int64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_11(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_45 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_45(this, that []*int8) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_12(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_46 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_46(this, that []*string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_13(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_47 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_47(this, that []*uint) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_14(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_48 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_48(this, that []*uint16) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_15(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_49 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_49(this, that []*uint32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_16(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_50 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_50(this, that []*uint64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_17(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_51 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_51(this, that []*uintptr) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_18(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_52 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_52(this, that [1]bool) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_53 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_53(this, that [2]byte) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_54 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_54(this, that [3]complex128) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompareComplex64(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_55 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_55(this, that [4]complex64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompareComplex32(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_56 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_56(this, that [5]float64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_f(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_57 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_57(this, that [6]float32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_fl(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_58 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_58(this, that [7]int) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_i(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_59 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_59(this, that [8]int16) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_in(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_60 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_60(this, that [9]int32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_61 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_61(this, that [10]int64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int6(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_62 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_62(this, that [11]int8) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int8(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_63 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_63(this, that [12]rune) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_int(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_64 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_64(this, that [13]string) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := strings.Compare(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_65 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_65(this, that [14]uint) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_u(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_66 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_66(this, that [15]uint16) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_ui(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_67 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_67(this, that [16]uint32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_uin(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_68 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_68(this, that [17]uint64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_uint(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_69 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_69(this, that [18]uint8) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_70 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_70(this, that [19]uintptr) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_1(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_71 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_71(this, that [10]bool) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_72 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_72(this, that [1]*bool) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_2(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_73 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_73(this, that [2]*byte) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_3(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_74 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_74(this, that [3]*complex128) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_4(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_75 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_75(this, that [4]*complex64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_5(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_76 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_76(this, that [5]*float64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_6(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_77 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_77(this, that [6]*float32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_7(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_78 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_78(this, that [7]*int) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_8(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_79 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_79(this, that [8]*int16) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_9(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_80 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_80(this, that [9]*int32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_10(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_81 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_81(this, that [10]*int64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_11(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_82 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_82(this, that [11]*int8) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_12(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_83 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_83(this, that [12]*rune) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_10(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_84 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_84(this, that [13]*string) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_13(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_85 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_85(this, that [14]*uint) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_14(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_86 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_86(this, that [15]*uint16) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_15(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_87 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_87(this, that [16]*uint32) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_16(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_88 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_88(this, that [17]*uint64) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_17(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_89 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_89(this, that [18]*uint8) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_3(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_90 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_90(this, that [19]*uintptr) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_18(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_91 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_91(this, that [10]*bool) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_2(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_92 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_92(this, that map[string]uint32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_(this))
	thatkeys := deriveSortedStrings(deriveKeys_(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_uin(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_93 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_93(this, that map[uint8]int64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort(deriveKeys_1(this))
	thatkeys := deriveSort(deriveKeys_1(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_int6(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_94 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_94(this, that map[bool]string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_(deriveKeys_2(this))
	thatkeys := deriveSort_(deriveKeys_2(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := strings.Compare(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_95 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_95(this, that map[string]bool) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_3(this))
	thatkeys := deriveSortedStrings(deriveKeys_3(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_96 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_96(this, that map[complex128]complex64) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_1(deriveKeys_4(this))
	thatkeys := deriveSort_1(deriveKeys_4(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompareComplex32(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompareComplex64(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_97 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_97(this, that map[float64]uint32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_2(deriveKeys_5(this))
	thatkeys := deriveSort_2(deriveKeys_5(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_uin(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_f(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_98 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_98(this, that map[uint16]uint8) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_3(deriveKeys_6(this))
	thatkeys := deriveSort_3(deriveKeys_6(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_ui(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_99 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_99(this, that [][]int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_24(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_100 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_100(this, that [][]string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_29(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_101 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_101(this, that [][]*int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_41(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_102 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_102(this, that *[]int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_24(*this, *that)
}

// deriveCompare_103 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_103(this, that *[4]int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_139(*this, *that)
}

// deriveCompare_104 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_104(this, that *map[int]int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_140(*this, *that)
}

// deriveCompare_105 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_105(this, that []Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := this[i].Compare(&that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_106 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_106(this, that []*Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := this[i].Compare(that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_107 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_107(this, that *StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := strings.Compare(this.Name, that.Name); c != 0 {
		return c
	}
	return 0
}

// deriveCompare_108 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_108(this, that []StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_107(&this[i], &that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_109 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_109(this, that []*StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_107(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_110 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_110(this, that map[Name]string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_4(deriveKeys_7(this))
	thatkeys := deriveSort_4(deriveKeys_7(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := strings.Compare(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := thiskey.Compare(&thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_111 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_111(this, that map[string]Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_8(this))
	thatkeys := deriveSortedStrings(deriveKeys_8(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := thisvalue.Compare(&thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_112 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_112(this, that map[string]*Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_9(this))
	thatkeys := deriveSortedStrings(deriveKeys_9(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := thisvalue.Compare(thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_113 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_113(this, that map[string][]Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_10(this))
	thatkeys := deriveSortedStrings(deriveKeys_10(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_105(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_114 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_114(this, that map[string][]*Name) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_11(this))
	thatkeys := deriveSortedStrings(deriveKeys_11(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_106(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_115 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_115(this, that map[string]StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_12(this))
	thatkeys := deriveSortedStrings(deriveKeys_12(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_107(&thisvalue, &thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_116 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_116(this, that map[StructWithoutMethod]string) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_5(deriveKeys_13(this))
	thatkeys := deriveSort_5(deriveKeys_13(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := strings.Compare(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_107(&thiskey, &thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_117 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_117(this, that map[string]*StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_14(this))
	thatkeys := deriveSortedStrings(deriveKeys_14(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_107(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_118 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_118(this, that map[string][]StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_15(this))
	thatkeys := deriveSortedStrings(deriveKeys_15(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_108(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_119 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_119(this, that map[string][]*StructWithoutMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_16(this))
	thatkeys := deriveSortedStrings(deriveKeys_16(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_109(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_120 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_120(this, that map[int]RecursiveType) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedInts(deriveKeys_17(this))
	thatkeys := deriveSortedInts(deriveKeys_17(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := thisvalue.Compare(&thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_i(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_121 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_121(this, that *StructWithoutEqualMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_int6(this.Num, that.Num); c != 0 {
		return c
	}
	return 0
}

// deriveCompare_122 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_122(this, that *extra.StructWithoutEqualMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_int6(this.Number, that.Number); c != 0 {
		return c
	}
	return 0
}

// deriveCompare_123 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_123(this, that *extra.PrivateFieldAndNoEqualMethod) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	thisv := reflect.Indirect(reflect.ValueOf(this))
	thatv := reflect.Indirect(reflect.ValueOf(that))
	if c := deriveCompare_int6(*(*int64)(unsafe.Pointer(thisv.FieldByName("number").UnsafeAddr())), *(*int64)(unsafe.Pointer(thatv.FieldByName("number").UnsafeAddr()))); c != 0 {
		return c
	}
	if c := deriveCompare_27(*(*[]int64)(unsafe.Pointer(thisv.FieldByName("numbers").UnsafeAddr())), *(*[]int64)(unsafe.Pointer(thatv.FieldByName("numbers").UnsafeAddr()))); c != 0 {
		return c
	}
	if c := deriveCompare_11(*(**int64)(unsafe.Pointer(thisv.FieldByName("ptr").UnsafeAddr())), *(**int64)(unsafe.Pointer(thatv.FieldByName("ptr").UnsafeAddr()))); c != 0 {
		return c
	}
	if c := deriveCompare_44(*(*[]*int64)(unsafe.Pointer(thisv.FieldByName("numberpts").UnsafeAddr())), *(*[]*int64)(unsafe.Pointer(thatv.FieldByName("numberpts").UnsafeAddr()))); c != 0 {
		return c
	}
	if c := deriveCompare_122(*(**extra.StructWithoutEqualMethod)(unsafe.Pointer(thisv.FieldByName("strct").UnsafeAddr())), *(**extra.StructWithoutEqualMethod)(unsafe.Pointer(thatv.FieldByName("strct").UnsafeAddr()))); c != 0 {
		return c
	}
	return 0
}

// deriveCompare_M returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_M(this, that MyEnum) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_124 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_124(this, that *MyEnum) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_M(*this, *that)
}

// deriveCompare_125 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_125(this, that []MyEnum) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_M(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_126 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_126(this, that []*MyEnum) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_124(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_127 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_127(this, that map[int32]MyEnum) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_6(deriveKeys_18(this))
	thatkeys := deriveSort_6(deriveKeys_18(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_M(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_int(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_128 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_128(this, that map[MyEnum]int32) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSort_7(deriveKeys_19(this))
	thatkeys := deriveSort_7(deriveKeys_19(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_int(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_M(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_129 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_129(this, that [2]MyEnum) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_M(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_130 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_130(this, that *MySlice) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_27(*this, *that)
}

// deriveCompare_131 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_131(this, that []MySlice) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_27(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_D returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_D(this, that time.Duration) int {
	if this != that {
		if this < that {
			return -1
		} else {
			return 1
		}
	}
	return 0
}

// deriveCompare_132 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_132(this, that *time.Duration) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	return deriveCompare_D(*this, *that)
}

// deriveCompare_133 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_133(this, that []time.Duration) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_D(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_134 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_134(this, that []*time.Duration) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_132(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_135 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_135(this, that map[int]time.Duration) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedInts(deriveKeys_20(this))
	thatkeys := deriveSortedInts(deriveKeys_20(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_D(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_i(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_136 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_136(this, that map[string][]*pickle.Rick) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedStrings(deriveKeys_21(this))
	thatkeys := deriveSortedStrings(deriveKeys_21(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_141(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := strings.Compare(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_137 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_137(this, that *privateStruct) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := deriveCompare_8(this.ptrfield, that.ptrfield); c != 0 {
		return c
	}
	return 0
}

// deriveCompare_138 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_138(this, that *StructWithStringAlias) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := strings.Compare(string(this.Field), string(that.Field)); c != 0 {
		return c
	}
	return 0
}

// deriveTuple returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple(v0 int, v1 error) func() (int, error) {
	return func() (int, error) {
		return v0, v1
	}
}

// deriveTuple_ returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple_(v0 int, v1 string, v2 error) func() (int, string, error) {
	return func() (int, string, error) {
		return v0, v1, v2
	}
}

// deriveTuple_i returns a function, which returns the input values.
// Since tuples are not first class citizens in Go, this is a way to fake it, because functions that return tuples are first class citizens.
func deriveTuple_i(v0 int64, v1 error) func() (int64, error) {
	return func() (int64, error) {
		return v0, v1
	}
}

// deriveEqual_ returns whether this and that are equal.
func deriveEqual_(this, that []bool) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_1 returns whether this and that are equal.
func deriveEqual_1(this, that []complex128) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_2 returns whether this and that are equal.
func deriveEqual_2(this, that []complex64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_3 returns whether this and that are equal.
func deriveEqual_3(this, that []float64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_4 returns whether this and that are equal.
func deriveEqual_4(this, that []float32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_5 returns whether this and that are equal.
func deriveEqual_5(this, that []int16) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_6 returns whether this and that are equal.
func deriveEqual_6(this, that []int32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_7 returns whether this and that are equal.
func deriveEqual_7(this, that []int64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_8 returns whether this and that are equal.
func deriveEqual_8(this, that []int8) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_9 returns whether this and that are equal.
func deriveEqual_9(this, that []string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_10 returns whether this and that are equal.
func deriveEqual_10(this, that []uint) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_11 returns whether this and that are equal.
func deriveEqual_11(this, that []uint16) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_12 returns whether this and that are equal.
func deriveEqual_12(this, that []uint32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_13 returns whether this and that are equal.
func deriveEqual_13(this, that []uint64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_14 returns whether this and that are equal.
func deriveEqual_14(this, that []uintptr) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_15 returns whether this and that are equal.
func deriveEqual_15(this, that []*bool) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_16 returns whether this and that are equal.
func deriveEqual_16(this, that []*byte) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_17 returns whether this and that are equal.
func deriveEqual_17(this, that []*complex128) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_18 returns whether this and that are equal.
func deriveEqual_18(this, that []*complex64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_19 returns whether this and that are equal.
func deriveEqual_19(this, that []*float64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_20 returns whether this and that are equal.
func deriveEqual_20(this, that []*float32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_21 returns whether this and that are equal.
func deriveEqual_21(this, that []*int) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_22 returns whether this and that are equal.
func deriveEqual_22(this, that []*int16) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_23 returns whether this and that are equal.
func deriveEqual_23(this, that []*int32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_24 returns whether this and that are equal.
func deriveEqual_24(this, that []*int64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_25 returns whether this and that are equal.
func deriveEqual_25(this, that []*int8) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_26 returns whether this and that are equal.
func deriveEqual_26(this, that []*string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_27 returns whether this and that are equal.
func deriveEqual_27(this, that []*uint) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_28 returns whether this and that are equal.
func deriveEqual_28(this, that []*uint16) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_29 returns whether this and that are equal.
func deriveEqual_29(this, that []*uint32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_30 returns whether this and that are equal.
func deriveEqual_30(this, that []*uint64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_31 returns whether this and that are equal.
func deriveEqual_31(this, that []*uintptr) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_32 returns whether this and that are equal.
func deriveEqual_32(this, that [1]*bool) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_33 returns whether this and that are equal.
func deriveEqual_33(this, that [2]*byte) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_34 returns whether this and that are equal.
func deriveEqual_34(this, that [3]*complex128) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_35 returns whether this and that are equal.
func deriveEqual_35(this, that [4]*complex64) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_36 returns whether this and that are equal.
func deriveEqual_36(this, that [5]*float64) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_37 returns whether this and that are equal.
func deriveEqual_37(this, that [6]*float32) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_38 returns whether this and that are equal.
func deriveEqual_38(this, that [7]*int) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_39 returns whether this and that are equal.
func deriveEqual_39(this, that [8]*int16) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_40 returns whether this and that are equal.
func deriveEqual_40(this, that [9]*int32) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_41 returns whether this and that are equal.
func deriveEqual_41(this, that [10]*int64) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_42 returns whether this and that are equal.
func deriveEqual_42(this, that [11]*int8) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_43 returns whether this and that are equal.
func deriveEqual_43(this, that [12]*rune) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_44 returns whether this and that are equal.
func deriveEqual_44(this, that [13]*string) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_45 returns whether this and that are equal.
func deriveEqual_45(this, that [14]*uint) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_46 returns whether this and that are equal.
func deriveEqual_46(this, that [15]*uint16) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_47 returns whether this and that are equal.
func deriveEqual_47(this, that [16]*uint32) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_48 returns whether this and that are equal.
func deriveEqual_48(this, that [17]*uint64) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_49 returns whether this and that are equal.
func deriveEqual_49(this, that [18]*uint8) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_50 returns whether this and that are equal.
func deriveEqual_50(this, that [19]*uintptr) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_51 returns whether this and that are equal.
func deriveEqual_51(this, that [10]*bool) bool {
	for i := 0; i < len(this); i++ {
		if !((this[i] == nil && that[i] == nil) || (this[i] != nil && that[i] != nil && *(this[i]) == *(that[i]))) {
			return false
		}
	}
	return true
}

// deriveEqual_52 returns whether this and that are equal.
func deriveEqual_52(this, that map[string]uint32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_53 returns whether this and that are equal.
func deriveEqual_53(this, that map[uint8]int64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_54 returns whether this and that are equal.
func deriveEqual_54(this, that map[bool]string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_55 returns whether this and that are equal.
func deriveEqual_55(this, that map[string]bool) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_56 returns whether this and that are equal.
func deriveEqual_56(this, that map[complex128]complex64) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_57 returns whether this and that are equal.
func deriveEqual_57(this, that map[float64]uint32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_58 returns whether this and that are equal.
func deriveEqual_58(this, that map[uint16]uint8) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_59 returns whether this and that are equal.
func deriveEqual_59(this, that [][]int) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqualSliceOfint(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_60 returns whether this and that are equal.
func deriveEqual_60(this, that [][]string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_9(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_61 returns whether this and that are equal.
func deriveEqual_61(this, that [][]*int) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_21(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_62 returns whether this and that are equal.
func deriveEqual_62(this, that []Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i].Equal(&that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_63 returns whether this and that are equal.
func deriveEqual_63(this, that []*Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i].Equal(that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_64 returns whether this and that are equal.
func deriveEqual_64(this, that *StructWithoutMethod) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Name == that.Name
}

// deriveEqual_65 returns whether this and that are equal.
func deriveEqual_65(this, that []StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_66 returns whether this and that are equal.
func deriveEqual_66(this, that []*StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_64(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_67 returns whether this and that are equal.
func deriveEqual_67(this, that map[Name]string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_68 returns whether this and that are equal.
func deriveEqual_68(this, that map[string]Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v.Equal(&thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_69 returns whether this and that are equal.
func deriveEqual_69(this, that map[string]*Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v.Equal(thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_70 returns whether this and that are equal.
func deriveEqual_70(this, that map[string][]Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_62(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_71 returns whether this and that are equal.
func deriveEqual_71(this, that map[string][]*Name) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_63(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_72 returns whether this and that are equal.
func deriveEqual_72(this, that map[string]StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_73 returns whether this and that are equal.
func deriveEqual_73(this, that map[StructWithoutMethod]string) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_74 returns whether this and that are equal.
func deriveEqual_74(this, that map[string]*StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_64(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_75 returns whether this and that are equal.
func deriveEqual_75(this, that map[string][]StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_65(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_76 returns whether this and that are equal.
func deriveEqual_76(this, that map[string][]*StructWithoutMethod) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_66(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_77 returns whether this and that are equal.
func deriveEqual_77(this, that map[int]RecursiveType) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v.Equal(&thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_78 returns whether this and that are equal.
func deriveEqual_78(this, that *StructWithoutEqualMethod) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Num == that.Num
}

// deriveEqual_79 returns whether this and that are equal.
func deriveEqual_79(this, that *extra.StructWithoutEqualMethod) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Number == that.Number
}

// deriveEqual_80 returns whether this and that are equal.
func deriveEqual_80(this, that *extra.PrivateFieldAndNoEqualMethod) bool {
	thisv := reflect.Indirect(reflect.ValueOf(this))
	thatv := reflect.Indirect(reflect.ValueOf(that))
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			*(*int64)(unsafe.Pointer(thisv.FieldByName("number").UnsafeAddr())) == *(*int64)(unsafe.Pointer(thatv.FieldByName("number").UnsafeAddr())) &&
			deriveEqual_7(*(*[]int64)(unsafe.Pointer(thisv.FieldByName("numbers").UnsafeAddr())), *(*[]int64)(unsafe.Pointer(thatv.FieldByName("numbers").UnsafeAddr()))) &&
			((*(**int64)(unsafe.Pointer(thisv.FieldByName("ptr").UnsafeAddr())) == nil && *(**int64)(unsafe.Pointer(thatv.FieldByName("ptr").UnsafeAddr())) == nil) || (*(**int64)(unsafe.Pointer(thisv.FieldByName("ptr").UnsafeAddr())) != nil && *(**int64)(unsafe.Pointer(thatv.FieldByName("ptr").UnsafeAddr())) != nil && *(*(**int64)(unsafe.Pointer(thisv.FieldByName("ptr").UnsafeAddr()))) == *(*(**int64)(unsafe.Pointer(thatv.FieldByName("ptr").UnsafeAddr()))))) &&
			deriveEqual_24(*(*[]*int64)(unsafe.Pointer(thisv.FieldByName("numberpts").UnsafeAddr())), *(*[]*int64)(unsafe.Pointer(thatv.FieldByName("numberpts").UnsafeAddr()))) &&
			deriveEqual_79(*(**extra.StructWithoutEqualMethod)(unsafe.Pointer(thisv.FieldByName("strct").UnsafeAddr())), *(**extra.StructWithoutEqualMethod)(unsafe.Pointer(thatv.FieldByName("strct").UnsafeAddr())))
}

// deriveEqual_81 returns whether this and that are equal.
func deriveEqual_81(this, that *MyEnum) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		return *this == *that
	}
	return false
}

// deriveEqual_82 returns whether this and that are equal.
func deriveEqual_82(this, that []MyEnum) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_83 returns whether this and that are equal.
func deriveEqual_83(this, that []*MyEnum) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_81(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_84 returns whether this and that are equal.
func deriveEqual_84(this, that map[int32]MyEnum) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_85 returns whether this and that are equal.
func deriveEqual_85(this, that map[MyEnum]int32) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_86 returns whether this and that are equal.
func deriveEqual_86(this, that *MySlice) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		if *this == nil || *that == nil {
			return *this == nil && *that == nil
		}
		if len(*this) != len(*that) {
			return false
		}
		for i := 0; i < len(*this); i++ {
			if !((*this)[i] == (*that)[i]) {
				return false
			}
		}
		return true
	}
	return false
}

// deriveEqual_87 returns whether this and that are equal.
func deriveEqual_87(this, that []MySlice) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_7(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_88 returns whether this and that are equal.
func deriveEqual_88(this, that *time.Duration) bool {
	if this == nil && that == nil {
		return true
	}
	if this != nil && that != nil {
		return *this == *that
	}
	return false
}

// deriveEqual_89 returns whether this and that are equal.
func deriveEqual_89(this, that []time.Duration) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(this[i] == that[i]) {
			return false
		}
	}
	return true
}

// deriveEqual_90 returns whether this and that are equal.
func deriveEqual_90(this, that []*time.Duration) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_88(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveEqual_91 returns whether this and that are equal.
func deriveEqual_91(this, that map[int]time.Duration) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(v == thatv) {
			return false
		}
	}
	return true
}

// deriveEqual_92 returns whether this and that are equal.
func deriveEqual_92(this, that map[string][]*pickle.Rick) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for k, v := range this {
		thatv, ok := that[k]
		if !ok {
			return false
		}
		if !(deriveEqual_96(v, thatv)) {
			return false
		}
	}
	return true
}

// deriveEqual_93 returns whether this and that are equal.
func deriveEqual_93(this, that *privateStruct) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			((this.ptrfield == nil && that.ptrfield == nil) || (this.ptrfield != nil && that.ptrfield != nil && *(this.ptrfield) == *(that.ptrfield)))
}

// deriveEqual_94 returns whether this and that are equal.
func deriveEqual_94(this, that *Visitor) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			((this.UserName == nil && that.UserName == nil) || (this.UserName != nil && that.UserName != nil && *(this.UserName) == *(that.UserName))) &&
			this.RemoteAddr == that.RemoteAddr
}

// deriveEqual_95 returns whether this and that are equal.
func deriveEqual_95(this, that struct {
	Param0 *BuiltInTypes
	Param1 int
}) bool {
	return this.Param0.Equal(that.Param0) &&
		this.Param1 == that.Param1
}

// deriveSort sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort(list []uint8) []uint8 {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSort_ sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_(list []bool) []bool {
	sort.Slice(list, func(i, j int) bool { return deriveCompare(list[i], list[j]) < 0 })
	return list
}

// deriveSort_1 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_1(list []complex128) []complex128 {
	sort.Slice(list, func(i, j int) bool { return deriveCompareComplex64(list[i], list[j]) < 0 })
	return list
}

// deriveSort_2 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_2(list []float64) []float64 {
	sort.Float64s(list)
	return list
}

// deriveSort_3 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_3(list []uint16) []uint16 {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSort_4 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_4(list []Name) []Name {
	sort.Slice(list, func(i, j int) bool { return deriveCompare_N(list[i], list[j]) < 0 })
	return list
}

// deriveSort_5 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_5(list []StructWithoutMethod) []StructWithoutMethod {
	sort.Slice(list, func(i, j int) bool { return deriveCompare_S(list[i], list[j]) < 0 })
	return list
}

// deriveSort_6 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_6(list []int32) []int32 {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveSort_7 sorts the slice inplace and also returns it.
//
// Deprecated: In favour of generics.
func deriveSort_7(list []MyEnum) []MyEnum {
	sort.Slice(list, func(i, j int) bool { return list[i] < list[j] })
	return list
}

// deriveKeys returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys(m map[int]int) []int {
	keys := make([]int, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_ returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_(m map[string]uint32) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_1 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_1(m map[uint8]int64) []uint8 {
	keys := make([]uint8, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_2 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_2(m map[bool]string) []bool {
	keys := make([]bool, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_3 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_3(m map[string]bool) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_4 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_4(m map[complex128]complex64) []complex128 {
	keys := make([]complex128, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_5 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_5(m map[float64]uint32) []float64 {
	keys := make([]float64, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_6 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_6(m map[uint16]uint8) []uint16 {
	keys := make([]uint16, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_7 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_7(m map[Name]string) []Name {
	keys := make([]Name, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_8 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_8(m map[string]Name) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_9 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_9(m map[string]*Name) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_10 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_10(m map[string][]Name) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_11 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_11(m map[string][]*Name) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_12 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_12(m map[string]StructWithoutMethod) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_13 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_13(m map[StructWithoutMethod]string) []StructWithoutMethod {
	keys := make([]StructWithoutMethod, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_14 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_14(m map[string]*StructWithoutMethod) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_15 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_15(m map[string][]StructWithoutMethod) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_16 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_16(m map[string][]*StructWithoutMethod) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_17 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_17(m map[int]RecursiveType) []int {
	keys := make([]int, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_18 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_18(m map[int32]MyEnum) []int32 {
	keys := make([]int32, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_19 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_19(m map[MyEnum]int32) []MyEnum {
	keys := make([]MyEnum, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_20 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_20(m map[int]time.Duration) []int {
	keys := make([]int, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveKeys_21 returns the keys of the input map as a slice.
//
// Deprecated: In favour of generics.
func deriveKeys_21(m map[string][]*pickle.Rick) []string {
	keys := make([]string, 0, len(m))
	for key := range m {
		keys = append(keys, key)
	}
	return keys
}

// deriveHash_ returns the hash of the object.
func deriveHash_(object bool) uint64 {
	if object {
		return 1
	}
	return 0
}

// deriveHash_s returns the hash of the object.
func deriveHash_s(object string) uint64 {
	var h uint64
	for _, c := range object {
		h = 31*h + uint64(c)
	}
	return h
}

// deriveHash_1 returns the hash of the object.
func deriveHash_1(object *bool) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHash_(*object)
}

// deriveHash_2 returns the hash of the object.
func deriveHash_2(object *byte) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_3 returns the hash of the object.
func deriveHash_3(object *complex128) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + (31 * ((31 * 17) + math.Float64bits(real(*object)))) + math.Float64bits(imag(*object))
}

// deriveHash_4 returns the hash of the object.
func deriveHash_4(object *complex64) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + (31 * ((31 * 17) + uint64(math.Float32bits(real(*object))))) + uint64(math.Float32bits(imag(*object)))
}

// deriveHash_5 returns the hash of the object.
func deriveHash_5(object *float64) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + math.Float64bits(*object)
}

// deriveHash_6 returns the hash of the object.
func deriveHash_6(object *float32) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(math.Float32bits(*object))
}

// deriveHash_7 returns the hash of the object.
func deriveHash_7(object *int16) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_8 returns the hash of the object.
func deriveHash_8(object *int32) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_9 returns the hash of the object.
func deriveHash_9(object *int64) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_10 returns the hash of the object.
func deriveHash_10(object *int8) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_11 returns the hash of the object.
func deriveHash_11(object *string) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHash_s(*object)
}

// deriveHash_12 returns the hash of the object.
func deriveHash_12(object *uint) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_13 returns the hash of the object.
func deriveHash_13(object *uint16) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_14 returns the hash of the object.
func deriveHash_14(object *uint32) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_15 returns the hash of the object.
func deriveHash_15(object *uint64) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + *object
}

// deriveHash_16 returns the hash of the object.
func deriveHash_16(object *uintptr) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_17 returns the hash of the object.
func deriveHash_17(object []bool) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_(object[i])
	}
	return h
}

// deriveHash_18 returns the hash of the object.
func deriveHash_18(object []byte) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_19 returns the hash of the object.
func deriveHash_19(object []complex128) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + (31 * ((31 * 17) + math.Float64bits(real(object[i])))) + math.Float64bits(imag(object[i]))
	}
	return h
}

// deriveHash_20 returns the hash of the object.
func deriveHash_20(object []complex64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + (31 * ((31 * 17) + uint64(math.Float32bits(real(object[i]))))) + uint64(math.Float32bits(imag(object[i])))
	}
	return h
}

// deriveHash_21 returns the hash of the object.
func deriveHash_21(object []float64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + math.Float64bits(object[i])
	}
	return h
}

// deriveHash_22 returns the hash of the object.
func deriveHash_22(object []float32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(math.Float32bits(object[i]))
	}
	return h
}

// deriveHash_23 returns the hash of the object.
func deriveHash_23(object []int16) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_24 returns the hash of the object.
func deriveHash_24(object []int32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_25 returns the hash of the object.
func deriveHash_25(object []int64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_26 returns the hash of the object.
func deriveHash_26(object []int8) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_27 returns the hash of the object.
func deriveHash_27(object []string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_s(object[i])
	}
	return h
}

// deriveHash_28 returns the hash of the object.
func deriveHash_28(object []uint) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_29 returns the hash of the object.
func deriveHash_29(object []uint16) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_30 returns the hash of the object.
func deriveHash_30(object []uint32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_31 returns the hash of the object.
func deriveHash_31(object []uint64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + object[i]
	}
	return h
}

// deriveHash_32 returns the hash of the object.
func deriveHash_32(object []uintptr) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_33 returns the hash of the object.
func deriveHash_33(object []*bool) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_1(object[i])
	}
	return h
}

// deriveHash_34 returns the hash of the object.
func deriveHash_34(object []*byte) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_2(object[i])
	}
	return h
}

// deriveHash_35 returns the hash of the object.
func deriveHash_35(object []*complex128) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_3(object[i])
	}
	return h
}

// deriveHash_36 returns the hash of the object.
func deriveHash_36(object []*complex64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_4(object[i])
	}
	return h
}

// deriveHash_37 returns the hash of the object.
func deriveHash_37(object []*float64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_5(object[i])
	}
	return h
}

// deriveHash_38 returns the hash of the object.
func deriveHash_38(object []*float32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_6(object[i])
	}
	return h
}

// deriveHash_39 returns the hash of the object.
func deriveHash_39(object []*int) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHashPtrToint(object[i])
	}
	return h
}

// deriveHash_40 returns the hash of the object.
func deriveHash_40(object []*int16) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_7(object[i])
	}
	return h
}

// deriveHash_41 returns the hash of the object.
func deriveHash_41(object []*int32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_8(object[i])
	}
	return h
}

// deriveHash_42 returns the hash of the object.
func deriveHash_42(object []*int64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_9(object[i])
	}
	return h
}

// deriveHash_43 returns the hash of the object.
func deriveHash_43(object []*int8) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_10(object[i])
	}
	return h
}

// deriveHash_44 returns the hash of the object.
func deriveHash_44(object []*string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_11(object[i])
	}
	return h
}

// deriveHash_45 returns the hash of the object.
func deriveHash_45(object []*uint) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_12(object[i])
	}
	return h
}

// deriveHash_46 returns the hash of the object.
func deriveHash_46(object []*uint16) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_13(object[i])
	}
	return h
}

// deriveHash_47 returns the hash of the object.
func deriveHash_47(object []*uint32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_14(object[i])
	}
	return h
}

// deriveHash_48 returns the hash of the object.
func deriveHash_48(object []*uint64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_15(object[i])
	}
	return h
}

// deriveHash_49 returns the hash of the object.
func deriveHash_49(object []*uintptr) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_16(object[i])
	}
	return h
}

// deriveHash_50 returns the hash of the object.
func deriveHash_50(object [1]bool) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_(object[i])
	}
	return h
}

// deriveHash_51 returns the hash of the object.
func deriveHash_51(object [2]byte) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_52 returns the hash of the object.
func deriveHash_52(object [3]complex128) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + (31 * ((31 * 17) + math.Float64bits(real(object[i])))) + math.Float64bits(imag(object[i]))
	}
	return h
}

// deriveHash_53 returns the hash of the object.
func deriveHash_53(object [4]complex64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + (31 * ((31 * 17) + uint64(math.Float32bits(real(object[i]))))) + uint64(math.Float32bits(imag(object[i])))
	}
	return h
}

// deriveHash_54 returns the hash of the object.
func deriveHash_54(object [5]float64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + math.Float64bits(object[i])
	}
	return h
}

// deriveHash_55 returns the hash of the object.
func deriveHash_55(object [6]float32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(math.Float32bits(object[i]))
	}
	return h
}

// deriveHash_56 returns the hash of the object.
func deriveHash_56(object [7]int) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_57 returns the hash of the object.
func deriveHash_57(object [8]int16) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_58 returns the hash of the object.
func deriveHash_58(object [9]int32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_59 returns the hash of the object.
func deriveHash_59(object [10]int64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_60 returns the hash of the object.
func deriveHash_60(object [11]int8) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_61 returns the hash of the object.
func deriveHash_61(object [12]rune) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_62 returns the hash of the object.
func deriveHash_62(object [13]string) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_s(object[i])
	}
	return h
}

// deriveHash_63 returns the hash of the object.
func deriveHash_63(object [14]uint) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_64 returns the hash of the object.
func deriveHash_64(object [15]uint16) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_65 returns the hash of the object.
func deriveHash_65(object [16]uint32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_66 returns the hash of the object.
func deriveHash_66(object [17]uint64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + object[i]
	}
	return h
}

// deriveHash_67 returns the hash of the object.
func deriveHash_67(object [18]uint8) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_68 returns the hash of the object.
func deriveHash_68(object [19]uintptr) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_69 returns the hash of the object.
func deriveHash_69(object [10]bool) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_(object[i])
	}
	return h
}

// deriveHash_70 returns the hash of the object.
func deriveHash_70(object [1]*bool) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_1(object[i])
	}
	return h
}

// deriveHash_71 returns the hash of the object.
func deriveHash_71(object [2]*byte) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_2(object[i])
	}
	return h
}

// deriveHash_72 returns the hash of the object.
func deriveHash_72(object [3]*complex128) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_3(object[i])
	}
	return h
}

// deriveHash_73 returns the hash of the object.
func deriveHash_73(object [4]*complex64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_4(object[i])
	}
	return h
}

// deriveHash_74 returns the hash of the object.
func deriveHash_74(object [5]*float64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_5(object[i])
	}
	return h
}

// deriveHash_75 returns the hash of the object.
func deriveHash_75(object [6]*float32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_6(object[i])
	}
	return h
}

// deriveHash_76 returns the hash of the object.
func deriveHash_76(object [7]*int) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHashPtrToint(object[i])
	}
	return h
}

// deriveHash_77 returns the hash of the object.
func deriveHash_77(object [8]*int16) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_7(object[i])
	}
	return h
}

// deriveHash_78 returns the hash of the object.
func deriveHash_78(object [9]*int32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_8(object[i])
	}
	return h
}

// deriveHash_79 returns the hash of the object.
func deriveHash_79(object [10]*int64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_9(object[i])
	}
	return h
}

// deriveHash_80 returns the hash of the object.
func deriveHash_80(object [11]*int8) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_10(object[i])
	}
	return h
}

// deriveHash_81 returns the hash of the object.
func deriveHash_81(object [12]*rune) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_8(object[i])
	}
	return h
}

// deriveHash_82 returns the hash of the object.
func deriveHash_82(object [13]*string) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_11(object[i])
	}
	return h
}

// deriveHash_83 returns the hash of the object.
func deriveHash_83(object [14]*uint) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_12(object[i])
	}
	return h
}

// deriveHash_84 returns the hash of the object.
func deriveHash_84(object [15]*uint16) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_13(object[i])
	}
	return h
}

// deriveHash_85 returns the hash of the object.
func deriveHash_85(object [16]*uint32) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_14(object[i])
	}
	return h
}

// deriveHash_86 returns the hash of the object.
func deriveHash_86(object [17]*uint64) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_15(object[i])
	}
	return h
}

// deriveHash_87 returns the hash of the object.
func deriveHash_87(object [18]*uint8) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_2(object[i])
	}
	return h
}

// deriveHash_88 returns the hash of the object.
func deriveHash_88(object [19]*uintptr) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_16(object[i])
	}
	return h
}

// deriveHash_89 returns the hash of the object.
func deriveHash_89(object [10]*bool) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_1(object[i])
	}
	return h
}

// deriveHash_90 returns the hash of the object.
func deriveHash_90(object map[string]uint32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_91 returns the hash of the object.
func deriveHash_91(object map[uint8]int64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort(deriveKeys_1(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_92 returns the hash of the object.
func deriveHash_92(object map[bool]string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_(deriveKeys_2(object)) {
		h = 31*h + deriveHash_(k)
		h = 31*h + deriveHash_s(object[k])
	}
	return h
}

// deriveHash_93 returns the hash of the object.
func deriveHash_93(object map[string]bool) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_3(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_(object[k])
	}
	return h
}

// deriveHash_94 returns the hash of the object.
func deriveHash_94(object map[complex128]complex64) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_1(deriveKeys_4(object)) {
		h = 31*h + (31 * ((31 * 17) + math.Float64bits(real(k)))) + math.Float64bits(imag(k))
		h = 31*h + (31 * ((31 * 17) + uint64(math.Float32bits(real(object[k]))))) + uint64(math.Float32bits(imag(object[k])))
	}
	return h
}

// deriveHash_95 returns the hash of the object.
func deriveHash_95(object map[float64]uint32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_2(deriveKeys_5(object)) {
		h = 31*h + math.Float64bits(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_96 returns the hash of the object.
func deriveHash_96(object map[uint16]uint8) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_3(deriveKeys_6(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_97 returns the hash of the object.
func deriveHash_97(object [][]int) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHashSliceOfint(object[i])
	}
	return h
}

// deriveHash_98 returns the hash of the object.
func deriveHash_98(object [][]string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_27(object[i])
	}
	return h
}

// deriveHash_99 returns the hash of the object.
func deriveHash_99(object [][]*int) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_39(object[i])
	}
	return h
}

// deriveHash_100 returns the hash of the object.
func deriveHash_100(object *[4]int) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHash_134(*object)
}

// deriveHash_N returns the hash of the object.
func deriveHash_N(object Name) uint64 {
	return deriveHashName(&object)
}

// deriveHash_101 returns the hash of the object.
func deriveHash_101(object []Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_N(object[i])
	}
	return h
}

// deriveHash_102 returns the hash of the object.
func deriveHash_102(object []*Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHashName(object[i])
	}
	return h
}

// deriveHash_S returns the hash of the object.
func deriveHash_S(object StructWithoutMethod) uint64 {
	return deriveHash_103(&object)
}

// deriveHash_103 returns the hash of the object.
func deriveHash_103(object *StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_s(object.Name)
	return h
}

// deriveHash_104 returns the hash of the object.
func deriveHash_104(object []StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_S(object[i])
	}
	return h
}

// deriveHash_105 returns the hash of the object.
func deriveHash_105(object []*StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_103(object[i])
	}
	return h
}

// deriveHash_106 returns the hash of the object.
func deriveHash_106(object map[Name]string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_4(deriveKeys_7(object)) {
		h = 31*h + deriveHash_N(k)
		h = 31*h + deriveHash_s(object[k])
	}
	return h
}

// deriveHash_107 returns the hash of the object.
func deriveHash_107(object map[string]Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_8(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_N(object[k])
	}
	return h
}

// deriveHash_108 returns the hash of the object.
func deriveHash_108(object map[string]*Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_9(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHashName(object[k])
	}
	return h
}

// deriveHash_109 returns the hash of the object.
func deriveHash_109(object map[string][]Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_10(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_101(object[k])
	}
	return h
}

// deriveHash_110 returns the hash of the object.
func deriveHash_110(object map[string][]*Name) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_11(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_102(object[k])
	}
	return h
}

// deriveHash_111 returns the hash of the object.
func deriveHash_111(object map[string]StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_12(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_S(object[k])
	}
	return h
}

// deriveHash_112 returns the hash of the object.
func deriveHash_112(object map[StructWithoutMethod]string) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_5(deriveKeys_13(object)) {
		h = 31*h + deriveHash_S(k)
		h = 31*h + deriveHash_s(object[k])
	}
	return h
}

// deriveHash_113 returns the hash of the object.
func deriveHash_113(object map[string]*StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_14(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_103(object[k])
	}
	return h
}

// deriveHash_114 returns the hash of the object.
func deriveHash_114(object map[string][]StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_15(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_104(object[k])
	}
	return h
}

// deriveHash_115 returns the hash of the object.
func deriveHash_115(object map[string][]*StructWithoutMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_16(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_105(object[k])
	}
	return h
}

// deriveHash_116 returns the hash of the object.
func deriveHash_116(object map[int]RecursiveType) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedInts(deriveKeys_17(object)) {
		h = 31*h + uint64(k)
		h = 31*h + deriveHash_R(object[k])
	}
	return h
}

// deriveHash_St returns the hash of the object.
func deriveHash_St(object Structs) uint64 {
	return deriveHashStructs(&object)
}

// deriveHash_117 returns the hash of the object.
func deriveHash_117(object *StructWithoutEqualMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + uint64(object.Num)
	return h
}

// deriveHash_Str returns the hash of the object.
func deriveHash_Str(object StructWithoutEqualMethod) uint64 {
	return deriveHash_117(&object)
}

// deriveHash_118 returns the hash of the object.
func deriveHash_118(object *extra.StructWithoutEqualMethod) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + uint64(object.Number)
	return h
}

// deriveHash_Stru returns the hash of the object.
func deriveHash_Stru(object extra.StructWithoutEqualMethod) uint64 {
	return deriveHash_118(&object)
}

// deriveHash_119 returns the hash of the object.
func deriveHash_119(object *MyEnum) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_120 returns the hash of the object.
func deriveHash_120(object []MyEnum) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_121 returns the hash of the object.
func deriveHash_121(object []*MyEnum) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_119(object[i])
	}
	return h
}

// deriveHash_122 returns the hash of the object.
func deriveHash_122(object map[int32]MyEnum) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_6(deriveKeys_18(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_123 returns the hash of the object.
func deriveHash_123(object map[MyEnum]int32) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSort_7(deriveKeys_19(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_124 returns the hash of the object.
func deriveHash_124(object [2]MyEnum) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_125 returns the hash of the object.
func deriveHash_125(object *MySlice) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + deriveHash_25(*object)
}

// deriveHash_126 returns the hash of the object.
func deriveHash_126(object []MySlice) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_25(object[i])
	}
	return h
}

// deriveHash_127 returns the hash of the object.
func deriveHash_127(object *time.Duration) uint64 {
	if object == nil {
		return 0
	}
	return (31 * 17) + uint64(*object)
}

// deriveHash_128 returns the hash of the object.
func deriveHash_128(object []time.Duration) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_129 returns the hash of the object.
func deriveHash_129(object []*time.Duration) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_127(object[i])
	}
	return h
}

// deriveHash_130 returns the hash of the object.
func deriveHash_130(object map[int]time.Duration) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedInts(deriveKeys_20(object)) {
		h = 31*h + uint64(k)
		h = 31*h + uint64(object[k])
	}
	return h
}

// deriveHash_131 returns the hash of the object.
func deriveHash_131(object map[string][]*pickle.Rick) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for _, k := range deriveSortedStrings(deriveKeys_21(object)) {
		h = 31*h + deriveHash_s(k)
		h = 31*h + deriveHash_135(object[k])
	}
	return h
}

// deriveHash_p returns the hash of the object.
func deriveHash_p(object privateStruct) uint64 {
	return deriveHash_136(&object)
}

// deriveHash_132 returns the hash of the object.
func deriveHash_132(object [10]int) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_133 returns the hash of the object.
func deriveHash_133(object struct {
	Param0 *BuiltInTypes
	Param1 int
}) uint64 {
	h := uint64(17)
	h = 31*h + deriveHashBuiltInTypes(object.Param0)
	h = 31*h + uint64(object.Param1)
	return h
}

// deriveGoString_71 returns a recursive representation of this as a valid go string.
func deriveGoString_71(this *bool) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *bool {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(bool)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_72 returns a recursive representation of this as a valid go string.
func deriveGoString_72(this *byte) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *byte {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(byte)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_73 returns a recursive representation of this as a valid go string.
func deriveGoString_73(this *complex128) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *complex128 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(complex128)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_74 returns a recursive representation of this as a valid go string.
func deriveGoString_74(this *complex64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *complex64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(complex64)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_75 returns a recursive representation of this as a valid go string.
func deriveGoString_75(this *float64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *float64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(float64)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_76 returns a recursive representation of this as a valid go string.
func deriveGoString_76(this *float32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *float32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(float32)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_77 returns a recursive representation of this as a valid go string.
func deriveGoString_77(this *int16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *int16 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(int16)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_78 returns a recursive representation of this as a valid go string.
func deriveGoString_78(this *int32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *int32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(int32)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_79 returns a recursive representation of this as a valid go string.
func deriveGoString_79(this *int64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *int64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(int64)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_80 returns a recursive representation of this as a valid go string.
func deriveGoString_80(this *int8) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *int8 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(int8)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_81 returns a recursive representation of this as a valid go string.
func deriveGoString_81(this *string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(string)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_82 returns a recursive representation of this as a valid go string.
func deriveGoString_82(this *uint) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *uint {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(uint)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_83 returns a recursive representation of this as a valid go string.
func deriveGoString_83(this *uint16) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *uint16 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(uint16)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_84 returns a recursive representation of this as a valid go string.
func deriveGoString_84(this *uint32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *uint32 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(uint32)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_85 returns a recursive representation of this as a valid go string.
func deriveGoString_85(this *uint64) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *uint64 {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(uint64)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_86 returns a recursive representation of this as a valid go string.
func deriveGoString_86(this *uintptr) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *uintptr {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := new(uintptr)\n")
		fmt.Fprintf(buf, "*this = %#v\n", *this)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_87 returns a recursive representation of this as a valid go string.
func deriveGoString_87(this []string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []string {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "return %#v\n", this)
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_s returns a recursive representation of this as a valid go string.
func deriveGoString_s(this string) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() string {\n")
	fmt.Fprintf(buf, "return %#v\n", this)
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_R returns a recursive representation of this as a valid go string.
func deriveGoString_R(this RecursiveType) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.RecursiveType {\n")
	fmt.Fprintf(buf, "this := &test.RecursiveType{}\n")
	if this.Bytes != nil {
		fmt.Fprintf(buf, "this.Bytes = %#v\n", this.Bytes)
	}
	if this.N != nil {
		fmt.Fprintf(buf, "this.N = %s\n", deriveGoString_55(this.N))
	}
	fmt.Fprintf(buf, "return *this\n")
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_M returns a recursive representation of this as a valid go string.
func deriveGoString_M(this MyEnum) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.MyEnum {\n")
	fmt.Fprintf(buf, "return %#v\n", this)
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_i returns a recursive representation of this as a valid go string.
func deriveGoString_i(this int32) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() int32 {\n")
	fmt.Fprintf(buf, "return %#v\n", this)
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_My returns a recursive representation of this as a valid go string.
func deriveGoString_My(this MySlice) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() test.MySlice {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "return %#v\n", this)
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_D returns a recursive representation of this as a valid go string.
func deriveGoString_D(this time.Duration) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() time.Duration {\n")
	fmt.Fprintf(buf, "return %#v\n", this)
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveGoString_88 returns a recursive representation of this as a valid go string.
func deriveGoString_88(this []*pickle.Rick) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() []*pickle.Rick {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := make([]*pickle.Rick, %d)\n", len(this))
		for i := range this {
			fmt.Fprintf(buf, "this[%d] = %s\n", i, deriveGoString_89(this[i]))
		}
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveDeepCopy_55 recursively copies the contents of src into dst.
func deriveDeepCopy_55(dst, src []*pickle.Rick) {
	for src_i, src_value := range src {
		if src_value == nil {
			dst[src_i] = nil
		} else {
			dst[src_i] = new(pickle.Rick)
			*dst[src_i] = *src_value
		}
	}
}

// deriveCompare_s returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_s(this, that string) int {
	return strings.Compare(this, that)
}

// deriveCompare_139 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_139(this, that [4]int) int {
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_i(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_140 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_140(this, that map[int]int) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	thiskeys := deriveSortedInts(deriveKeys(this))
	thatkeys := deriveSortedInts(deriveKeys(that))
	for i, thiskey := range thiskeys {
		thatkey := thatkeys[i]
		if thiskey == thatkey {
			thisvalue := this[thiskey]
			thatvalue := that[thatkey]
			if c := deriveCompare_i(thisvalue, thatvalue); c != 0 {
				return c
			}
		} else {
			if c := deriveCompare_i(thiskey, thatkey); c != 0 {
				return c
			}
		}
	}
	return 0
}

// deriveCompare_141 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_141(this, that []*pickle.Rick) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if len(this) != len(that) {
		if len(this) < len(that) {
			return -1
		}
		return 1
	}
	for i := 0; i < len(this); i++ {
		if c := deriveCompare_142(this[i], that[i]); c != 0 {
			return c
		}
	}
	return 0
}

// deriveCompare_N returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_N(this, that Name) int {
	return (&this).Compare(&that)
}

// deriveCompare_S returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_S(this, that StructWithoutMethod) int {
	return deriveCompare_107(&this, &that)
}

// deriveEqual_96 returns whether this and that are equal.
func deriveEqual_96(this, that []*pickle.Rick) bool {
	if this == nil || that == nil {
		return this == nil && that == nil
	}
	if len(this) != len(that) {
		return false
	}
	for i := 0; i < len(this); i++ {
		if !(deriveEqual_97(this[i], that[i])) {
			return false
		}
	}
	return true
}

// deriveHash_134 returns the hash of the object.
func deriveHash_134(object [4]int) uint64 {
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + uint64(object[i])
	}
	return h
}

// deriveHash_R returns the hash of the object.
func deriveHash_R(object RecursiveType) uint64 {
	return deriveHashRecursiveType(&object)
}

// deriveHash_135 returns the hash of the object.
func deriveHash_135(object []*pickle.Rick) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	for i := 0; i < len(object); i++ {
		h = 31*h + deriveHash_137(object[i])
	}
	return h
}

// deriveHash_136 returns the hash of the object.
func deriveHash_136(object *privateStruct) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHashPtrToint(object.ptrfield)
	return h
}

// deriveGoString_89 returns a recursive representation of this as a valid go string.
func deriveGoString_89(this *pickle.Rick) string {
	buf := bytes.NewBuffer(nil)
	fmt.Fprintf(buf, "func() *pickle.Rick {\n")
	if this == nil {
		fmt.Fprintf(buf, "return nil\n")
	} else {
		fmt.Fprintf(buf, "this := &pickle.Rick{}\n")
		fmt.Fprintf(buf, "this.Portal = %#v\n", this.Portal)
		fmt.Fprintf(buf, "return this\n")
	}
	fmt.Fprintf(buf, "}()\n")
	return buf.String()
}

// deriveCompare_142 returns:
//   - 0 if this and that are equal,
//   - -1 is this is smaller and
//   - +1 is this is bigger.
func deriveCompare_142(this, that *pickle.Rick) int {
	if this == nil {
		if that == nil {
			return 0
		}
		return -1
	}
	if that == nil {
		return 1
	}
	if c := strings.Compare(this.Portal, that.Portal); c != 0 {
		return c
	}
	return 0
}

// deriveEqual_97 returns whether this and that are equal.
func deriveEqual_97(this, that *pickle.Rick) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Portal == that.Portal
}

// deriveHash_137 returns the hash of the object.
func deriveHash_137(object *pickle.Rick) uint64 {
	if object == nil {
		return 0
	}
	h := uint64(17)
	h = 31*h + deriveHash_s(object.Portal)
	return h
}
