func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&Ingress{},
		&IngressList{},
		&IngressClass{},
		&IngressClassList{},
	)
	// Add the watch version that applies
	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
	return nil
}

// Adds the list of known types to the given scheme.


func diffMaps(original, modified map[string]interface{}, schema LookupPatchMeta, diffOptions DiffOptions) (map[string]interface{}, error) {
	patch := map[string]interface{}{}

	// This will be used to build the $retainKeys directive sent in the patch
	retainKeysList := make([]interface{}, 0, len(modified))

	// Compare each value in the modified map against the value in the original map
	for key, modifiedValue := range modified {
		// Get the underlying type for pointers
		if diffOptions.BuildRetainKeysDirective && modifiedValue != nil {
			retainKeysList = append(retainKeysList, key)
		}

		originalValue, ok := original[key]
		if !ok {
			// Key was added, so add to patch
			if !diffOptions.IgnoreChangesAndAdditions {
				patch[key] = modifiedValue
			}
			continue
		}

		// The patch may have a patch directive
		// TODO: figure out if we need this. This shouldn't be needed by apply. When would the original map have patch directives in it?
		foundDirectiveMarker, err := handleDirectiveMarker(key, originalValue, modifiedValue, patch)
		if err != nil {
			return nil, err
		}
		if foundDirectiveMarker {
			continue
		}

		if reflect.TypeOf(originalValue) != reflect.TypeOf(modifiedValue) {
			// Types have changed, so add to patch
			if !diffOptions.IgnoreChangesAndAdditions {
				patch[key] = modifiedValue
			}
			continue
		}

		// Types are the same, so compare values
		switch originalValueTyped := originalValue.(type) {
		case map[string]interface{}:
			modifiedValueTyped := modifiedValue.(map[string]interface{})
			err = handleMapDiff(key, originalValueTyped, modifiedValueTyped, patch, schema, diffOptions)
		case []interface{}:
			modifiedValueTyped := modifiedValue.([]interface{})
			err = handleSliceDiff(key, originalValueTyped, modifiedValueTyped, patch, schema, diffOptions)
		default:
			replacePatchFieldIfNotEqual(key, originalValue, modifiedValue, patch, diffOptions)
		}
		if err != nil {
			return nil, err
		}
	}

	updatePatchIfMissing(original, modified, patch, diffOptions)
	// Insert the retainKeysList iff there are values present in the retainKeysList and
	// either of the following is true:
	// - the patch is not empty
	// - there are additional field in original that need to be cleared
	if len(retainKeysList) > 0 &&
		(len(patch) > 0 || hasAdditionalNewField(original, modified)) {
		patch[retainKeysDirective] = sortScalars(retainKeysList)
	}
	return patch, nil
}

// Returns a (recursive) strategic merge patch that yields modified when applied to original.
// Including:
// - Adding fields to the patch present in modified, missing from original
// - Setting fields to the patch present in modified and original with different values
// - Delete fields present in original, missing from modified through
// - IFF map field - set to nil in patch
// - IFF list of maps && merge strategy - use deleteDirective for the elements
// - IFF list of primitives && merge strategy - use parallel deletion list
// - IFF list of maps or primitives with replace strategy (default) - set patch value to the value in modified
// - Build $retainKeys directive for fields with retainKeys patch strategy


func ExtractReplicaSet(replicaSet *extensionsv1beta1.ReplicaSet, fieldManager string) (*ReplicaSetApplyConfiguration, error) {
	return extractReplicaSet(replicaSet, fieldManager, "")
}

// ExtractReplicaSet extracts the applied configuration owned by fieldManager from
// replicaSet. If no managedFields are found in replicaSet for fieldManager, a
// ReplicaSetApplyConfiguration is returned with only the Name, Namespace (if applicable),
// APIVersion and Kind populated. It is possible that no managed fields were found for because other
// field managers have taken ownership of all the fields previously owned by fieldManager, or because
// the fieldManager never owned fields any fields.
// replicaSet must be a unmodified ReplicaSet API object that was retrieved from the Kubernetes API.
// ExtractReplicaSet provides a way to perform a extract/modify-in-place/apply workflow.
// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously
// applied if another fieldManager has updated or force applied any of the previously applied fields.
// Experimental!


func (r *Ref) IsValidURI(basepaths ...string) bool {
	if r.String() == "" {
		return true
	}

	v := r.RemoteURI()
	if v == "" {
		return true
	}

	if r.HasFullURL {
		rr, err := http.Get(v)
		if err != nil {
			return false
		}

		return rr.StatusCode/100 == 2
	}

	if !(r.HasFileScheme || r.HasFullFilePath || r.HasURLPathOnly) {
		return false
	}

	// check for local file
	pth := v
	if r.HasURLPathOnly {
		base := "."
		if len(basepaths) > 0 {
			base = filepath.Dir(filepath.Join(basepaths...))
		}
		p, e := filepath.Abs(filepath.ToSlash(filepath.Join(base, pth)))
		if e != nil {
			return false
		}
		pth = p
	}

	fi, err := os.Stat(filepath.ToSlash(pth))
	if err != nil {
		return false
	}

	return !fi.IsDir()
}

// IsValidURI returns true when the url the ref points to can be found


func MultiMutatingHandler(handlers ...Handler) Handler {
	return multiMutating(handlers)
}

// MultiMutatingHandler combines multiple mutating webhook handlers into a single
// mutating webhook handler.  Handlers are called in sequential order, and the first
// `allowed: false`	response may short-circuit the rest.  Users must take care to
// ensure patches are disjoint.


func fileExists(filePath string) bool {
	if _, err := os.Stat(filePath); err != nil {
		if os.IsNotExist(err) {
			return false
		}
	}

	return true
}

// fileExists reports whether the named file or directory exists.


func (u userPrivateInfoDo) Save(values ...*model.UserPrivateInfo) error {
	if len(values) == 0 {
		return nil
	}
	return u.DO.Save(values)
}

// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)


func NewDBPathsFromData(paths []string, target_sizes []uint64) []*DBPath {
	dbpaths := make([]*DBPath, len(paths))
	for i, path := range paths {
		targetSize := target_sizes[i]
		dbpaths[i] = NewDBPath(path, targetSize)
	}

	return dbpaths
}

// NewDBPathsFromData creates a slice with allocated DBPath objects
// from paths and target_sizes.


func isNewline(lg lineGroup) bool {
	return len(lg.comment) == 0 && len(lg.lines) == 1 && strings.TrimSpace(lg.lines[0]) == ""
}

// isNewline determines if lg is just an empty line.


func (m *Fixed32NotIn) Validate() error {
	return m.validate(false)
}

// Validate checks the field values on Fixed32NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the first
// error encountered is returned, or nil if there are no violations.


func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
	dst := make(map[string]time.Time)
	for k, val := range src {
		if val != nil {
			dst[k] = *val
		}
	}
	return dst
}

// TimeValueMap converts a string map of time.Time pointers into a string
// map of time.Time values


func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
	fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
}

// RegisterFieldEncoder register TypeEncoder for a struct field


func (b *Buffer) Size() int {
	size := len(b.Buf)
	for _, buf := range b.bufs {
		size += len(buf)
	}
	return size
}

// Size computes the size of a buffer by adding sizes of every chunk.


func socket(domain int, typ int, proto int) (fd int, err error) {
	r0, er := C.socket(C.int(domain), C.int(typ), C.int(proto))
	fd = int(r0)
	if r0 == -1 && er != nil {
		err = er
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
	_, _, e1 := Syscall6(SYS_FADVISE64, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Utime(path string, buf *Utimbuf) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	_, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func IoctlGetPtmget(fd int, req uint) (*Ptmget, error) {
	var value Ptmget
	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
	return &value, err
}

//sys	ioctl(fd int, req uint, arg uintptr) (err error)
//sys	ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL
//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL


func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
	r0, _, e1 := syscall_rawSyscall(libc_getgroups_trampoline_addr, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	n = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
	_, _, e1 := Syscall9(SYS_POSIX_FADVISE, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32), uintptr(advice), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func (t *bidiTrie) lookupValue(n uint32, b byte) uint8 {
	switch {
	default:
		return uint8(bidiValues[n<<6+uint32(b)])
	}
}

// lookupValue determines the type of block n and looks up the value for b.


func (e *Encoder) Snapshot() encoderState {
	return e.encoderState
}

// Snapshot returns the current snapshot for use in Reset.


func MustParse(str string) Quantity {
	q, err := ParseQuantity(str)
	if err != nil {
		panic(fmt.Errorf("cannot parse '%v': %v", str, err))
	}
	return q
}

// MustParse turns the given string into a quantity or panics; for tests
// or other cases where you know the string is valid.


func RollingUpdateDeployment() *RollingUpdateDeploymentApplyConfiguration {
	return &RollingUpdateDeploymentApplyConfiguration{}
}

// RollingUpdateDeploymentApplyConfiguration constructs a declarative configuration of the RollingUpdateDeployment type for use with
// apply.


func IngressTLS() *IngressTLSApplyConfiguration {
	return &IngressTLSApplyConfiguration{}
}

// IngressTLSApplyConfiguration constructs a declarative configuration of the IngressTLS type for use with
// apply.


func ExtractResourceSliceStatus(resourceSlice *resourcev1alpha3.ResourceSlice, fieldManager string) (*ResourceSliceApplyConfiguration, error) {
	return extractResourceSlice(resourceSlice, fieldManager, "status")
}

// ExtractResourceSliceStatus is the same as ExtractResourceSlice except
// that it extracts the status subresource applied configuration.
// Experimental!


func CreatedAtIn(vs ...time.Time) predicate.Integration {
	return predicate.Integration(sql.FieldIn(FieldCreatedAt, vs...))
}

// CreatedAtIn applies the In predicate on the "created_at" field.


func AnyToInt(i any) (int, error) {
	v, err := AnyToInt64(i)
	if err != nil {
		return 0, err
	}

	// int 兼容32位和64位系统
	//if int64(int(v)) != v {
	//	return 0, ErrValOut
	//}

	return int(v), nil
}


func ChallengeBlocks(domain, keyAuth string) ([]byte, []byte, error) {
	// Compute the SHA-256 digest of the key authorization.
	zBytes := sha256.Sum256([]byte(keyAuth))

	value, err := asn1.Marshal(zBytes[:sha256.Size])
	if err != nil {
		return nil, nil, err
	}

	// Add the keyAuth digest as the acmeValidation-v1 extension
	// (marked as critical such that it won't be used by non-ACME software).
	// Reference: https://tools.ietf.org/html/draft-ietf-acme-tls-alpn-05#section-3
	extensions := []pkix.Extension{
		{
			Id:       idPeAcmeIdentifierV1,
			Critical: true,
			Value:    value,
		},
	}

	// Generate a new RSA key for the certificates.
	tempPrivateKey, err := certcrypto.GeneratePrivateKey(certcrypto.RSA2048)
	if err != nil {
		return nil, nil, err
	}

	rsaPrivateKey := tempPrivateKey.(*rsa.PrivateKey)

	// Generate the PEM certificate using the provided private key, domain, and extra extensions.
	tempCertPEM, err := certcrypto.GeneratePemCert(rsaPrivateKey, domain, extensions)
	if err != nil {
		return nil, nil, err
	}

	// Encode the private key into a PEM format. We'll need to use it to generate the x509 keypair.
	rsaPrivatePEM := certcrypto.PEMEncode(rsaPrivateKey)

	return tempCertPEM, rsaPrivatePEM, nil
}

// ChallengeBlocks returns PEM blocks (certPEMBlock, keyPEMBlock) with the acmeValidation-v1 extension
// and domain name for the `tls-alpn-01` challenge.


func callgetsystemcfg(label int) (r1 uintptr, e1 Errno) {
	r1 = uintptr(C.getsystemcfg(C.int(label)))
	e1 = syscall.GetErrno()
	return
}


func ExtattrListFile(file string, attrnamespace int, data uintptr, nbytes int) (ret int, err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(file)
	if err != nil {
		return
	}
	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
	ret = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Setrlimit(resource int, rlim *Rlimit) (err error) {
	_, e1 := callsetrlimit(resource, uintptr(unsafe.Pointer(rlim)))
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func ExtattrGetFd(fd int, attrnamespace int, attrname string, data uintptr, nbytes int) (ret int, err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(attrname)
	if err != nil {
		return
	}
	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
	ret = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Access(path string, mode uint32) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Kill(pid int, signum syscall.Signal) (err error) {
	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func ExtattrListFd(fd int, attrnamespace int, data uintptr, nbytes int) (ret int, err error) {
	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
	ret = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func callfchown(fd int, uid int, gid int) (r1 uintptr, e1 Errno) {
	r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_fchown)), 3, uintptr(fd), uintptr(uid), uintptr(gid), 0, 0, 0)
	return
}


func KeyctlString(cmd int, id int) (string, error) {
	// We must loop as the string data may change in between the syscalls.
	// We could allocate a large buffer here to reduce the chance that the
	// syscall needs to be called twice; however, this is unnecessary as
	// the performance loss is negligible.
	var buffer []byte
	for {
		// Try to fill the buffer with data
		length, err := KeyctlBuffer(cmd, id, buffer, 0)
		if err != nil {
			return "", err
		}

		// Check if the data was written
		if length <= len(buffer) {
			// Exclude the null terminator
			return string(buffer[:length-1]), nil
		}

		// Make a bigger buffer if needed
		buffer = make([]byte, length)
	}
}

// Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html)
// KeyctlInt calls keyctl commands in which each argument is an int.
// These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK,
// KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT,
// KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT,
// KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT.
//sys	KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL
// KeyctlBuffer calls keyctl commands in which the third and fourth
// arguments are a buffer and its length, respectively.
// These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE.
//sys	KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL
// KeyctlString calls keyctl commands which return a string.
// These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY.


func NewError(reason string) *Error {
	return &Error{reason: reason}
}


func (f *FlagSet) Changed(name string) bool {
	flag := f.Lookup(name)
	// If a flag doesn't exist, it wasn't changed....
	if flag == nil {
		return false
	}
	return flag.Changed
}

// Changed returns true if the flag was explicitly set during Parse() and false
// otherwise


func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func pread(fd int, p []byte, offset int64) (n int, err error) {
	var _p0 unsafe.Pointer
	if len(p) > 0 {
		_p0 = unsafe.Pointer(&p[0])
	} else {
		_p0 = unsafe.Pointer(&_zero)
	}
	r0, _, e1 := syscall_syscall6(libc_pread_trampoline_addr, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32))
	n = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

//go:cgo_import_dynamic libc_pathconf pathconf "libc.so"
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func Access(path string, mode uint32) (err error) {
	return Faccessat(AT_FDCWD, path, mode, 0)
}


func Sync() {
	SyscallNoError(SYS_SYNC, 0, 0, 0)
	return
}


func (m *FeedbackSummarizationsReactionsMutation) FieldCleared(name string) bool {
	_, ok := m.clearedFields[name]
	return ok
}

// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.


func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	var _p1 *byte
	_p1, err = BytePtrFromString(link)
	if err != nil {
		return
	}
	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func mknodat(fd int, path string, mode uint32, dev int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	_, _, e1 := Syscall6(SYS_MKNODAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) {
	r0, _, e1 := Syscall6(SYS_TEE, uintptr(rfd), uintptr(wfd), uintptr(len), uintptr(flags), 0, 0)
	n = int64(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Fclonefileat(srcDirfd int, dstDirfd int, dst string, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(dst)
	if err != nil {
		return
	}
	_, _, e1 := syscall_syscall6(libc_fclonefileat_trampoline_addr, uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func Setresgid(rgid int, egid int, sgid int) (err error) {
	_, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid))
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error {
	// Under rare circumstances getting the descriptor might recursively
	// examine the registry, so fetch it before locking.
	//
	// A known case where this can happen: Fetching the TypeDescriptor for a
	// legacy ExtensionDesc can consult the global registry.
	xd := xt.TypeDescriptor()

	if r == GlobalTypes {
		globalMutex.Lock()
		defer globalMutex.Unlock()
	}

	field := xd.Number()
	message := xd.ContainingMessage().FullName()
	if prev := r.extensionsByMessage[message][field]; prev != nil {
		err := errors.New("extension number %d is already registered on message %v", field, message)
		err = amendErrorWithCaller(err, prev, xt)
		if !(r == GlobalTypes && ignoreConflict(xd, err)) {
			return err
		}
	}

	if err := r.register("extension", xd, xt); err != nil {
		return err
	}
	if r.extensionsByMessage == nil {
		r.extensionsByMessage = make(extensionsByMessage)
	}
	if r.extensionsByMessage[message] == nil {
		r.extensionsByMessage[message] = make(extensionsByNumber)
	}
	r.extensionsByMessage[message][field] = xt
	r.numExtensions++
	return nil
}

// RegisterExtension registers the provided extension type.
//
// If a naming conflict occurs, the type is not registered and an error is returned.


func (ev binlogEvent) NextPosition() uint32 {
	return binary.LittleEndian.Uint32(ev.Bytes()[13 : 13+4])
}

// NextPosition returns the nextPosition field from the header


func ConvertStateToMySQLErrorCode(state vterrors.State) string {
	s := getStateToMySQLState(state)
	return strconv.Itoa(s.num)
}

// ConvertStateToMySQLErrorCode returns MySQL error code for the given vterrors.State
// If the state is == 0, an empty string is returned


func checkTablesCount(t *testing.T, tablet *cluster.Vttablet, showTableName string, expectCount int) {
	query := fmt.Sprintf(`show tables like '%%%s%%';`, showTableName)
	queryResult, err := tablet.VttabletProcess.QueryTablet(query, keyspaceName, true)
	require.Nil(t, err)
	assert.Equal(t, expectCount, len(queryResult.Rows))
}

// checkTablesCount checks the number of tables in the given tablet


func (node *TruncateTable) GetToTables() TableNames {
	return nil
}

// GetToTables implements the DDLStatement interface


func (bs Bitset) AndNot(b2 Bitset) Bitset {
	if len(b2) == 0 {
		return bs
	}

	merged := make([]byte, len(bs))
	m := 0

	for m = 0; m < len(bs); m++ {
		if m < len(b2) {
			merged[m] = bs[m] & ^b2[m]
		} else {
			merged[m] = bs[m]
		}
	}
	for ; m > 0; m-- {
		if merged[m-1] != 0 {
			break
		}
	}
	return toBitset(merged[:m])
}

// AndNot returns the logical AND NOT of the two Bitsets as a new Bitset


func GenerateInsertStatement(qr *rules.Rule, ifNotExist bool) (string, error) {
	insertTemplate := getInsertSQLTemplate(ifNotExist)
	parsed := sqlparser.BuildParsedQuery(insertTemplate,
		":name",
		":description",
		":priority",
		":status",
		":plans",
		":fully_qualified_table_names",
		":query_regex",
		":query_template",
		":request_ip_regex",
		":user_regex",
		":leading_comment_regex",
		":trailing_comment_regex",
		":bind_var_conds",
		":action",
		":action_args",
	)
	bindVars, err := qr.ToBindVariable()
	if err != nil {
		return "", err
	}
	bound, err := parsed.GenerateQuery(bindVars, nil)
	return bound, err
}

// GenerateInsertStatement returns the SQL statement to insert the rule into the database.


func buildSelectColumnList(t *schema.Table) string {
	buf := sqlparser.NewTrackedBuffer(nil)
	for i, c := range t.MessageInfo.Fields {
		// Column names may have to be escaped.
		if i == 0 {
			buf.Myprintf("%v", sqlparser.NewIdentifierCI(c.Name))
		} else {
			buf.Myprintf(", %v", sqlparser.NewIdentifierCI(c.Name))
		}
	}
	return buf.String()
}

// buildSelectColumnList is a convenience function that
// builds a 'select' list for the user-defined columns.


func NewCollectedStatusLister(indexer cache.Indexer) CollectedStatusLister {
	return &collectedStatusLister{indexer: indexer}
}

// NewCollectedStatusLister returns a new CollectedStatusLister.


func Lstat(name string) (os.FileInfo, error) {
	defer updateOSMetrics(osMetricLstat, name)()
	return os.Lstat(name)
}

// Lstat captures time taken to call os.Lstat


func (sses3) ParseHTTP(h http.Header) error {
	if h.Get(xhttp.AmzServerSideEncryption) != xhttp.AmzEncryptionAES {
		return ErrInvalidEncryptionMethod
	}
	return nil
}

// ParseHTTP parses the SSE-S3 related HTTP headers and checks
// whether they contain valid values.


func (o *ClientFindSubEntry) GetFilteringEnabled() bool {
	if o == nil || o.FilteringEnabled == nil {
		var ret bool
		return ret
	}
	return *o.FilteringEnabled
}

// GetFilteringEnabled returns the FilteringEnabled field value if set, zero value otherwise.


func IsCRC32(str string) bool {
	return IsHash(str, "crc32")
}

// IsCRC32 checks is a string is a CRC32 hash. Alias for `IsHash(str, "crc32")`


func NewSignalChannel() (<-chan os.Signal, func()) {
	signalC := make(chan os.Signal, 1)
	signal.Notify(signalC, signals...)
	return signalC, func() {
		signal.Stop(signalC)
		close(signalC)
	}
}

// NewSignalChannel returns a new channel for interrupt signals.
//
// Call the returned function to cancel sending to this channel.


func (p *PortOpt) Set(value string) error {
	longSyntax, err := regexp.MatchString(`\w+=\w+(,\w+=\w+)*`, value)
	if err != nil {
		return err
	}
	if longSyntax {
		csvReader := csv.NewReader(strings.NewReader(value))
		fields, err := csvReader.Read()
		if err != nil {
			return err
		}

		pConfig := swarm.PortConfig{}
		for _, field := range fields {
			parts := strings.SplitN(field, "=", 2)
			if len(parts) != 2 {
				return fmt.Errorf("invalid field %s", field)
			}

			key := strings.ToLower(parts[0])
			value := strings.ToLower(parts[1])

			switch key {
			case portOptProtocol:
				if value != string(swarm.PortConfigProtocolTCP) && value != string(swarm.PortConfigProtocolUDP) && value != string(swarm.PortConfigProtocolSCTP) {
					return fmt.Errorf("invalid protocol value %s", value)
				}

				pConfig.Protocol = swarm.PortConfigProtocol(value)
			case portOptMode:
				if value != string(swarm.PortConfigPublishModeIngress) && value != string(swarm.PortConfigPublishModeHost) {
					return fmt.Errorf("invalid publish mode value %s", value)
				}

				pConfig.PublishMode = swarm.PortConfigPublishMode(value)
			case portOptTargetPort:
				tPort, err := strconv.ParseUint(value, 10, 16)
				if err != nil {
					return err
				}

				pConfig.TargetPort = uint32(tPort)
			case portOptPublishedPort:
				pPort, err := strconv.ParseUint(value, 10, 16)
				if err != nil {
					return err
				}

				pConfig.PublishedPort = uint32(pPort)
			default:
				return fmt.Errorf("invalid field key %s", key)
			}
		}

		if pConfig.TargetPort == 0 {
			return fmt.Errorf("missing mandatory field %q", portOptTargetPort)
		}

		if pConfig.PublishMode == "" {
			pConfig.PublishMode = swarm.PortConfigPublishModeIngress
		}

		if pConfig.Protocol == "" {
			pConfig.Protocol = swarm.PortConfigProtocolTCP
		}

		p.ports = append(p.ports, pConfig)
	} else {
		// short syntax
		portConfigs := []swarm.PortConfig{}
		ports, portBindingMap, err := nat.ParsePortSpecs([]string{value})
		if err != nil {
			return err
		}
		for _, portBindings := range portBindingMap {
			for _, portBinding := range portBindings {
				if portBinding.HostIP != "" {
					return fmt.Errorf("hostip is not supported")
				}
			}
		}

		for port := range ports {
			portConfig, err := ConvertPortToPortConfig(port, portBindingMap)
			if err != nil {
				return err
			}
			portConfigs = append(portConfigs, portConfig...)
		}
		p.ports = append(p.ports, portConfigs...)
	}
	return nil
}

// Set a new port value
// nolint: gocyclo


func IsDataLoss(err error) bool {
	_, ok := getImplementer(err).(ErrDataLoss)
	return ok
}

// IsDataLoss returns if the passed in error is an ErrDataLoss


func Marshal(v interface{}) ([]byte, error) {
	return marshal(v, false)
}

// Marshal returns the JSON encoding of v.
//
// Marshal traverses the value v recursively.
// If an encountered value implements the Marshaler interface
// and is not a nil pointer, Marshal calls its MarshalJSON method
// to produce JSON. If no MarshalJSON method is present but the
// value implements encoding.TextMarshaler instead, Marshal calls
// its MarshalText method.
// The nil pointer exception is not strictly necessary
// but mimics a similar, necessary exception in the behavior of
// UnmarshalJSON.
//
// Otherwise, Marshal uses the following type-dependent default encodings:
//
// Boolean values encode as JSON booleans.
//
// Floating point, integer, and Number values encode as JSON numbers.
//
// String values encode as JSON strings coerced to valid UTF-8,
// replacing invalid bytes with the Unicode replacement rune.
// The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e"
// to keep some browsers from misinterpreting JSON output as HTML.
// Ampersand "&" is also escaped to "\u0026" for the same reason.
//
// Array and slice values encode as JSON arrays, except that
// []byte encodes as a base64-encoded string, and a nil slice
// encodes as the null JSON object.
//
// Struct values encode as JSON objects. Each exported struct field
// becomes a member of the object unless
//   - the field's tag is "-", or
//   - the field is empty and its tag specifies the "omitempty" option.
// The empty values are false, 0, any
// nil pointer or interface value, and any array, slice, map, or string of
// length zero. The object's default key string is the struct field name
// but can be specified in the struct field's tag value. The "json" key in
// the struct field's tag value is the key name, followed by an optional comma
// and options. Examples:
//
//   // Field is ignored by this package.
//   Field int `json:"-"`
//
//   // Field appears in JSON as key "myName".
//   Field int `json:"myName"`
//
//   // Field appears in JSON as key "myName" and
//   // the field is omitted from the object if its value is empty,
//   // as defined above.
//   Field int `json:"myName,omitempty"`
//
//   // Field appears in JSON as key "Field" (the default), but
//   // the field is skipped if empty.
//   // Note the leading comma.
//   Field int `json:",omitempty"`
//
// The "string" option signals that a field is stored as JSON inside a
// JSON-encoded string. It applies only to fields of string, floating point,
// integer, or boolean types. This extra level of encoding is sometimes used
// when communicating with JavaScript programs:
//
//    Int64String int64 `json:",string"`
//
// The key name will be used if it's a non-empty string consisting of
// only Unicode letters, digits, dollar signs, percent signs, hyphens,
// underscores and slashes.
//
// Anonymous struct fields are usually marshaled as if their inner exported fields
// were fields in the outer struct, subject to the usual Go visibility rules amended
// as described in the next paragraph.
// An anonymous struct field with a name given in its JSON tag is treated as
// having that name, rather than being anonymous.
// An anonymous struct field of interface type is treated the same as having
// that type as its name, rather than being anonymous.
//
// The Go visibility rules for struct fields are amended for JSON when
// deciding which field to marshal or unmarshal. If there are
// multiple fields at the same level, and that level is the least
// nested (and would therefore be the nesting level selected by the
// usual Go rules), the following extra rules apply:
//
// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered,
// even if there are multiple untagged fields that would otherwise conflict.
// 2) If there is exactly one field (tagged or not according to the first rule), that is selected.
// 3) Otherwise there are multiple fields, and all are ignored; no error occurs.
//
// Handling of anonymous struct fields is new in Go 1.1.
// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of
// an anonymous struct field in both current and earlier versions, give the field
// a JSON tag of "-".
//
// Map values encode as JSON objects.
// The map's key type must be string; the map keys are used as JSON object
// keys, subject to the UTF-8 coercion described for string values above.
//
// Pointer values encode as the value pointed to.
// A nil pointer encodes as the null JSON object.
//
// Interface values encode as the value contained in the interface.
// A nil interface value encodes as the null JSON object.
//
// Channel, complex, and function values cannot be encoded in JSON.
// Attempting to encode such a value causes Marshal to return
// an UnsupportedTypeError.
//
// JSON cannot represent cyclic data structures and Marshal does not
// handle them.  Passing cyclic structures to Marshal will result in
// an infinite recursion.
//


func (c Continue) RandString() string {
	return randString(c.Rand)
}

// RandString makes a random string up to 20 characters long. The returned string
// may include a variety of (valid) UTF-8 encodings.


func FieldMaskFromRequestBody(r io.Reader, msg proto.Message) (*field_mask.FieldMask, error) {
	fm := &field_mask.FieldMask{}
	var root interface{}

	if err := json.NewDecoder(r).Decode(&root); err != nil {
		if err == io.EOF {
			return fm, nil
		}
		return nil, err
	}

	queue := []fieldMaskPathItem{{node: root, msg: msg.ProtoReflect()}}
	for len(queue) > 0 {
		// dequeue an item
		item := queue[0]
		queue = queue[1:]

		m, ok := item.node.(map[string]interface{})
		switch {
		case ok:
			// if the item is an object, then enqueue all of its children
			for k, v := range m {
				if item.msg == nil {
					return nil, errors.New("JSON structure did not match request type")
				}

				fd := getFieldByName(item.msg.Descriptor().Fields(), k)
				if fd == nil {
					return nil, fmt.Errorf("could not find field %q in %q", k, item.msg.Descriptor().FullName())
				}

				if isDynamicProtoMessage(fd.Message()) {
					for _, p := range buildPathsBlindly(string(fd.FullName().Name()), v) {
						newPath := p
						if item.path != "" {
							newPath = item.path + "." + newPath
						}
						queue = append(queue, fieldMaskPathItem{path: newPath})
					}
					continue
				}

				if isProtobufAnyMessage(fd.Message()) && !fd.IsList() {
					_, hasTypeField := v.(map[string]interface{})["@type"]
					if hasTypeField {
						queue = append(queue, fieldMaskPathItem{path: k})
						continue
					} else {
						return nil, fmt.Errorf("could not find field @type in %q in message %q", k, item.msg.Descriptor().FullName())
					}

				}

				child := fieldMaskPathItem{
					node: v,
				}
				if item.path == "" {
					child.path = string(fd.FullName().Name())
				} else {
					child.path = item.path + "." + string(fd.FullName().Name())
				}

				switch {
				case fd.IsList(), fd.IsMap():
					// As per: https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto#L85-L86
					// Do not recurse into repeated fields. The repeated field goes on the end of the path and we stop.
					fm.Paths = append(fm.Paths, child.path)
				case fd.Message() != nil:
					child.msg = item.msg.Get(fd).Message()
					fallthrough
				default:
					queue = append(queue, child)
				}
			}
		case len(item.path) > 0:
			// otherwise, it's a leaf node so print its path
			fm.Paths = append(fm.Paths, item.path)
		}
	}

	// Sort for deterministic output in the presence
	// of repeated fields.
	sort.Strings(fm.Paths)

	return fm, nil
}

// FieldMaskFromRequestBody creates a FieldMask printing all complete paths from the JSON body.


func (s *set) indexNL(key Key) int {
	for i, k := range s.keys {
		if k == key {
			return i
		}
	}
	return -1
}

// indexNL is Index(), but without the locking


func BiDirectional() InitOption {
	return func(g *Generator) { g.workflow = &onceWorkflow{workflow: &standardWorkflow{BiDi: true}} }
}

// BiDirectional instructs the Generator to build the AST graph in both
// directions (ie, accessing dependents of an entity, not just dependencies).


func DebugFn(fn LogFunction) {
	std.DebugFn(fn)
}

// DebugFn logs a message from a func at level Debug on the standard logger.


func Float64SliceVarP(p *[]float64, name, shorthand string, value []float64, usage string) {
	CommandLine.VarP(newFloat64SliceValue(value, p), name, shorthand, usage)
}

// Float64SliceVarP is like Float64SliceVar, but accepts a shorthand letter that can be used after a single dash.


func IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {
	CommandLine.VarP(newIPMaskValue(value, p), name, "", usage)
}

// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.
// The argument p points to an net.IPMask variable in which to store the value of the flag.


func filterSet(kvs []KeyValue, filter Filter) (Set, []KeyValue) {
	var excluded []KeyValue

	// Move attributes that do not match the filter so they're adjacent before
	// calling computeDistinct().
	distinctPosition := len(kvs)

	// Swap indistinct keys forward and distinct keys toward the
	// end of the slice.
	offset := len(kvs) - 1
	for ; offset >= 0; offset-- {
		if filter(kvs[offset]) {
			distinctPosition--
			kvs[offset], kvs[distinctPosition] = kvs[distinctPosition], kvs[offset]
			continue
		}
	}
	excluded = kvs[:distinctPosition]

	return Set{
		equivalent: computeDistinct(kvs[distinctPosition:]),
	}, excluded
}

// filterSet reorders kvs so that included keys are contiguous at the end of
// the slice, while excluded keys precede the included keys.


func ptracePtr(request int, pid int, addr unsafe.Pointer, data int) (err error) {
	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func pread(fd int, p []byte, offset int64) (n int, err error) {
	var _p0 unsafe.Pointer
	if len(p) > 0 {
		_p0 = unsafe.Pointer(&p[0])
	} else {
		_p0 = unsafe.Pointer(&_zero)
	}
	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0)
	n = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Getrlimit(resource int, rlim *Rlimit) (err error) {
	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func pread(fd int, p []byte, offset int64) (n int, err error) {
	var _p0 *byte
	if len(p) > 0 {
		_p0 = &p[0]
	}
	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procpread)), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(offset), 0, 0)
	n = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func (s *EnvSettings) Namespace() string {
	if ns, _, err := s.config.ToRawKubeConfigLoader().Namespace(); err == nil {
		return ns
	}
	return "default"
}

// Namespace gets the namespace from the configuration


func Resource(resource string) schema.GroupResource {
	return SchemeGroupVersion.WithResource(resource).GroupResource()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource


func RegisterDefaults(scheme *runtime.Scheme) error {
	scheme.AddTypeDefaultingFunc(&CustomResourceDefinition{}, func(obj interface{}) { SetObjectDefaults_CustomResourceDefinition(obj.(*CustomResourceDefinition)) })
	scheme.AddTypeDefaultingFunc(&CustomResourceDefinitionList{}, func(obj interface{}) {
		SetObjectDefaults_CustomResourceDefinitionList(obj.(*CustomResourceDefinitionList))
	})
	return nil
}

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.


func (r *Refable) UnmarshalJSON(d []byte) error {
	return json.Unmarshal(d, &r.Ref)
}

// UnmarshalJSON unmarshalss the ref from json


func (c *paramVerifyingSchema) ValidateBytes(data []byte) error {
	obj, err := schemavalidation.Parse(data)
	if err != nil {
		return err
	}

	gvk, errs := schemavalidation.GetObjectKind(obj)
	if errs != nil {
		return utilerrors.NewAggregate(errs)
	}

	err = c.verifier.HasSupport(gvk)
	if resource.IsParamUnsupportedError(err) {
		switch c.directive {
		case metav1.FieldValidationStrict:
			return c.schema.ValidateBytes(data)
		case metav1.FieldValidationWarn:
			klog.Warningf("cannot perform warn validation if server-side field validation is unsupported, skipping validation")
		default:
			// can't be reached
			klog.Warningf("unexpected field validation directive: %s, skipping validation", c.directive)
		}
		return nil
	}
	return err
}

// ValidateBytes validates bytes per a ParamVerifyingSchema


func GetNode(root *yaml.Node, path ...string) (*yaml.Node, bool, error) {
	resNode, restPath, err := asCloseAsPossible(root, path...)
	if err != nil {
		return nil, false, err
	}
	// more path means the node didn't exist
	if len(restPath) != 0 {
		return nil, false, nil
	}
	return resNode, true, nil
}

// GetNode gets the node at the given path in the given sequence of mapping
// nodes, or, if it doesn't exist, returning false.


func main() {
	x := Xenia{
		Host:    "localhost:8000",
		Timeout: time.Second,
	}

	p := Pillar{
		Host:    "localhost:9000",
		Timeout: time.Second,
	}

	if err := Copy(&x, &p, 3); err != io.EOF {
		fmt.Println(err)
	}
}


func (s *Server) Wait() error {

	// ΠΡΟΣΠΟΙΗΘΕΙΤΕ ΟΤΙ ΥΠΑΡΧΕΙ ΣΥΓΚΕΚΡΙΜΕΝΗ ΥΛΟΠΟΙΗΣΗ.
	return nil
}

// Η Wait αποτρέπει τον server να δεχτεί νέες συνδέσεις.


func sendNotification(n notifier) {
	n.notify()
}

// sendNotification accepts values that implement the notifier
// interface and sends notifications.


func (v PreciseVector) SmallestComponent() Axis {
	t := v.Abs()

	if t.X.Cmp(t.Y) < 0 {
		if t.X.Cmp(t.Z) < 0 {
			return XAxis
		}
		return ZAxis
	}
	if t.Y.Cmp(t.Z) < 0 {
		return YAxis
	}
	return ZAxis
}

// SmallestComponent returns the axis that represents the smallest component in this vector.


func CheckPath(path string) (err error) {
	defer func() {
		if err != nil {
			err = &InvalidPathError{Kind: "module", Path: path, Err: err}
		}
	}()

	if err := checkPath(path, modulePath); err != nil {
		return err
	}
	i := strings.Index(path, "/")
	if i < 0 {
		i = len(path)
	}
	if i == 0 {
		return fmt.Errorf("leading slash")
	}
	if !strings.Contains(path[:i], ".") {
		return fmt.Errorf("missing dot in first path element")
	}
	if path[0] == '-' {
		return fmt.Errorf("leading dash in first path element")
	}
	for _, r := range path[:i] {
		if !firstPathOK(r) {
			return fmt.Errorf("invalid char %q in first path element", r)
		}
	}
	if _, _, ok := SplitPathVersion(path); !ok {
		return fmt.Errorf("invalid version")
	}
	return nil
}

// CheckPath checks that a module path is valid.
// A valid module path is a valid import path, as checked by [CheckImportPath],
// with three additional constraints.
// First, the leading path element (up to the first slash, if any),
// by convention a domain name, must contain only lower-case ASCII letters,
// ASCII digits, dots (U+002E), and dashes (U+002D);
// it must contain at least one dot and cannot start with a dash.
// Second, for a final path element of the form /vN, where N looks numeric
// (ASCII digits and dots) must not begin with a leading zero, must not be /v1,
// and must not contain any dots. For paths beginning with "gopkg.in/",
// this second requirement is replaced by a requirement that the path
// follow the gopkg.in server's conventions.
// Third, no path element may begin with a dot.


func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	fd = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}


func Setrtable(rtable int) (err error) {
	_, _, e1 := syscall_rawSyscall(libc_setrtable_trampoline_addr, uintptr(rtable), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

//go:cgo_import_dynamic libc_setresuid setresuid "libc.so"
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	_, _, e1 := syscall_syscall6(libc_faccessat_trampoline_addr, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT


func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
	if wtyp != protowire.Fixed32Type {
		return out, errUnknown
	}
	v, n := protowire.ConsumeFixed32(b)
	if n < 0 {
		return out, errDecode
	}
	vp := p.Uint32Ptr()
	if *vp == nil {
		*vp = new(uint32)
	}
	**vp = v
	out.n = n
	return out, nil
}

// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.


func (_ *RESTProvider) ReregisterEntity(
	_ context.Context, _ minderv1.Entity, _ *properties.Properties,
) error {
	// TODO: implement
	return nil
}

// ReregisterEntity implements the Provider interface


func GetNiceStatus(code codes.Code) *NiceStatus {
	s := &NiceStatus{}
	return s.SetCode(code)
}

// GetNiceStatus get a nice status from the code.


func (p *PPU) nameTableIdx(addr uint16) uint {
	var (
		idx  = (addr - 0x2000) / 0x0400
		mode = p.cart.MirrorMode()
	)

	switch mode {
	case ines.MirrorHorizontal:
		switch idx {
		case 0, 1:
			return 0
		default:
			return 1
		}
	case ines.MirrorVertical:
		switch idx {
		case 0, 2:
			return 0
		default:
			return 1
		}
	case ines.MirrorSingle0:
		return 0
	case ines.MirrorSingle1:
		return 1
	default:
		panic(fmt.Sprintf("invalid mirroring mode: %d", mode))
	}
}

// nameTableIdx returns the index of the nametable (0 or 1) for the given vram
// address, based on the cartridge’s mirroring mode.


func TestSystem(t *testing.T, makeSystem MakeSystem) {
	t.Run("file", file.runFunc(makeSystem))
	t.Run("proc", proc.runFunc(makeSystem))
	t.Run("poll", poll.runFunc(makeSystem))
	t.Run("socket", socket.runFunc(makeSystem))
}

// TestSystem is a test suite which validates the behavior of wasi.System
// implementations.


func (c *constraints) AddReservation(p peer.ID, a ma.Multiaddr) error {
	c.mutex.Lock()

	now := time.Now()
	c.cleanup(now)

	if len(c.total) >= c.rc.MaxReservations {
		c.mutex.Unlock()
		return errTooManyReservations
	}

	ip, err := manet.ToIP(a)
	if err != nil {
		c.mutex.Unlock()
		return errors.New("no IP address associated with peer")
	}

	peerReservations := c.peers[p]
	if len(peerReservations) >= c.rc.MaxReservationsPerPeer {
		c.mutex.Unlock()
		return errTooManyReservationsForPeer
	}

	ipReservations := c.ips[ip.String()]
	if len(ipReservations) >= c.rc.MaxReservationsPerIP {
		c.mutex.Unlock()
		return errTooManyReservationsForIP
	}

	var asnReservations []time.Time
	var asn uint32
	if ip.To4() == nil {
		asn = asnutil.AsnForIPv6(ip)
		if asn != 0 {
			asnReservations = c.asns[asn]
			if len(asnReservations) >= c.rc.MaxReservationsPerASN {
				c.mutex.Unlock()
				return errTooManyReservationsForASN
			}
		}
	}

	expiry := now.Add(validity)
	c.total = append(c.total, expiry)

	peerReservations = append(peerReservations, expiry)
	c.peers[p] = peerReservations

	ipReservations = append(ipReservations, expiry)
	c.ips[ip.String()] = ipReservations

	if asn != 0 {
		asnReservations = append(asnReservations, expiry)
		c.asns[asn] = asnReservations
	}
	c.mutex.Unlock()
	return nil
}

// AddReservation adds a reservation for a given peer with a given multiaddr.
// If adding this reservation violates IP constraints, an error is returned.


func (set *IdSet) Delete(atom Atom) bool {
	switch a := atom.(type) {
	case *Vertex:
		if _, exists := set.atoms[a.GetID()]; exists {
			delete(set.atoms, a.GetID())
			return true
		}
	case *Hyperedge:
		if _, exists := set.atoms[a.GetID()]; exists {
			delete(set.atoms, a.GetID())
			return true
		}
	}
	return false
}

// Delete removes an atom from the IdSet and returns true if the atom was
// present.


func WithReason(ctx context.Context, reason Reason) context.Context {
	info := infoFromCtx(ctx)
	info.reason = reason
	return withInfo(ctx, info)
}

// WithReason creates a context that has an associated Reason (which ends up in
// traces created under that context).


public ListNode getMid(ListNode head) {
        ListNode slow = head, fast = head.next;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

/**
     * Find middle with usage slow and fast pointers
     */


@GetMapping(value = "/index")
    public String index(HttpServletRequest httpRequest, HttpSession session, Model model) {
        return "system/index";
    }

/**
     * 跳转到浪海博客后台管理首页
     *
     * @return 后台管理首页页面 system/index.html
     */


public ArrayList<Setting> getSettingList() {
        return settingList;
    }

/**
     * @return Returns an Arraylist of all settings
     */


public void writeBytes(byte []buffer, int offset, int length)
    throws IOException
  {
    if (buffer == null) {
      print("<null></null>");
    }
    else {
      print("<base64>");

      int i = 0;
      for (; i + 2 < length; i += 3) {
        if (i != 0 && (i & 0x3f) == 0)
          print('\n');

        int v = (((buffer[offset + i] & 0xff) << 16) +
                 ((buffer[offset + i + 1] & 0xff) << 8) +
                 (buffer[offset + i + 2] & 0xff));

        print(encode(v >> 18));
        print(encode(v >> 12));
        print(encode(v >> 6));
        print(encode(v));
      }

      if (i + 1 < length) {
        int v = (((buffer[offset + i] & 0xff) << 8) +
                 (buffer[offset + i + 1] & 0xff));

        print(encode(v >> 10));
        print(encode(v >> 4));
        print(encode(v << 2));
        print('=');
      }
      else if (i < length) {
        int v = buffer[offset + i] & 0xff;

        print(encode(v >> 2));
        print(encode(v << 4));
        print('=');
        print('=');
      }

      print("</base64>");
    }
  }

/**
   * Writes a byte array to the stream.
   * The array will be written with the following syntax:
   *
   *

   * <base64>bytes</base64>
   *

   *
   * If the value is null, it will be written as
   *
   *

   * <null></null>
   *

   *
   * @param value the string value to write.
   */


public void reset()
  {
    if (_refs != null) {
      _refs.clear();
      _refCount = 0;
    }

    _classRefs.clear();
    _typeRefs = null;
    _offset = 0;
    _isPacket = false;
    _isUnshared = false;
  }

/**
   * Resets all counters and references
   */


public void writeInt(int value)
    throws IOException
  {
    os.write('I');
    os.write(value >> 24);
    os.write(value >> 16);
    os.write(value >> 8);
    os.write(value);
  }

/**
   * Writes an integer value to the stream.  The integer will be written
   * with the following syntax:
   *
   *

   * I b32 b24 b16 b8
   *

   *
   * @param value the integer value to write.
   */


public byte getAlgorithm() {
        return algorithm;
    }

/**
     * Get Algorithm tag.
     *
     * @return algorithm - The algorithm tag of crypto operation.
     */


public Builder clearLiveId() {
      bitField0_ = (bitField0_ & ~0x00000080);
      liveId_ = 0L;
      onChanged();
      return this;
    }

/**
     * int64 live_id = 14;
     * @return This builder for chaining.
     */


public cool.scx.live_room_watcher.impl.douyin_hack.proto_entity.webcast.data.GiftStructOrBuilder getGiftOrBuilder() {
      if (giftBuilder_ != null) {
        return giftBuilder_.getMessageOrBuilder();
      } else {
        return gift_ == null ?
            cool.scx.live_room_watcher.impl.douyin_hack.proto_entity.webcast.data.GiftStruct.getDefaultInstance() : gift_;
      }
    }

/**
     * <code>.GiftStruct gift = 15;</code>
     */


public Builder addAllMessages(
        java.lang.Iterable<? extends cool.scx.live_room_watcher.impl.douyin_hack.proto_entity.webcast.im.Message> values) {
      if (messagesBuilder_ == null) {
        ensureMessagesIsMutable();
        com.google.protobuf.AbstractMessageLite.Builder.addAll(
            values, messages_);
        onChanged();
      } else {
        messagesBuilder_.addAllMessages(values);
      }
      return this;
    }

/**
     * repeated .Message messages = 1;
     */


@java.lang.Override
    public boolean hasUser() {
      return ((bitField0_ & 0x00000001) != 0);
    }

/**
     * <code>.User user = 1;</code>
     * @return Whether the user field is set.
     */


public com.google.protobuf.ByteString
          getScoreStrBytes() {
        java.lang.Object ref = scoreStr_;
        if (ref instanceof String) {
          com.google.protobuf.ByteString b =
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          scoreStr_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }

/**
       * string score_str = 2;
       * @return The bytes for scoreStr.
       */


@java.lang.Override
  public java.lang.String getName() {
    java.lang.Object ref = name_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs =
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      name_ = s;
      return s;
    }
  }

/**
   * string name = 16;
   * @return The name.
   */


@java.lang.Override
  public cool.scx.live_room_watcher.impl.tiktok_hack.proto_entity.webcast.im.ChatMessage.EmoteWithIndex getEmotesList(int index) {
    return emotesList_.get(index);
  }

/**
   * repeated .tiktok_hack.ChatMessage.EmoteWithIndex emotesList = 13;
   */


@java.lang.Override
  public cool.scx.live_room_watcher.impl.tiktok_hack.proto_entity.webcast.data.LiveMessageID getDependId() {
    return dependId_ == null ? cool.scx.live_room_watcher.impl.tiktok_hack.proto_entity.webcast.data.LiveMessageID.getDefaultInstance() : dependId_;
  }

/**
   * <code>.tiktok_hack.LiveMessageID dependId = 20;</code>
   * @return The dependId.
   */


public Builder setRoomMessageHeatLevel(
        java.lang.String value) {
      if (value == null) { throw new NullPointerException(); }
      roomMessageHeatLevel_ = value;
      bitField0_ |= 0x00200000;
      onChanged();
      return this;
    }

/**
     * string roomMessageHeatLevel = 22;
     * @param value The roomMessageHeatLevel to set.
     * @return This builder for chaining.
     */


@java.lang.Override
  public java.lang.String getEffectCnt() {
    java.lang.Object ref = effectCnt_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs =
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      effectCnt_ = s;
      return s;
    }
  }

/**
   * string effectCnt = 9;
   * @return The effectCnt.
   */


@java.lang.Override
  public cool.scx.live_room_watcher.impl.tiktok_hack.proto_entity.webcast.im.PublicAreaMessageCommonOrBuilder getPublicAreaMessageCommonOrBuilder() {
    return publicAreaMessageCommon_ == null ? cool.scx.live_room_watcher.impl.tiktok_hack.proto_entity.webcast.im.PublicAreaMessageCommon.getDefaultInstance() : publicAreaMessageCommon_;
  }

/**
   * <code>.tiktok_hack.PublicAreaMessageCommon publicAreaMessageCommon = 11;</code>
   */


public com.google.protobuf.ByteString
        getIsFirstBytes() {
      java.lang.Object ref = isFirst_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b =
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        isFirst_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }

/**
     * string isFirst = 11;
     * @return The bytes for isFirst.
     */


@PreAuthorize("@ss.hasPermi('system:role:query')")
    @GetMapping(value = "/{roleId}")
    public AjaxResult getInfo(@PathVariable Long roleId)
    {
        roleService.checkRoleDataScope(roleId);
        return AjaxResult.success(roleService.selectRoleById(roleId));
    }

/**
     * 根据角色编号获取详细信息
     */


@Override
    public void validateEdit(GenTable genTable) {
        if (GenConstants.TPL_TREE.equals(genTable.getTplCategory())) {
            String options = JSON.toJSONString(genTable.getParams());
            JSONObject paramsObj = JSONObject.parseObject(options);
            if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_CODE))) {
                throw new ServiceException("树编码字段不能为空");
            } else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_PARENT_CODE))) {
                throw new ServiceException("树父编码字段不能为空");
            } else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_NAME))) {
                throw new ServiceException("树名称字段不能为空");
            } else if (GenConstants.TPL_SUB.equals(genTable.getTplCategory())) {
                if (StringUtils.isEmpty(genTable.getSubTableName())) {
                    throw new ServiceException("关联子表的表名不能为空");
                } else if (StringUtils.isEmpty(genTable.getSubTableFkName())) {
                    throw new ServiceException("子表关联的外键名不能为空");
                }
            }
        }
    }

/**
     * 修改保存参数校验
     *
     * @param genTable 业务信息
     */


private static CelFunctionDecl sanitizeFunction(CelFunctionDecl func) {
    boolean needsSanitizing = false;
    for (CelOverloadDecl o : func.overloads()) {
      if (isWellKnownType(o.resultType())) {
        needsSanitizing = true;
        break;
      }
      for (CelType p : o.parameterTypes()) {
        if (isWellKnownType(p)) {
          needsSanitizing = true;
          break;
        }
      }
    }
    if (!needsSanitizing) {
      return func;
    }

    CelFunctionDecl.Builder funcBuilder = func.toBuilder();
    ImmutableSet.Builder<CelOverloadDecl> overloadsBuilder = new ImmutableSet.Builder<>();
    for (CelOverloadDecl overloadDecl : funcBuilder.overloads()) {
      CelOverloadDecl.Builder overloadBuilder = overloadDecl.toBuilder();
      CelType resultType = overloadBuilder.build().resultType();
      if (isWellKnownType(resultType)) {
        overloadBuilder.setResultType(getWellKnownType(resultType));
      }

      ImmutableList.Builder<CelType> parameterTypeBuilder = ImmutableList.builder();
      for (CelType paramType : overloadBuilder.parameterTypes()) {
        if (isWellKnownType(paramType)) {
          parameterTypeBuilder.add(getWellKnownType(paramType));
        } else {
          parameterTypeBuilder.add(paramType);
        }
      }
      overloadBuilder.setParameterTypes(parameterTypeBuilder.build());
      overloadsBuilder.add(overloadBuilder.build());
    }
    return funcBuilder.setOverloads(overloadsBuilder.build()).build();
  }

/**
   * Sanitize the function declaration type making sure that proto-based message names appearing in
   * the result or parameter types are mapped to the appropriate CEL types.
   */


@SuppressWarnings("DoNotCallSuggester")
  Object eval(CelAbstractSyntaxTree ast, Map<String, ?> parameterValues) {
    throw new UnsupportedOperationException("To be implemented");
  }

/**
   * Evaluates the compiled AST with the user provided parameter values.
   *
   * @throws IllegalArgumentException If the compiled expression in AST fails to evaluate.
   */


private static Optional<Integer> getLocationOffsetImpl(
      List<Integer> lineOffsets, int line, int column) {
    if (line <= 0 || column < 0) {
      return Optional.empty();
    }
    int offset = CelSourceHelper.findLineOffset(lineOffsets, line);
    if (offset == -1) {
      return Optional.empty();
    }
    return Optional.of(offset + column);
  }

/**
   * Get the code point offset within the source expression text that corresponds with the {@code
   * line} and {@code column}.
   *
   * @param line the line number starting from 1
   * @param column the column number starting from 0
   */


public ImmutableList<CelMap.Entry> getEntries() {
        return ImmutableList.copyOf(mutableEntries);
      }

/** Returns an immutable copy of the current mutable entries present in the builder. */


public final CelExpr fold(
      String iterVar,
      CelExpr.Builder iterRange,
      String accuVar,
      CelExpr accuInit,
      CelExpr.Builder condition,
      CelExpr step,
      CelExpr result) {
    return fold(iterVar, iterRange.build(), accuVar, accuInit, condition.build(), step, result);
  }

/** Fold creates a fold comprehension instruction. */


@GetMapping("/frame1")
    public String frame1()
    {
        return prefix + "/table/frame1";
    }


public static String getUploadPath()
    {
        return getProfile() + "/upload";
    }

/**
     * 获取上传路径
     */


public static String getIpAddr(HttpServletRequest request)
    {
        if (request == null)
        {
            return "unknown";
        }
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
        {
            ip = request.getRemoteAddr();
        }

        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
    }

/**
     * 获取客户端IP
     *
     * @param request 请求对象
     * @return IP地址
     */


public static int ZZ_CMAP(int ch) {
    return ZZ_CMAP_A[ZZ_CMAP_Y[ZZ_CMAP_Z[ch>>13]|((ch>>7)&0x3f)]|(ch&0x7f)];
  }

/**
   * Translates characters to character classes
   * Chosen bits are [8, 6, 7]
   * Total runtime size is 1040 bytes
   */


public static void populateKeyLookupTables() {
        for (int key = 0; key <= 255; key++) {
            getKeyName(key);
        }
    }

/** Populates the key name->index lookup table with the current keyboard layout based names. */


public static WaveData create(ByteBuffer buffer) {
        try {
            byte[] bytes = null;

            if (buffer.hasArray()) {
                bytes = buffer.array();
            } else {
                bytes = new byte[buffer.capacity()];
                buffer.get(bytes);
            }
            return create(bytes);
        } catch (Exception e) {
            org.lwjglx.LWJGLUtil.log("Unable to create from ByteBuffer, " + e.getMessage());
            return null;
        }
    }

/**
     * Creates a WaveData container from the specified ByetBuffer. If the buffer is backed by an array, it will be used
     * directly, else the contents of the buffer will be copied using get(byte[]).
     *
     * @param buffer ByteBuffer containing sound file
     * @return WaveData containing data, or null if a failure occured
     */


public Matrix invert() {
        return invert(this, this);
    }

/**
     * Invert this matrix
     *
     * @return this if successful, null otherwise
     */


public void viewImage(@NonNull Uri imageUri) {
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_VIEW);
        intent.setDataAndType(imageUri, "image/*");
        intent.setFlags(FLAG_GRANT_READ_URI_PERMISSION);
        try {
            getContext().startActivity(intent);
        } catch (ActivityNotFoundException e) {
            e.printStackTrace();
        }
    }

/**
     * Instantiates view intent to view an image in default image viewer
     *
     * @param imageUri The image {@link URI}, which is to be viewed
     */


@SuppressWarnings("unchecked")
    @Override
    protected Map<Object, Object> getSourcesFromContainer(Container<?> container, Collection<Target> targets) {
        Set<Object> keys = targets.stream()
            .map(Target::getKey)
            .map(k -> (Collection<?>)k)
            .flatMap(Collection::stream)
            .collect(Collectors.toSet());
        return (Map<Object, Object>)((Container<Object>)container).get(keys);
    }

/**
     * Obtain the corresponding data source object from the data source container based on the entity's key value.
     *
     * @param container container
     * @param targets   targets
     * @return source objects
     */


public Set<Class<?>> scan(String... basePackages) {
        return scan(Objects::nonNull, basePackages);
    }

/**
     * <p>Scan all classes under the specified package.
     *
     * @param basePackages the specified package
     * @return a set of classes
     */


public SwerveModuleState getState()
  {
    double     velocity;
    Rotation2d azimuth;
    if (!SwerveDriveTelemetry.isSimulation)
    {
      velocity = driveVelocityCache.getValue();
      azimuth = Rotation2d.fromDegrees(getAbsolutePosition());
    } else
    {
      return simModule.getState();
    }
    return new SwerveModuleState(velocity, azimuth);
  }

/**
   * Get the Swerve Module state.
   *
   * @return Current SwerveModule state.
   */


@Override
  public Object getAbsoluteEncoder()
  {
    return encoder;
  }

/**
   * Get the instantiated absolute encoder Object.
   *
   * @return Absolute encoder object.
   */


@Override
  public void factoryDefault()
  {
    imu.resetFactoryDefaults(STATUS_TIMEOUT_SECONDS);
  }

/**
   * Reset {@link Canandgyro} to factory default.
   */


@Test
    public void chatCompletionTokensTest() {
        ChatCompletion completion = ChatCompletion.builder().messages(messages).build();
        long tokens = completion.tokens();
        log.info("Message集合文本：【{}】", messages, tokens);
        log.info("总tokens数{}", tokens);
    }

/**
     * gpt-3.5和gpt4.0聊天模型接口计算推荐这种方法
     */


@Blocking
    @Nullable
    @Override
    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        checkMinimalStage();
        return cf.get(timeout, unit);
    }

/**
     * Waits if necessary for at most the given time for the computation to complete,
     * and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit    the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException    if the computation threw an exception
     * @throws InterruptedException  if the current thread was interrupted while waiting
     * @throws TimeoutException      if the wait timed out
     */


@Override
	public boolean isSameThan(__ptr__ other) {
		ST_subtree_t other2 = (ST_subtree_t) other;
		return this == other2;
	}


public DiagramType getDiagramType() {
		return DiagramType.getTypeFromArobaseStart(source.get(0).getString());
	}

/**
	 * Retrieve the type of the diagram. This is based on the first line
	 * <code>@startfoo</code>.
	 *
	 * @return the type of the diagram.
	 */


public JsonObject set(String name, double value) {
		set(name, Json.value(value));
		return this;
	}

/**
	 * Sets the value of the member with the specified name to the JSON
	 * representation of the specified double value. If this object
	 * does not contain a member with this name, a new member is added at the end of
	 * the object. If this object contains multiple members with this name, only the
	 * last one is changed.
	 *

	 * This method should only be used to modify existing objects.
	 * To fill a new object with members, the method add(name, value)
	 * should be preferred which is much faster (as it does not need to search for
	 * existing members).
	 *

	 *
	 * @param name  the name of the member to add
	 * @param value the value of the member to add
	 * @return the object itself, to enable method chaining
	 */


public boolean isShowProgressBar() {
    return mShowProgressBar;
  }

/**
   * if to show progress bar when image async loading/cropping is in progress.<br>
   * default: true, disable to provide custom progress bar UI.
   */


protected Stream<String> getLines(Path file) throws IOException {
        return Files.lines(file);
    }


public String getName() { return name; }

/**
     * @return The unique name of this capability, typically this is
     * the fully qualified class name for the target interface.
     */


public boolean isBooleanValue()
    {
        return ("true".equals(value.toLowerCase()) || "false".equals(value.toLowerCase()));
    }

/**
     * Checks if the current value held by this property is a valid boolean value.
     *
     * @return True if it is a boolean value
     */


@SideOnly(Side.CLIENT)
    public static IAnimationStateMachine load(IResourceManager manager, ResourceLocation location, ImmutableMap<String, ITimeValue> customParameters)
    {
        try (IResource resource = manager.getResource(location))
        {
            ClipResolver clipResolver = new ClipResolver();
            ParameterResolver parameterResolver = new ParameterResolver(customParameters);
            Clips.CommonClipTypeAdapterFactory.INSTANCE.setClipResolver(clipResolver);
            TimeValues.CommonTimeValueTypeAdapterFactory.INSTANCE.setValueResolver(parameterResolver);
            AnimationStateMachine asm = asmGson.fromJson(new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8), AnimationStateMachine.class);
            clipResolver.asm = asm;
            parameterResolver.asm = asm;
            asm.initialize();
            //String json = asmGson.toJson(asm);
            //System.out.println(location + ": " + json);
            return asm;
        }
        catch(IOException | JsonParseException e)
        {
            FMLLog.log.error("Exception loading Animation State Machine {}, skipping", location, e);
            return missing;
        }
        finally
        {
            Clips.CommonClipTypeAdapterFactory.INSTANCE.setClipResolver(null);
            TimeValues.CommonTimeValueTypeAdapterFactory.INSTANCE.setValueResolver(null);
        }
    }

/**
     * Load a new instance if AnimationStateMachine at specified location, with specified custom parameters.
     */


@Deprecated
    public static int getFuelValue(@Nonnull ItemStack itemStack)
    {
        return ForgeEventFactory.getItemBurnTime(itemStack);
    }

/**
     * @deprecated use {@link ForgeEventFactory#getItemBurnTime(ItemStack)}
     */


private static int get2Fold(int fold) {
        int ret = 2;
        while (ret < fold) {
            ret *= 2;
        }
        return ret;
    }

/**
     * Get the closest greater power of 2 to the fold number
     *
     * @param fold The target number
     * @return The power of 2
     */


public Matrix transpose() {
        return transpose(this);
    }

/**
     * Transpose this matrix
     *
     * @return this
     */


public final float getY() {
        return y;
    }


@Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.OAS_30)
                // 是否启用Swagger
                .enable(enabled)
                // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
                .apiInfo(apiInfo())
                // 设置哪些接口暴露给Swagger展示
                .select()
                // 扫描所有有注解的api，用这种方式更灵活
                .apis(RequestHandlerSelectors.withMethodAnnotation(Operation.class))
                // 扫描指定包中的swagger注解
                // .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger"))
                // 扫描所有 .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build()
                /* 设置安全模式，swagger可以设置访问token */
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }


public static Double toDouble(Object value) {
        return toDouble(value, null);
    }

/**
     * 转换为double

     * 如果给定的值为空，或者转换失败，返回默认值null

     * 转换失败不会报错
     *
     * @param value 被转换的值
     * @return 结果
     */


public static boolean ishttp(String link) {
        return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
    }

/**
     * 是否为http(s)://开头
     *
     * @param link 链接
     * @return 结果
     */


@Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {

        /** 本地文件上传路径 */
        registry.addResourceHandler(Constants.RESOURCE_PREFIX + "/**")
                .addResourceLocations("file:" + ConfigExpander.getFileProfile() + "/");

        /** swagger配置 */
        registry.addResourceHandler("/swagger-ui/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/springfox-swagger-ui/");
    }

/**
     * 映射到访问本地的资源文件
     *
     * @param registry
     */


public boolean execRequest(Request request, String code) throws Exception {
        if (StringUtils.isEmpty(code)) {
            return true;
        }
        InMemoryJavaCompiler memoryJavaCompiler = javac(prependPublicToCoolRequestScript(REQUEST_REGEX, code), REQUEST_CLASS);
        Class<?> requestClass = memoryJavaCompiler.getClassloader().loadClass(REQUEST_CLASS);
        return invokeRequest(requestClass, request);
    }

/**
     * 执行前置脚本
     *
     * @return 如果返回false，则表示被脚本拒绝执行
     */


public void set$vocabulary(String $vocabulary) {
        this.$vocabulary = $vocabulary;
    }


public XML getXml() {
        return xml;
    }

/**
     * returns the xml property from a Schema instance.
     *
     * @return XML xml
     **/


public static void isNull( Object object, String message) {
        if (object != null) {
            throw new IllegalArgumentException(message);
        }
    }

/**
     * Assert that an object is {@code null}.
     *
Assert.isNull(value, "The value must be null");

     * @param object the object to check
     * @param message the exception message to use if the assertion fails
     * @throws IllegalArgumentException if the object is not {@code null}
     */


@java.lang.Override
    public int getUnk3300BALCPHMFIBC() {
      return unk3300BALCPHMFIBC_;
    }

/**
       * uint32 Unk3300_BALCPHMFIBC = 1940;
       * @return The unk3300BALCPHMFIBC.
       */


@java.lang.Override
    public int getTargetType() {
      return targetType_;
    }

/**
       * uint32 targetType = 346;
       * @return The targetType.
       */


@java.lang.Override
    public emu.grasscutter.net.proto.AbilityStringOuterClass.AbilityString getKey() {
      return key_ == null ? emu.grasscutter.net.proto.AbilityStringOuterClass.AbilityString.getDefaultInstance() : key_;
    }

/**
     * <code>.AbilityString key = 7;</code>
     * @return The key.
     */


public emu.grasscutter.net.proto.AbilityStringOuterClass.AbilityString getKey() {
        if (keyBuilder_ == null) {
          return key_ == null ? emu.grasscutter.net.proto.AbilityStringOuterClass.AbilityString.getDefaultInstance() : key_;
        } else {
          return keyBuilder_.getMessage();
        }
      }

/**
       * <code>.AbilityString key = 7;</code>
       * @return The key.
       */


public Builder setPosition(
          emu.grasscutter.net.proto.VectorOuterClass.Vector.Builder builderForValue) {
        if (positionBuilder_ == null) {
          position_ = builderForValue.build();
          onChanged();
        } else {
          positionBuilder_.setMessage(builderForValue.build());
        }

        return this;
      }

/**
       * <code>.Vector position = 1;</code>
       */


public Builder clearFaceDir() {
        if (faceDirBuilder_ == null) {
          faceDir_ = null;
          onChanged();
        } else {
          faceDir_ = null;
          faceDirBuilder_ = null;
        }

        return this;
      }

/**
       * <code>.Vector face_dir = 5;</code>
       */


public emu.grasscutter.net.proto.VectorOuterClass.VectorOrBuilder getRegionCenterPosOrBuilder() {
        if (regionCenterPosBuilder_ != null) {
          return regionCenterPosBuilder_.getMessageOrBuilder();
        } else {
          return regionCenterPos_ == null ?
              emu.grasscutter.net.proto.VectorOuterClass.Vector.getDefaultInstance() : regionCenterPos_;
        }
      }

/**
       * <code>.Vector regionCenterPos = 13;</code>
       */


@java.lang.Override
    public int getWishProgress() {
      return wishProgress_;
    }

/**
       * uint32 wishProgress = 12;
       * @return The wishProgress.
       */


@java.lang.Override
    public boolean hasIntVal() {
      return mMJOJNNFGCNCase_ == 2;
    }

/**
     * int32 int_val = 2;
     * @return Whether the intVal field is set.
     */


public emu.grasscutter.net.proto.ExhibitionDisplayInfoOuterClass.ExhibitionDisplayInfo getCardList(int index) {
        if (cardListBuilder_ == null) {
          return cardList_.get(index);
        } else {
          return cardListBuilder_.getMessage(index);
        }
      }

/**
       * repeated .ExhibitionDisplayInfo cardList = 2;
       */


@java.lang.Override
    public int getNextAddTimestamp() {
      return nextAddTimestamp_;
    }

/**
       * uint32 nextAddTimestamp = 4;
       * @return The nextAddTimestamp.
       */


public emu.grasscutter.net.proto.WeaponOuterClass.Weapon.Builder getWeaponBuilder() {
        return getWeaponFieldBuilder().getBuilder();
      }

/**
       * <code>.Weapon weapon = 3;</code>
       */


public emu.grasscutter.net.proto.AbilitySyncStateInfoOuterClass.AbilitySyncStateInfo getWeaponAbilityInfo() {
        if (weaponAbilityInfoBuilder_ == null) {
          return weaponAbilityInfo_ == null ? emu.grasscutter.net.proto.AbilitySyncStateInfoOuterClass.AbilitySyncStateInfo.getDefaultInstance() : weaponAbilityInfo_;
        } else {
          return weaponAbilityInfoBuilder_.getMessage();
        }
      }

/**
       * <code>.AbilitySyncStateInfo weaponAbilityInfo = 6;</code>
       * @return The weaponAbilityInfo.
       */


public Builder clearMaterialId() {

        materialId_ = 0;
        onChanged();
        return this;
      }

/**
       * uint32 materialId = 10;
       * @return This builder for chaining.
       */


@java.lang.Override
    public java.util.List<java.lang.Integer>
        getRuneListList() {
      return runeList_;
    }

/**
     * repeated uint32 rune_list = 3;
     * @return A list containing the runeList.
     */


public Builder setContentCloseTime(int value) {

        contentCloseTime_ = value;
        onChanged();
        return this;
      }

/**
       * uint32 content_close_time = 11;
       * @param value The contentCloseTime to set.
       * @return This builder for chaining.
       */


public emu.grasscutter.net.proto.TreasureSeelieRegionDataOuterClass.TreasureSeelieRegionData.Builder getRegionDataListBuilder(
          int index) {
        return getRegionDataListFieldBuilder().getBuilder(index);
      }

/**
       * repeated .TreasureSeelieRegionData region_data_list = 6;
       */


public emu.grasscutter.net.proto.BounceConjuringChapterInfoOuterClass.BounceConjuringChapterInfo.Builder addChapterInfoListBuilder(
          int index) {
        return getChapterInfoListFieldBuilder().addBuilder(
            index, emu.grasscutter.net.proto.BounceConjuringChapterInfoOuterClass.BounceConjuringChapterInfo.getDefaultInstance());
      }

/**
       * repeated .BounceConjuringChapterInfo chapter_info_list = 15;
       */


public Builder addStageInfoList(
          int index, emu.grasscutter.net.proto.OMNAAMAIBOHOuterClass.OMNAAMAIBOH.Builder builderForValue) {
        if (stageInfoListBuilder_ == null) {
          ensureStageInfoListIsMutable();
          stageInfoList_.add(index, builderForValue.build());
          onChanged();
        } else {
          stageInfoListBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }

/**
       * repeated .OMNAAMAIBOH stageInfoList = 12;
       */


@java.lang.Override
    public int getProgress() {
      return progress_;
    }

/**
       * uint32 progress = 3;
       * @return The progress.
       */


public Builder setTeamList(
          int index, emu.grasscutter.net.proto.SumoTeamDataOuterClass.SumoTeamData value) {
        if (teamListBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureTeamListIsMutable();
          teamList_.set(index, value);
          onChanged();
        } else {
          teamListBuilder_.setMessage(index, value);
        }
        return this;
      }

/**
       * repeated .SumoTeamData team_list = 1;
       */


public Builder setRaceInfoList(
          int index, emu.grasscutter.net.proto.WinterCampRaceStageInfoOuterClass.WinterCampRaceStageInfo.Builder builderForValue) {
        if (raceInfoListBuilder_ == null) {
          ensureRaceInfoListIsMutable();
          raceInfoList_.set(index, builderForValue.build());
          onChanged();
        } else {
          raceInfoListBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }

/**
       * repeated .WinterCampRaceStageInfo raceInfoList = 5;
       */


public emu.grasscutter.net.proto.WinterCampStageInfoOuterClass.WinterCampStageInfo getExploreInfo() {
        if (exploreInfoBuilder_ == null) {
          return exploreInfo_ == null ? emu.grasscutter.net.proto.WinterCampStageInfoOuterClass.WinterCampStageInfo.getDefaultInstance() : exploreInfo_;
        } else {
          return exploreInfoBuilder_.getMessage();
        }
      }

/**
       * <code>.WinterCampStageInfo exploreInfo = 1;</code>
       * @return The exploreInfo.
       */


@java.lang.Override
    public int getUnk3300KFDGFFPJGJC() {
      return unk3300KFDGFFPJGJC_;
    }

/**
       * uint32 Unk3300_KFDGFFPJGJC = 4;
       * @return The unk3300KFDGFFPJGJC.
       */


public Builder setUnk3300KIOMJNHFMDE(boolean value) {

        unk3300KIOMJNHFMDE_ = value;
        onChanged();
        return this;
      }

/**
       * bool Unk3300_KIOMJNHFMDE = 11;
       * @param value The unk3300KIOMJNHFMDE to set.
       * @return This builder for chaining.
       */


public Builder setIsHasChange(boolean value) {

        isHasChange_ = value;
        onChanged();
        return this;
      }

/**
       * bool isHasChange = 3;
       * @param value The isHasChange to set.
       * @return This builder for chaining.
       */


@java.lang.Override
      public emu.grasscutter.net.proto.BonusInfoOuterClass.BonusInfoOrBuilder getBonusInfoOrBuilder() {
        if ((detailCase_ == 11) && (bonusInfoBuilder_ != null)) {
          return bonusInfoBuilder_.getMessageOrBuilder();
        } else {
          if (detailCase_ == 11) {
            return (emu.grasscutter.net.proto.BonusInfoOuterClass.BonusInfo) detail_;
          }
          return emu.grasscutter.net.proto.BonusInfoOuterClass.BonusInfo.getDefaultInstance();
        }
      }

/**
       * <code>.BonusInfo bonus_info = 11;</code>
       */


public Builder setDayIndex(int value) {

        dayIndex_ = value;
        onChanged();
        return this;
      }

/**
       * uint32 dayIndex = 8;
       * @param value The dayIndex to set.
       * @return This builder for chaining.
       */


public emu.grasscutter.net.proto.WinterCampRecvItemDataOuterClass.WinterCampRecvItemData getRecvItemData() {
        if (recvItemDataBuilder_ == null) {
          return recvItemData_ == null ? emu.grasscutter.net.proto.WinterCampRecvItemDataOuterClass.WinterCampRecvItemData.getDefaultInstance() : recvItemData_;
        } else {
          return recvItemDataBuilder_.getMessage();
        }
      }

/**
       * <code>.WinterCampRecvItemData recvItemData = 5;</code>
       * @return The recvItemData.
       */


public Builder setIsTruncated(boolean value) {

        isTruncated_ = value;
        onChanged();
        return this;
      }

/**
       * bool isTruncated = 8;
       * @param value The isTruncated to set.
       * @return This builder for chaining.
       */


public emu.grasscutter.net.proto.HomeFurnitureDataOuterClass.HomeFurnitureData.Builder addDeployFurniureListBuilder(
          int index) {
        return getDeployFurniureListFieldBuilder().addBuilder(
            index, emu.grasscutter.net.proto.HomeFurnitureDataOuterClass.HomeFurnitureData.getDefaultInstance());
      }

/**
       * repeated .HomeFurnitureData deployFurniureList = 15;
       */


@java.lang.Override
    public int getUid() {
      return uid_;
    }

/**
       * uint32 uid = 10;
       * @return The uid.
       */


public Builder clearIsOpen() {

        isOpen_ = false;
        onChanged();
        return this;
      }

/**
       * bool isOpen = 2;
       * @return This builder for chaining.
       */


@java.lang.Override
    public emu.grasscutter.net.proto.LuminanceStoneChallengeInfoOuterClass.LuminanceStoneChallengeInfoOrBuilder getLuminanceStoneChallengeInfoOrBuilder() {
      if (iKJIPGGMNBKCase_ == 142) {
         return (emu.grasscutter.net.proto.LuminanceStoneChallengeInfoOuterClass.LuminanceStoneChallengeInfo) iKJIPGGMNBK_;
      }
      return emu.grasscutter.net.proto.LuminanceStoneChallengeInfoOuterClass.LuminanceStoneChallengeInfo.getDefaultInstance();
    }

/**
     * <code>.LuminanceStoneChallengeInfo luminance_stone_challenge_info = 142;</code>
     */


public Builder mergeIrodoriInfo(emu.grasscutter.net.proto.IrodoriInfoOuterClass.IrodoriInfo value) {
        if (irodoriInfoBuilder_ == null) {
          if (iKJIPGGMNBKCase_ == 1014 &&
              iKJIPGGMNBK_ != emu.grasscutter.net.proto.IrodoriInfoOuterClass.IrodoriInfo.getDefaultInstance()) {
            iKJIPGGMNBK_ = emu.grasscutter.net.proto.IrodoriInfoOuterClass.IrodoriInfo.newBuilder((emu.grasscutter.net.proto.IrodoriInfoOuterClass.IrodoriInfo) iKJIPGGMNBK_)
                .mergeFrom(value).buildPartial();
          } else {
            iKJIPGGMNBK_ = value;
          }
          onChanged();
        } else {
          if (iKJIPGGMNBKCase_ == 1014) {
            irodoriInfoBuilder_.mergeFrom(value);
          }
          irodoriInfoBuilder_.setMessage(value);
        }
        iKJIPGGMNBKCase_ = 1014;
        return this;
      }

/**
       * <code>.IrodoriInfo irodori_info = 1014;</code>
       */


@java.lang.Override
    public emu.grasscutter.net.proto.FungusTrainingPoolPreviewDetailOuterClass.FungusTrainingPoolPreviewDetail getMonsterPoolPreviewList(int index) {
      return monsterPoolPreviewList_.get(index);
    }

/**
     * repeated .FungusTrainingPoolPreviewDetail monsterPoolPreviewList = 9;
     */


public Builder addDailyInfoList(
          int index, emu.grasscutter.net.proto.EffigyDailyInfoOuterClass.EffigyDailyInfo value) {
        if (dailyInfoListBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureDailyInfoListIsMutable();
          dailyInfoList_.add(index, value);
          onChanged();
        } else {
          dailyInfoListBuilder_.addMessage(index, value);
        }
        return this;
      }

/**
       * repeated .EffigyDailyInfo daily_info_list = 4;
       */


@java.lang.Override
    public int getBuyCount() {
      return buyCount_;
    }

/**
       * uint32 buyCount = 11;
       * @return The buyCount.
       */


@java.lang.Override
    public int getDifficultyId() {
      return difficultyId_;
    }

/**
       * uint32 difficulty_id = 3;
       * @return The difficultyId.
       */


public Builder setRetcode(int value) {

        retcode_ = value;
        onChanged();
        return this;
      }

/**
       * int32 retcode = 2;
       * @param value The retcode to set.
       * @return This builder for chaining.
       */


public Builder setRemainUidList(
          int index, int value) {
        ensureRemainUidListIsMutable();
        remainUidList_.setInt(index, value);
        onChanged();
        return this;
      }

/**
       * repeated uint32 remainUidList = 2;
       * @param index The index to set the value at.
       * @param value The remainUidList to set.
       * @return This builder for chaining.
       */


public Builder setUgcGuid(long value) {

        ugcGuid_ = value;
        onChanged();
        return this;
      }

/**
       * uint64 ugcGuid = 8;
       * @param value The ugcGuid to set.
       * @return This builder for chaining.
       */


public emu.grasscutter.net.proto.ProfilePictureOuterClass.ProfilePicture getProfilePicture() {
        if (profilePictureBuilder_ == null) {
          return profilePicture_ == null ? emu.grasscutter.net.proto.ProfilePictureOuterClass.ProfilePicture.getDefaultInstance() : profilePicture_;
        } else {
          return profilePictureBuilder_.getMessage();
        }
      }

/**
       * <code>.ProfilePicture profilePicture = 13;</code>
       * @return The profilePicture.
       */


public Builder setGadgetState(int value) {

        gadgetState_ = value;
        onChanged();
        return this;
      }

/**
       * uint32 gadgetState = 6;
       * @param value The gadgetState to set.
       * @return This builder for chaining.
       */


@java.lang.Override
    public emu.grasscutter.net.proto.StatueGadgetInfoOuterClass.StatueGadgetInfoOrBuilder getStatueGadgetOrBuilder() {
      if (contentCase_ == 19) {
         return (emu.grasscutter.net.proto.StatueGadgetInfoOuterClass.StatueGadgetInfo) content_;
      }
      return emu.grasscutter.net.proto.StatueGadgetInfoOuterClass.StatueGadgetInfo.getDefaultInstance();
    }

/**
     * <code>.StatueGadgetInfo statue_gadget = 19;</code>
     */


public Builder setPhotoInfo(emu.grasscutter.net.proto.GravenInnocencePhotoInfoOuterClass.GravenInnocencePhotoInfo value) {
        if (photoInfoBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          photoInfo_ = value;
          onChanged();
        } else {
          photoInfoBuilder_.setMessage(value);
        }

        return this;
      }

/**
       * <code>.GravenInnocencePhotoInfo photo_info = 10;</code>
       */


public Builder setPhotoInfo(
          emu.grasscutter.net.proto.GravenInnocencePhotoInfoOuterClass.GravenInnocencePhotoInfo.Builder builderForValue) {
        if (photoInfoBuilder_ == null) {
          photoInfo_ = builderForValue.build();
          onChanged();
        } else {
          photoInfoBuilder_.setMessage(builderForValue.build());
        }

        return this;
      }


@java.lang.Override
    public int getStageId() {
      return stageId_;
    }

/**
       * uint32 stageId = 10;
       * @return The stageId.
       */


public java.lang.String getClientParams() {
        java.lang.Object ref = clientParams_;
        if (!(ref instanceof java.lang.String)) {
          com.google.protobuf.ByteString bs =
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          clientParams_ = s;
          return s;
        } else {
          return (java.lang.String) ref;
        }
      }

/**
       * string clientParams = 10;
       * @return The clientParams.
       */


public emu.grasscutter.net.proto.BlossomBriefInfoOuterClass.BlossomBriefInfo.Builder getBriefInfoListBuilder(
          int index) {
        return getBriefInfoListFieldBuilder().getBuilder(index);
      }

/**
       * repeated .BlossomBriefInfo briefInfoList = 9;
       */


public Builder setSchemeData(emu.grasscutter.net.proto.FireworksLaunchSchemeDataOuterClass.FireworksLaunchSchemeData value) {
        if (schemeDataBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          schemeData_ = value;
          onChanged();
        } else {
          schemeDataBuilder_.setMessage(value);
        }

        return this;
      }

/**
       * <code>.FireworksLaunchSchemeData schemeData = 1;</code>
       */


@java.lang.Override
    public emu.grasscutter.net.proto.MonsterRouteOuterClass.MonsterRouteOrBuilder getMonsterRouteOrBuilder() {
      return getMonsterRoute();
    }

/**
     * <code>.MonsterRoute monsterRoute = 2;</code>
     */


@java.lang.Override
    public boolean getIsHaveProgress() {
      return isHaveProgress_;
    }

/**
       * bool isHaveProgress = 13;
       * @return The isHaveProgress.
       */


public Builder addConfigIdList(int value) {
        ensureConfigIdListIsMutable();
        configIdList_.addInt(value);
        onChanged();
        return this;
      }

/**
       * repeated uint32 configIdList = 12;
       * @param value The configIdList to add.
       * @return This builder for chaining.
       */


@java.lang.Override
    public java.util.List<? extends emu.grasscutter.net.proto.ServerBuffOuterClass.ServerBuffOrBuilder>
        getServerBuffListOrBuilderList() {
      return serverBuffList_;
    }

/**
     * repeated .ServerBuff serverBuffList = 12;
     */


public int getAvatarGuidListCount() {
      return avatarGuidList_.size();
    }

/**
       * repeated uint64 avatarGuidList = 10;
       * @return The count of avatarGuidList.
       */


@java.lang.Override
    public int getObtainLimit() {
      return obtainLimit_;
    }

/**
       * uint32 obtainLimit = 4;
       * @return The obtainLimit.
       */


public Builder setRetcode(int value) {

        retcode_ = value;
        onChanged();
        return this;
      }

/**
       * int32 retcode = 5;
       * @param value The retcode to set.
       * @return This builder for chaining.
       */


@java.lang.Override
    public emu.grasscutter.net.proto.FriendBriefOuterClass.FriendBrief getAskFriendList(int index) {
      return askFriendList_.get(index);
    }

/**
     * repeated .FriendBrief askFriendList = 6;
     */


@java.lang.Override
    public java.util.List<java.lang.Integer>
        getRemainUidListList() {
      return remainUidList_;
    }

/**
     * repeated uint32 remainUidList = 3;
     * @return A list containing the remainUidList.
     */


public Builder clearUnk3300ILELLFNPDFJ() {
        if (unk3300ILELLFNPDFJBuilder_ == null) {
          unk3300ILELLFNPDFJ_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000001);
          onChanged();
        } else {
          unk3300ILELLFNPDFJBuilder_.clear();
        }
        return this;
      }

/**
       * repeated .ItemParam Unk3300_ILELLFNPDFJ = 9;
       */


@java.lang.Override
    public java.util.List<? extends emu.grasscutter.net.proto.ParkourLevelInfoOuterClass.ParkourLevelInfoOrBuilder>
        getParkourLevelInfoListOrBuilderList() {
      return parkourLevelInfoList_;
    }

/**
     * repeated .ParkourLevelInfo parkourLevelInfoList = 6;
     */


public Builder clearMainHouse() {
        if (mainHouseBuilder_ == null) {
          mainHouse_ = null;
          onChanged();
        } else {
          mainHouse_ = null;
          mainHouseBuilder_ = null;
        }

        return this;
      }

/**
       * <code>.HomeFurnitureData mainHouse = 6;</code>
       */


public Builder addUnk3300ABHHACBDCFI(int value) {
        ensureUnk3300ABHHACBDCFIIsMutable();
        unk3300ABHHACBDCFI_.addInt(value);
        onChanged();
        return this;
      }

/**
       * repeated uint32 Unk3300_ABHHACBDCFI = 3;
       * @param value The unk3300ABHHACBDCFI to add.
       * @return This builder for chaining.
       */


public Builder clearUnk3300KJDEFIBKBPE() {

        unk3300KJDEFIBKBPE_ = false;
        onChanged();
        return this;
      }

/**
       * bool Unk3300_KJDEFIBKBPE = 5;
       * @return This builder for chaining.
       */


@java.lang.Override
    public int getCount() {
      return count_;
    }

/**
       * uint32 count = 1;
       * @return The count.
       */


public Builder putPropMap(
          int key,
          emu.grasscutter.net.proto.PropValueOuterClass.PropValue value) {

        if (value == null) { throw new java.lang.NullPointerException(); }
        internalGetMutablePropMap().getMutableMap()
            .put(key, value);
        return this;
      }

/**
       * map<uint32, .PropValue> propMap = 5;
       */


public Builder setClientVerisonHash(
          java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }

        clientVerisonHash_ = value;
        onChanged();
        return this;
      }

/**
       * string clientVerisonHash = 1765;
       * @param value The clientVerisonHash to set.
       * @return This builder for chaining.
       */


@java.lang.Override
    public emu.grasscutter.net.proto.VectorOuterClass.Vector getRot() {
      return rot_ == null ? emu.grasscutter.net.proto.VectorOuterClass.Vector.getDefaultInstance() : rot_;
    }

/**
     * <code>.Vector rot = 13;</code>
     * @return The rot.
     */


public Builder setResVersionConfig(
          emu.grasscutter.net.proto.ResVersionConfigOuterClass.ResVersionConfig.Builder builderForValue) {
        if (resVersionConfigBuilder_ == null) {
          resVersionConfig_ = builderForValue.build();
          onChanged();
        } else {
          resVersionConfigBuilder_.setMessage(builderForValue.build());
        }

        return this;
      }

/**
       * <code>.ResVersionConfig res_version_config = 22;</code>
       */


public java.lang.String getContentMsg() {
        java.lang.Object ref = contentMsg_;
        if (!(ref instanceof java.lang.String)) {
          com.google.protobuf.ByteString bs =
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          contentMsg_ = s;
          return s;
        } else {
          return (java.lang.String) ref;
        }
      }

/**
       * string contentMsg = 4;
       * @return The contentMsg.
       */


public Builder setItemList(
          int index, emu.grasscutter.net.proto.EquipParamOuterClass.EquipParam.Builder builderForValue) {
        if (itemListBuilder_ == null) {
          ensureItemListIsMutable();
          itemList_.set(index, builderForValue.build());
          onChanged();
        } else {
          itemListBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }

/**
       * repeated .EquipParam itemList = 9;
       */


public Builder setExpeditionStateValue(int value) {

        expeditionState_ = value;
        onChanged();
        return this;
      }

/**
       * <code>.AvatarExpeditionState expeditionState = 16;</code>
       * @param value The enum numeric value on the wire for expeditionState to set.
       * @return This builder for chaining.
       */


public Builder setForwardTypeValue(int value) {

        forwardType_ = value;
        onChanged();
        return this;
      }

/**
       * <code>.ForwardType forwardType = 5;</code>
       * @param value The enum numeric value on the wire for forwardType to set.
       * @return This builder for chaining.
       */