//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
//  Copyright © 2016 - 2026 Weaviate B.V. All rights reserved.
//
//  CONTACT: hello@weaviate.io
//

// Code generated by mockery v2.53.5. DO NOT EDIT.

package replica

import (
	context "context"

	mock "github.com/stretchr/testify/mock"
	objects "github.com/weaviate/weaviate/usecases/objects"

	storobj "github.com/weaviate/weaviate/entities/storobj"

	strfmt "github.com/go-openapi/strfmt"

	time "time"
)

// MockWClient is an autogenerated mock type for the WClient type
type MockWClient struct {
	mock.Mock
}

type MockWClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWClient) EXPECT() *MockWClient_Expecter {
	return &MockWClient_Expecter{mock: &_m.Mock}
}

// Abort provides a mock function with given fields: ctx, host, index, shard, requestID
func (_m *MockWClient) Abort(ctx context.Context, host string, index string, shard string, requestID string) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID)

	if len(ret) == 0 {
		panic("no return value specified for Abort")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = rf(ctx, host, index, shard, requestID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_Abort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Abort'
type MockWClient_Abort_Call struct {
	*mock.Call
}

// Abort is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
func (_e *MockWClient_Expecter) Abort(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}) *MockWClient_Abort_Call {
	return &MockWClient_Abort_Call{Call: _e.mock.On("Abort", ctx, host, index, shard, requestID)}
}

func (_c *MockWClient_Abort_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string)) *MockWClient_Abort_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockWClient_Abort_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_Abort_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_Abort_Call) RunAndReturn(run func(context.Context, string, string, string, string) (SimpleResponse, error)) *MockWClient_Abort_Call {
	_c.Call.Return(run)
	return _c
}

// AddReferences provides a mock function with given fields: ctx, host, index, shard, requestID, refs, schemaVersion
func (_m *MockWClient) AddReferences(ctx context.Context, host string, index string, shard string, requestID string, refs []objects.BatchReference, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, refs, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for AddReferences")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []objects.BatchReference, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, refs, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []objects.BatchReference, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, refs, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, []objects.BatchReference, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, refs, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_AddReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReferences'
type MockWClient_AddReferences_Call struct {
	*mock.Call
}

// AddReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - refs []objects.BatchReference
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) AddReferences(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, refs interface{}, schemaVersion interface{}) *MockWClient_AddReferences_Call {
	return &MockWClient_AddReferences_Call{Call: _e.mock.On("AddReferences", ctx, host, index, shard, requestID, refs, schemaVersion)}
}

func (_c *MockWClient_AddReferences_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, refs []objects.BatchReference, schemaVersion uint64)) *MockWClient_AddReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].([]objects.BatchReference), args[6].(uint64))
	})
	return _c
}

func (_c *MockWClient_AddReferences_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_AddReferences_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_AddReferences_Call) RunAndReturn(run func(context.Context, string, string, string, string, []objects.BatchReference, uint64) (SimpleResponse, error)) *MockWClient_AddReferences_Call {
	_c.Call.Return(run)
	return _c
}

// Commit provides a mock function with given fields: ctx, host, index, shard, requestID, resp
func (_m *MockWClient) Commit(ctx context.Context, host string, index string, shard string, requestID string, resp interface{}) error {
	ret := _m.Called(ctx, host, index, shard, requestID, resp)

	if len(ret) == 0 {
		panic("no return value specified for Commit")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, interface{}) error); ok {
		r0 = rf(ctx, host, index, shard, requestID, resp)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockWClient_Commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commit'
type MockWClient_Commit_Call struct {
	*mock.Call
}

// Commit is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - resp interface{}
func (_e *MockWClient_Expecter) Commit(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, resp interface{}) *MockWClient_Commit_Call {
	return &MockWClient_Commit_Call{Call: _e.mock.On("Commit", ctx, host, index, shard, requestID, resp)}
}

func (_c *MockWClient_Commit_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, resp interface{})) *MockWClient_Commit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(interface{}))
	})
	return _c
}

func (_c *MockWClient_Commit_Call) Return(_a0 error) *MockWClient_Commit_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWClient_Commit_Call) RunAndReturn(run func(context.Context, string, string, string, string, interface{}) error) *MockWClient_Commit_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObject provides a mock function with given fields: ctx, host, index, shard, requestID, id, deletionTime, schemaVersion
func (_m *MockWClient) DeleteObject(ctx context.Context, host string, index string, shard string, requestID string, id strfmt.UUID, deletionTime time.Time, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, id, deletionTime, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for DeleteObject")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, strfmt.UUID, time.Time, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, id, deletionTime, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, strfmt.UUID, time.Time, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, id, deletionTime, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, strfmt.UUID, time.Time, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, id, deletionTime, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject'
type MockWClient_DeleteObject_Call struct {
	*mock.Call
}

// DeleteObject is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - id strfmt.UUID
//   - deletionTime time.Time
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) DeleteObject(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, id interface{}, deletionTime interface{}, schemaVersion interface{}) *MockWClient_DeleteObject_Call {
	return &MockWClient_DeleteObject_Call{Call: _e.mock.On("DeleteObject", ctx, host, index, shard, requestID, id, deletionTime, schemaVersion)}
}

func (_c *MockWClient_DeleteObject_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, id strfmt.UUID, deletionTime time.Time, schemaVersion uint64)) *MockWClient_DeleteObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(strfmt.UUID), args[6].(time.Time), args[7].(uint64))
	})
	return _c
}

func (_c *MockWClient_DeleteObject_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_DeleteObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_DeleteObject_Call) RunAndReturn(run func(context.Context, string, string, string, string, strfmt.UUID, time.Time, uint64) (SimpleResponse, error)) *MockWClient_DeleteObject_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteObjects provides a mock function with given fields: ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion
func (_m *MockWClient) DeleteObjects(ctx context.Context, host string, index string, shard string, requestID string, uuids []strfmt.UUID, deletionTime time.Time, dryRun bool, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for DeleteObjects")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []strfmt.UUID, time.Time, bool, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []strfmt.UUID, time.Time, bool, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, []strfmt.UUID, time.Time, bool, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_DeleteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjects'
type MockWClient_DeleteObjects_Call struct {
	*mock.Call
}

// DeleteObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - uuids []strfmt.UUID
//   - deletionTime time.Time
//   - dryRun bool
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) DeleteObjects(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, uuids interface{}, deletionTime interface{}, dryRun interface{}, schemaVersion interface{}) *MockWClient_DeleteObjects_Call {
	return &MockWClient_DeleteObjects_Call{Call: _e.mock.On("DeleteObjects", ctx, host, index, shard, requestID, uuids, deletionTime, dryRun, schemaVersion)}
}

func (_c *MockWClient_DeleteObjects_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, uuids []strfmt.UUID, deletionTime time.Time, dryRun bool, schemaVersion uint64)) *MockWClient_DeleteObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].([]strfmt.UUID), args[6].(time.Time), args[7].(bool), args[8].(uint64))
	})
	return _c
}

func (_c *MockWClient_DeleteObjects_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_DeleteObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_DeleteObjects_Call) RunAndReturn(run func(context.Context, string, string, string, string, []strfmt.UUID, time.Time, bool, uint64) (SimpleResponse, error)) *MockWClient_DeleteObjects_Call {
	_c.Call.Return(run)
	return _c
}

// MergeObject provides a mock function with given fields: ctx, host, index, shard, requestID, mergeDoc, schemaVersion
func (_m *MockWClient) MergeObject(ctx context.Context, host string, index string, shard string, requestID string, mergeDoc *objects.MergeDocument, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, mergeDoc, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for MergeObject")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, *objects.MergeDocument, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, mergeDoc, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, *objects.MergeDocument, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, mergeDoc, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, *objects.MergeDocument, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, mergeDoc, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_MergeObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MergeObject'
type MockWClient_MergeObject_Call struct {
	*mock.Call
}

// MergeObject is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - mergeDoc *objects.MergeDocument
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) MergeObject(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, mergeDoc interface{}, schemaVersion interface{}) *MockWClient_MergeObject_Call {
	return &MockWClient_MergeObject_Call{Call: _e.mock.On("MergeObject", ctx, host, index, shard, requestID, mergeDoc, schemaVersion)}
}

func (_c *MockWClient_MergeObject_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, mergeDoc *objects.MergeDocument, schemaVersion uint64)) *MockWClient_MergeObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(*objects.MergeDocument), args[6].(uint64))
	})
	return _c
}

func (_c *MockWClient_MergeObject_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_MergeObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_MergeObject_Call) RunAndReturn(run func(context.Context, string, string, string, string, *objects.MergeDocument, uint64) (SimpleResponse, error)) *MockWClient_MergeObject_Call {
	_c.Call.Return(run)
	return _c
}

// PutObject provides a mock function with given fields: ctx, host, index, shard, requestID, obj, schemaVersion
func (_m *MockWClient) PutObject(ctx context.Context, host string, index string, shard string, requestID string, obj *storobj.Object, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, obj, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for PutObject")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, *storobj.Object, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, obj, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, *storobj.Object, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, obj, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, *storobj.Object, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, obj, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject'
type MockWClient_PutObject_Call struct {
	*mock.Call
}

// PutObject is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - obj *storobj.Object
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) PutObject(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, obj interface{}, schemaVersion interface{}) *MockWClient_PutObject_Call {
	return &MockWClient_PutObject_Call{Call: _e.mock.On("PutObject", ctx, host, index, shard, requestID, obj, schemaVersion)}
}

func (_c *MockWClient_PutObject_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, obj *storobj.Object, schemaVersion uint64)) *MockWClient_PutObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(*storobj.Object), args[6].(uint64))
	})
	return _c
}

func (_c *MockWClient_PutObject_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_PutObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_PutObject_Call) RunAndReturn(run func(context.Context, string, string, string, string, *storobj.Object, uint64) (SimpleResponse, error)) *MockWClient_PutObject_Call {
	_c.Call.Return(run)
	return _c
}

// PutObjects provides a mock function with given fields: ctx, host, index, shard, requestID, objs, schemaVersion
func (_m *MockWClient) PutObjects(ctx context.Context, host string, index string, shard string, requestID string, objs []*storobj.Object, schemaVersion uint64) (SimpleResponse, error) {
	ret := _m.Called(ctx, host, index, shard, requestID, objs, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for PutObjects")
	}

	var r0 SimpleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []*storobj.Object, uint64) (SimpleResponse, error)); ok {
		return rf(ctx, host, index, shard, requestID, objs, schemaVersion)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string, []*storobj.Object, uint64) SimpleResponse); ok {
		r0 = rf(ctx, host, index, shard, requestID, objs, schemaVersion)
	} else {
		r0 = ret.Get(0).(SimpleResponse)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string, []*storobj.Object, uint64) error); ok {
		r1 = rf(ctx, host, index, shard, requestID, objs, schemaVersion)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWClient_PutObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjects'
type MockWClient_PutObjects_Call struct {
	*mock.Call
}

// PutObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - host string
//   - index string
//   - shard string
//   - requestID string
//   - objs []*storobj.Object
//   - schemaVersion uint64
func (_e *MockWClient_Expecter) PutObjects(ctx interface{}, host interface{}, index interface{}, shard interface{}, requestID interface{}, objs interface{}, schemaVersion interface{}) *MockWClient_PutObjects_Call {
	return &MockWClient_PutObjects_Call{Call: _e.mock.On("PutObjects", ctx, host, index, shard, requestID, objs, schemaVersion)}
}

func (_c *MockWClient_PutObjects_Call) Run(run func(ctx context.Context, host string, index string, shard string, requestID string, objs []*storobj.Object, schemaVersion uint64)) *MockWClient_PutObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].([]*storobj.Object), args[6].(uint64))
	})
	return _c
}

func (_c *MockWClient_PutObjects_Call) Return(_a0 SimpleResponse, _a1 error) *MockWClient_PutObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWClient_PutObjects_Call) RunAndReturn(run func(context.Context, string, string, string, string, []*storobj.Object, uint64) (SimpleResponse, error)) *MockWClient_PutObjects_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWClient creates a new instance of MockWClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockWClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWClient {
	mock := &MockWClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
