// CoreFunctions returns all of the core logic
190884
func CoreFunctions() map[string]ZlispUserFunction {
	return map[string]ZlispUserFunction{
		"pretty":    SetPrettyPrintFlag,
		"<":         CompareFunction,
		">":         CompareFunction,
		"<=":        CompareFunction,
		">=":        CompareFunction,
		"==":        CompareFunction,
		"!=":        CompareFunction,
		"isnan":     IsNaNFunction,
		"isNaN":     IsNaNFunction,
		"sll":       BinaryIntFunction,
		"sra":       BinaryIntFunction,
		"srl":       BinaryIntFunction,
		"mod":       BinaryIntFunction,
		"+":         NumericFunction,
		"-":         NumericFunction,
		"*":         PointerOrNumericFunction,
		"**":        NumericFunction,
		"/":         NumericFunction,
		"bitAnd":    BitwiseFunction,
		"bitOr":     BitwiseFunction,
		"bitXor":    BitwiseFunction,
		"bitNot":    ComplementFunction,
		"read":      ReadFunction,
		"cons":      ConsFunction,
		"first":     FirstFunction,
		"second":    SecondFunction,
		"rest":      RestFunction,
		"car":       FirstFunction,
		"cdr":       RestFunction,
		"type?":     TypeQueryFunction,
		"list?":     TypeQueryFunction,
		"null?":     TypeQueryFunction,
		"array?":    TypeQueryFunction,
		"hash?":     TypeQueryFunction,
		"number?":   TypeQueryFunction,
		"int?":      TypeQueryFunction,
		"float?":    TypeQueryFunction,
		"char?":     TypeQueryFunction,
		"symbol?":   TypeQueryFunction,
		"string?":   TypeQueryFunction,
		"zero?":     TypeQueryFunction,
		"empty?":    TypeQueryFunction,
		"func?":     TypeQueryFunction,
		"not":       NotFunction,
		"apply":     ApplyFunction,
		"map":       MapFunction,
		"makeArray": MakeArrayFunction,
		"aget":      ArrayAccessFunction,
		"aset":      ArrayAccessFunction,
		"sget":      SgetFunction,
		"hget":      GenericAccessFunction, // handles arrays or hashes
		//":":          ColonAccessFunction,
		"hset":        HashAccessFunction,
		"hdel":        HashAccessFunction,
		"keys":        HashAccessFunction,
		"hpair":       GenericHpairFunction,
		"slice":       SliceFunction,
		"len":         LenFunction,
		"append":      AppendFunction,
		"appendslice": AppendFunction,
		"concat":      ConcatFunction,
		"field":       ConstructorFunction,
		"struct":      ConstructorFunction,
		"array":       ConstructorFunction,
		"list":        ConstructorFunction,
		"hash":        ConstructorFunction,
		"raw":         ConstructorFunction,
		"str":         StringifyFunction,
		"->":          ThreadMapFunction,
		"flatten":     FlattenToWordsFunction,
		"quotelist":   QuoteListFunction,
		"=":           AssignmentFunction,
		":=":          AssignmentFunction,
		"fieldls":     GoFieldListFunction,
		"defined?":    DefinedFunction,
		"stop":        StopFunction,
		"joinsym":     JoinSymFunction,
		"GOOS":        GOOSFunction,
		"&":           AddressOfFunction,
		"derefSet":    DerefFunction,
		"deref":       DerefFunction,
		".":           DotFunction,
		"arrayidx":    ArrayIndexFunction,
		"hashidx":     HashIndexFunction,
		"asUint64":    AsUint64Function,
	}
}
627428
func TemplateFunc(name string, f interface{}) TemplateOption {
	return func(g Generator, t *template.Template) *template.Template {
		return t.Funcs(template.FuncMap{name: curryGenerator(f, g)})
	}
}
121368
func AddTemplateFuncs(tmplFuncs template.FuncMap) {
	for k, v := range tmplFuncs {
		templateFuncs[k] = v
	}
}
373159
func Convert_v1_PodAffinity_To_core_PodAffinity(in *v1.PodAffinity, out *core.PodAffinity, s conversion.Scope) error {
	return autoConvert_v1_PodAffinity_To_core_PodAffinity(in, out, s)
}
234928
func (p *Profile) HasFunctions() bool {
	for _, l := range p.Location {
		if l.Mapping != nil && !l.Mapping.HasFunctions {
			return false
		}
	}
	return true
}
1269277
func (c *ifFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (sig builtinFunc, err error) {
	if err = c.verifyArgs(args); err != nil {
		return nil, err
	}
	retTp := InferType4ControlFuncs(args[1].GetType(), args[2].GetType())
	evalTps := retTp.EvalType()
	bf := newBaseBuiltinFuncWithTp(ctx, args, evalTps, types.ETInt, evalTps, evalTps)
	retTp.Flag |= bf.tp.Flag
	bf.tp = retTp
	switch evalTps {
	case types.ETInt:
		sig = &builtinIfIntSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfInt)
	case types.ETReal:
		sig = &builtinIfRealSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfReal)
	case types.ETDecimal:
		sig = &builtinIfDecimalSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfDecimal)
	case types.ETString:
		sig = &builtinIfStringSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfString)
	case types.ETDatetime, types.ETTimestamp:
		sig = &builtinIfTimeSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfTime)
	case types.ETDuration:
		sig = &builtinIfDurationSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfDuration)
	case types.ETJson:
		sig = &builtinIfJSONSig{bf}
		sig.setPbCode(tipb.ScalarFuncSig_IfJson)
	}
	return sig, nil
}
1232401
func (m *MockLambdaAPI) ListFunctions(arg0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
	ret := m.ctrl.Call(m, "ListFunctions", arg0)
	ret0, _ := ret[0].(*lambda.ListFunctionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
62119
func (s *FunctionDefinitionVersion) SetFunctions(v []*Function) *FunctionDefinitionVersion {
	s.Functions = v
	return s
}
759155
func Funcs(codecs runtimeserializer.CodecFactory) []interface{} {
	return []interface{}{
		fuzzInitConfiguration,
		fuzzClusterConfiguration,
		fuzzComponentConfigs,
		fuzzDNS,
		fuzzLocalEtcd,
		fuzzNetworking,
		fuzzJoinConfiguration,
	}
}
298081
func Funcs(codecs runtimeserializer.CodecFactory) []interface{} {
	return []interface{}{
		func(e *audit.Event, c fuzz.Continue) {
			c.FuzzNoCustom(e)
			switch c.RandBool() {
			case true:
				e.RequestObject = nil
			case false:
				e.RequestObject = &runtime.Unknown{
					TypeMeta:    runtime.TypeMeta{APIVersion: "", Kind: ""},
					Raw:         []byte(`{"apiVersion":"","kind":"Pod","someKey":"someValue"}`),
					ContentType: runtime.ContentTypeJSON,
				}
			}
			switch c.RandBool() {
			case true:
				e.ResponseObject = nil
			case false:
				e.ResponseObject = &runtime.Unknown{
					TypeMeta:    runtime.TypeMeta{APIVersion: "", Kind: ""},
					Raw:         []byte(`{"apiVersion":"","kind":"Pod","someKey":"someValue"}`),
					ContentType: runtime.ContentTypeJSON,
				}
			}
		},
		func(o *audit.ObjectReference, c fuzz.Continue) {
			c.FuzzNoCustom(o)
			switch c.Intn(3) {
			case 0:
				// core api group
				o.APIGroup = ""
				o.APIVersion = "v1"
			case 1:
				// other group
				o.APIGroup = "rbac.authorization.k8s.io"
				o.APIVersion = "v1beta1"
			default:
				// use random value, but without / as it is used as separator
				o.APIGroup = strings.Replace(o.APIGroup, "/", "-", -1)
				o.APIVersion = strings.Replace(o.APIVersion, "/", "-", -1)
			}
		},
	}
}
317902
func (v *Service) GetFunctions() (o []*Function) {
	if v != nil {
		o = v.Functions
	}
	return
}
923095
func (l *State) ToGoFunction(index int) Function {
	switch v := l.indexToValue(index).(type) {
	case *goFunction:
		return v.Function
	case *goClosure:
		return v.function
	}
	return nil
}
1168747
func Convert_v1_ComponentStatusList_To_core_ComponentStatusList(in *v1.ComponentStatusList, out *core.ComponentStatusList, s conversion.Scope) error {
	return autoConvert_v1_ComponentStatusList_To_core_ComponentStatusList(in, out, s)
}
486493
func Funcs(codecs runtimeserializer.CodecFactory) []interface{} {
	return []interface{}{
		func(obj *apiextensions.CustomResourceDefinitionSpec, c fuzz.Continue) {
			c.FuzzNoCustom(obj)

			// match our defaulter
			if len(obj.Scope) == 0 {
				obj.Scope = apiextensions.NamespaceScoped
			}
			if len(obj.Names.Singular) == 0 {
				obj.Names.Singular = strings.ToLower(obj.Names.Kind)
			}
			if len(obj.Names.ListKind) == 0 && len(obj.Names.Kind) > 0 {
				obj.Names.ListKind = obj.Names.Kind + "List"
			}
			if len(obj.Versions) == 0 && len(obj.Version) != 0 {
				obj.Versions = []apiextensions.CustomResourceDefinitionVersion{
					{
						Name:    obj.Version,
						Served:  true,
						Storage: true,
					},
				}
			} else if len(obj.Versions) != 0 {
				obj.Version = obj.Versions[0].Name
			}
			if len(obj.AdditionalPrinterColumns) == 0 {
				obj.AdditionalPrinterColumns = []apiextensions.CustomResourceColumnDefinition{
					{Name: "Age", Type: "date", Description: swaggerMetadataDescriptions["creationTimestamp"], JSONPath: ".metadata.creationTimestamp"},
				}
			}
			if obj.Conversion == nil {
				obj.Conversion = &apiextensions.CustomResourceConversion{
					Strategy: apiextensions.NoneConverter,
				}
			}
			if obj.Conversion.Strategy == apiextensions.WebhookConverter && len(obj.Conversion.ConversionReviewVersions) == 0 {
				obj.Conversion.ConversionReviewVersions = []string{"v1beta1"}
			}
		},
		func(obj *apiextensions.CustomResourceDefinition, c fuzz.Continue) {
			c.FuzzNoCustom(obj)

			if len(obj.Status.StoredVersions) == 0 {
				for _, v := range obj.Spec.Versions {
					if v.Storage && !apiextensions.IsStoredVersion(obj, v.Name) {
						obj.Status.StoredVersions = append(obj.Status.StoredVersions, v.Name)
					}
				}
			}
		},
		func(obj *apiextensions.JSONSchemaProps, c fuzz.Continue) {
			// we cannot use c.FuzzNoCustom because of the interface{} fields. So let's loop with reflection.
			vobj := reflect.ValueOf(obj).Elem()
			tobj := reflect.TypeOf(obj).Elem()
			for i := 0; i < tobj.NumField(); i++ {
				field := tobj.Field(i)
				switch field.Name {
				case "Default", "Enum", "Example", "Ref":
					continue
				default:
					isValue := true
					switch field.Type.Kind() {
					case reflect.Interface, reflect.Map, reflect.Slice, reflect.Ptr:
						isValue = false
					}
					if isValue || c.Intn(10) == 0 {
						c.Fuzz(vobj.Field(i).Addr().Interface())
					}
				}
			}
			if c.RandBool() {
				validJSON := apiextensions.JSON(`{"some": {"json": "test"}, "string": 42}`)
				obj.Default = &validJSON
			}
			if c.RandBool() {
				obj.Enum = []apiextensions.JSON{c.Float64(), c.RandString(), c.RandBool()}
			}
			if c.RandBool() {
				validJSON := apiextensions.JSON(`"foobarbaz"`)
				obj.Example = &validJSON
			}
			if c.RandBool() {
				validRef := "validRef"
				obj.Ref = &validRef
			}
			if len(obj.Type) == 0 {
				obj.Nullable = false // because this does not roundtrip through go-openapi
			}
		},
		func(obj *apiextensions.JSONSchemaPropsOrBool, c fuzz.Continue) {
			if c.RandBool() {
				obj.Allows = true
				obj.Schema = &apiextensions.JSONSchemaProps{}
				c.Fuzz(obj.Schema)
			} else {
				obj.Allows = c.RandBool()
			}
		},
		func(obj *apiextensions.JSONSchemaPropsOrArray, c fuzz.Continue) {
			// disallow both Schema and JSONSchemas to be nil.
			if c.RandBool() {
				obj.Schema = &apiextensions.JSONSchemaProps{}
				c.Fuzz(obj.Schema)
			} else {
				obj.JSONSchemas = make([]apiextensions.JSONSchemaProps, c.Intn(3)+1)
				for i := range obj.JSONSchemas {
					c.Fuzz(&obj.JSONSchemas[i])
				}
			}
		},
		func(obj *apiextensions.JSONSchemaPropsOrStringArray, c fuzz.Continue) {
			if c.RandBool() {
				obj.Schema = &apiextensions.JSONSchemaProps{}
				c.Fuzz(obj.Schema)
			} else {
				c.Fuzz(&obj.Property)
			}
		},
		func(obj *int64, c fuzz.Continue) {
			// JSON only supports 53 bits because everything is a float
			*obj = int64(c.Uint64()) & ((int64(1) << 53) - 1)
		},
	}
}
661848
func Convert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(in *v1.WeightedPodAffinityTerm, out *core.WeightedPodAffinityTerm, s conversion.Scope) error {
	return autoConvert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(in, out, s)
}
620234
func Funcs(d *data.Data) template.FuncMap {
	f := template.FuncMap{}
	funcs.AddDataFuncs(f, d)
	funcs.AWSFuncs(f)
	funcs.AddBase64Funcs(f)
	funcs.AddNetFuncs(f)
	funcs.AddReFuncs(f)
	funcs.AddStringFuncs(f)
	funcs.AddEnvFuncs(f)
	funcs.AddConvFuncs(f)
	funcs.AddTimeFuncs(f)
	funcs.AddMathFuncs(f)
	funcs.AddCryptoFuncs(f)
	funcs.AddFileFuncs(f)
	funcs.AddFilePathFuncs(f)
	funcs.AddPathFuncs(f)
	funcs.AddSockaddrFuncs(f)
	funcs.AddTestFuncs(f)
	funcs.AddCollFuncs(f)
	funcs.AddUUIDFuncs(f)
	funcs.AddRandomFuncs(f)
	return f
}
1210296
func Convert_v1_ExecAction_To_core_ExecAction(in *v1.ExecAction, out *core.ExecAction, s conversion.Scope) error {
	return autoConvert_v1_ExecAction_To_core_ExecAction(in, out, s)
}