// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/kubectl/pkg/cmd/util (interfaces: Factory)
//
// Generated by this command:
//
//	mockgen -typed -destination kubectl_cmd_util.go -package mock_k8s k8s.io/kubectl/pkg/cmd/util Factory
//

// Package mock_k8s is a generated GoMock package.
package mock_k8s

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	meta "k8s.io/apimachinery/pkg/api/meta"
	resource "k8s.io/cli-runtime/pkg/resource"
	discovery "k8s.io/client-go/discovery"
	dynamic "k8s.io/client-go/dynamic"
	kubernetes "k8s.io/client-go/kubernetes"
	openapi "k8s.io/client-go/openapi"
	rest "k8s.io/client-go/rest"
	clientcmd "k8s.io/client-go/tools/clientcmd"
	openapi0 "k8s.io/kubectl/pkg/util/openapi"
	validation "k8s.io/kubectl/pkg/validation"
)

// MockFactory is a mock of Factory interface.
type MockFactory struct {
	ctrl     *gomock.Controller
	recorder *MockFactoryMockRecorder
}

// MockFactoryMockRecorder is the mock recorder for MockFactory.
type MockFactoryMockRecorder struct {
	mock *MockFactory
}

// NewMockFactory creates a new mock instance.
func NewMockFactory(ctrl *gomock.Controller) *MockFactory {
	mock := &MockFactory{ctrl: ctrl}
	mock.recorder = &MockFactoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFactory) EXPECT() *MockFactoryMockRecorder {
	return m.recorder
}

// ClientForMapping mocks base method.
func (m *MockFactory) ClientForMapping(arg0 *meta.RESTMapping) (resource.RESTClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientForMapping", arg0)
	ret0, _ := ret[0].(resource.RESTClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClientForMapping indicates an expected call of ClientForMapping.
func (mr *MockFactoryMockRecorder) ClientForMapping(arg0 any) *MockFactoryClientForMappingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientForMapping", reflect.TypeOf((*MockFactory)(nil).ClientForMapping), arg0)
	return &MockFactoryClientForMappingCall{Call: call}
}

// MockFactoryClientForMappingCall wrap *gomock.Call
type MockFactoryClientForMappingCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryClientForMappingCall) Return(arg0 resource.RESTClient, arg1 error) *MockFactoryClientForMappingCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryClientForMappingCall) Do(f func(*meta.RESTMapping) (resource.RESTClient, error)) *MockFactoryClientForMappingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryClientForMappingCall) DoAndReturn(f func(*meta.RESTMapping) (resource.RESTClient, error)) *MockFactoryClientForMappingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DynamicClient mocks base method.
func (m *MockFactory) DynamicClient() (dynamic.Interface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DynamicClient")
	ret0, _ := ret[0].(dynamic.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DynamicClient indicates an expected call of DynamicClient.
func (mr *MockFactoryMockRecorder) DynamicClient() *MockFactoryDynamicClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DynamicClient", reflect.TypeOf((*MockFactory)(nil).DynamicClient))
	return &MockFactoryDynamicClientCall{Call: call}
}

// MockFactoryDynamicClientCall wrap *gomock.Call
type MockFactoryDynamicClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryDynamicClientCall) Return(arg0 dynamic.Interface, arg1 error) *MockFactoryDynamicClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryDynamicClientCall) Do(f func() (dynamic.Interface, error)) *MockFactoryDynamicClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryDynamicClientCall) DoAndReturn(f func() (dynamic.Interface, error)) *MockFactoryDynamicClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// KubernetesClientSet mocks base method.
func (m *MockFactory) KubernetesClientSet() (*kubernetes.Clientset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KubernetesClientSet")
	ret0, _ := ret[0].(*kubernetes.Clientset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KubernetesClientSet indicates an expected call of KubernetesClientSet.
func (mr *MockFactoryMockRecorder) KubernetesClientSet() *MockFactoryKubernetesClientSetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KubernetesClientSet", reflect.TypeOf((*MockFactory)(nil).KubernetesClientSet))
	return &MockFactoryKubernetesClientSetCall{Call: call}
}

// MockFactoryKubernetesClientSetCall wrap *gomock.Call
type MockFactoryKubernetesClientSetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryKubernetesClientSetCall) Return(arg0 *kubernetes.Clientset, arg1 error) *MockFactoryKubernetesClientSetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryKubernetesClientSetCall) Do(f func() (*kubernetes.Clientset, error)) *MockFactoryKubernetesClientSetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryKubernetesClientSetCall) DoAndReturn(f func() (*kubernetes.Clientset, error)) *MockFactoryKubernetesClientSetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NewBuilder mocks base method.
func (m *MockFactory) NewBuilder() *resource.Builder {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewBuilder")
	ret0, _ := ret[0].(*resource.Builder)
	return ret0
}

// NewBuilder indicates an expected call of NewBuilder.
func (mr *MockFactoryMockRecorder) NewBuilder() *MockFactoryNewBuilderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBuilder", reflect.TypeOf((*MockFactory)(nil).NewBuilder))
	return &MockFactoryNewBuilderCall{Call: call}
}

// MockFactoryNewBuilderCall wrap *gomock.Call
type MockFactoryNewBuilderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryNewBuilderCall) Return(arg0 *resource.Builder) *MockFactoryNewBuilderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryNewBuilderCall) Do(f func() *resource.Builder) *MockFactoryNewBuilderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryNewBuilderCall) DoAndReturn(f func() *resource.Builder) *MockFactoryNewBuilderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OpenAPISchema mocks base method.
func (m *MockFactory) OpenAPISchema() (openapi0.Resources, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenAPISchema")
	ret0, _ := ret[0].(openapi0.Resources)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenAPISchema indicates an expected call of OpenAPISchema.
func (mr *MockFactoryMockRecorder) OpenAPISchema() *MockFactoryOpenAPISchemaCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenAPISchema", reflect.TypeOf((*MockFactory)(nil).OpenAPISchema))
	return &MockFactoryOpenAPISchemaCall{Call: call}
}

// MockFactoryOpenAPISchemaCall wrap *gomock.Call
type MockFactoryOpenAPISchemaCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryOpenAPISchemaCall) Return(arg0 openapi0.Resources, arg1 error) *MockFactoryOpenAPISchemaCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryOpenAPISchemaCall) Do(f func() (openapi0.Resources, error)) *MockFactoryOpenAPISchemaCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryOpenAPISchemaCall) DoAndReturn(f func() (openapi0.Resources, error)) *MockFactoryOpenAPISchemaCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OpenAPIV3Client mocks base method.
func (m *MockFactory) OpenAPIV3Client() (openapi.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenAPIV3Client")
	ret0, _ := ret[0].(openapi.Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenAPIV3Client indicates an expected call of OpenAPIV3Client.
func (mr *MockFactoryMockRecorder) OpenAPIV3Client() *MockFactoryOpenAPIV3ClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenAPIV3Client", reflect.TypeOf((*MockFactory)(nil).OpenAPIV3Client))
	return &MockFactoryOpenAPIV3ClientCall{Call: call}
}

// MockFactoryOpenAPIV3ClientCall wrap *gomock.Call
type MockFactoryOpenAPIV3ClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryOpenAPIV3ClientCall) Return(arg0 openapi.Client, arg1 error) *MockFactoryOpenAPIV3ClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryOpenAPIV3ClientCall) Do(f func() (openapi.Client, error)) *MockFactoryOpenAPIV3ClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryOpenAPIV3ClientCall) DoAndReturn(f func() (openapi.Client, error)) *MockFactoryOpenAPIV3ClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RESTClient mocks base method.
func (m *MockFactory) RESTClient() (*rest.RESTClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RESTClient")
	ret0, _ := ret[0].(*rest.RESTClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RESTClient indicates an expected call of RESTClient.
func (mr *MockFactoryMockRecorder) RESTClient() *MockFactoryRESTClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTClient", reflect.TypeOf((*MockFactory)(nil).RESTClient))
	return &MockFactoryRESTClientCall{Call: call}
}

// MockFactoryRESTClientCall wrap *gomock.Call
type MockFactoryRESTClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryRESTClientCall) Return(arg0 *rest.RESTClient, arg1 error) *MockFactoryRESTClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryRESTClientCall) Do(f func() (*rest.RESTClient, error)) *MockFactoryRESTClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryRESTClientCall) DoAndReturn(f func() (*rest.RESTClient, error)) *MockFactoryRESTClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ToDiscoveryClient mocks base method.
func (m *MockFactory) ToDiscoveryClient() (discovery.CachedDiscoveryInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToDiscoveryClient")
	ret0, _ := ret[0].(discovery.CachedDiscoveryInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ToDiscoveryClient indicates an expected call of ToDiscoveryClient.
func (mr *MockFactoryMockRecorder) ToDiscoveryClient() *MockFactoryToDiscoveryClientCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToDiscoveryClient", reflect.TypeOf((*MockFactory)(nil).ToDiscoveryClient))
	return &MockFactoryToDiscoveryClientCall{Call: call}
}

// MockFactoryToDiscoveryClientCall wrap *gomock.Call
type MockFactoryToDiscoveryClientCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryToDiscoveryClientCall) Return(arg0 discovery.CachedDiscoveryInterface, arg1 error) *MockFactoryToDiscoveryClientCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryToDiscoveryClientCall) Do(f func() (discovery.CachedDiscoveryInterface, error)) *MockFactoryToDiscoveryClientCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryToDiscoveryClientCall) DoAndReturn(f func() (discovery.CachedDiscoveryInterface, error)) *MockFactoryToDiscoveryClientCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ToRESTConfig mocks base method.
func (m *MockFactory) ToRESTConfig() (*rest.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToRESTConfig")
	ret0, _ := ret[0].(*rest.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ToRESTConfig indicates an expected call of ToRESTConfig.
func (mr *MockFactoryMockRecorder) ToRESTConfig() *MockFactoryToRESTConfigCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRESTConfig", reflect.TypeOf((*MockFactory)(nil).ToRESTConfig))
	return &MockFactoryToRESTConfigCall{Call: call}
}

// MockFactoryToRESTConfigCall wrap *gomock.Call
type MockFactoryToRESTConfigCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryToRESTConfigCall) Return(arg0 *rest.Config, arg1 error) *MockFactoryToRESTConfigCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryToRESTConfigCall) Do(f func() (*rest.Config, error)) *MockFactoryToRESTConfigCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryToRESTConfigCall) DoAndReturn(f func() (*rest.Config, error)) *MockFactoryToRESTConfigCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ToRESTMapper mocks base method.
func (m *MockFactory) ToRESTMapper() (meta.RESTMapper, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToRESTMapper")
	ret0, _ := ret[0].(meta.RESTMapper)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ToRESTMapper indicates an expected call of ToRESTMapper.
func (mr *MockFactoryMockRecorder) ToRESTMapper() *MockFactoryToRESTMapperCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRESTMapper", reflect.TypeOf((*MockFactory)(nil).ToRESTMapper))
	return &MockFactoryToRESTMapperCall{Call: call}
}

// MockFactoryToRESTMapperCall wrap *gomock.Call
type MockFactoryToRESTMapperCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryToRESTMapperCall) Return(arg0 meta.RESTMapper, arg1 error) *MockFactoryToRESTMapperCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryToRESTMapperCall) Do(f func() (meta.RESTMapper, error)) *MockFactoryToRESTMapperCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryToRESTMapperCall) DoAndReturn(f func() (meta.RESTMapper, error)) *MockFactoryToRESTMapperCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ToRawKubeConfigLoader mocks base method.
func (m *MockFactory) ToRawKubeConfigLoader() clientcmd.ClientConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToRawKubeConfigLoader")
	ret0, _ := ret[0].(clientcmd.ClientConfig)
	return ret0
}

// ToRawKubeConfigLoader indicates an expected call of ToRawKubeConfigLoader.
func (mr *MockFactoryMockRecorder) ToRawKubeConfigLoader() *MockFactoryToRawKubeConfigLoaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToRawKubeConfigLoader", reflect.TypeOf((*MockFactory)(nil).ToRawKubeConfigLoader))
	return &MockFactoryToRawKubeConfigLoaderCall{Call: call}
}

// MockFactoryToRawKubeConfigLoaderCall wrap *gomock.Call
type MockFactoryToRawKubeConfigLoaderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryToRawKubeConfigLoaderCall) Return(arg0 clientcmd.ClientConfig) *MockFactoryToRawKubeConfigLoaderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryToRawKubeConfigLoaderCall) Do(f func() clientcmd.ClientConfig) *MockFactoryToRawKubeConfigLoaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryToRawKubeConfigLoaderCall) DoAndReturn(f func() clientcmd.ClientConfig) *MockFactoryToRawKubeConfigLoaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UnstructuredClientForMapping mocks base method.
func (m *MockFactory) UnstructuredClientForMapping(arg0 *meta.RESTMapping) (resource.RESTClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnstructuredClientForMapping", arg0)
	ret0, _ := ret[0].(resource.RESTClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnstructuredClientForMapping indicates an expected call of UnstructuredClientForMapping.
func (mr *MockFactoryMockRecorder) UnstructuredClientForMapping(arg0 any) *MockFactoryUnstructuredClientForMappingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnstructuredClientForMapping", reflect.TypeOf((*MockFactory)(nil).UnstructuredClientForMapping), arg0)
	return &MockFactoryUnstructuredClientForMappingCall{Call: call}
}

// MockFactoryUnstructuredClientForMappingCall wrap *gomock.Call
type MockFactoryUnstructuredClientForMappingCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryUnstructuredClientForMappingCall) Return(arg0 resource.RESTClient, arg1 error) *MockFactoryUnstructuredClientForMappingCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryUnstructuredClientForMappingCall) Do(f func(*meta.RESTMapping) (resource.RESTClient, error)) *MockFactoryUnstructuredClientForMappingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryUnstructuredClientForMappingCall) DoAndReturn(f func(*meta.RESTMapping) (resource.RESTClient, error)) *MockFactoryUnstructuredClientForMappingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Validator mocks base method.
func (m *MockFactory) Validator(arg0 string) (validation.Schema, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validator", arg0)
	ret0, _ := ret[0].(validation.Schema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Validator indicates an expected call of Validator.
func (mr *MockFactoryMockRecorder) Validator(arg0 any) *MockFactoryValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validator", reflect.TypeOf((*MockFactory)(nil).Validator), arg0)
	return &MockFactoryValidatorCall{Call: call}
}

// MockFactoryValidatorCall wrap *gomock.Call
type MockFactoryValidatorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFactoryValidatorCall) Return(arg0 validation.Schema, arg1 error) *MockFactoryValidatorCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFactoryValidatorCall) Do(f func(string) (validation.Schema, error)) *MockFactoryValidatorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFactoryValidatorCall) DoAndReturn(f func(string) (validation.Schema, error)) *MockFactoryValidatorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}