Merge pull request #7884 from multiversx/todos2

AdoAdoAdo · web-flow · commit 4486bce6a9b2 · 2026-06-29T10:24:42.000+03:00
TODOs part 2
diff --git a/consensus/broadcast/commonMessenger.go b/consensus/broadcast/commonMessenger.go
@@ -171,7 +171,6 @@ func (cm *commonMessenger) BroadcastBlockData(
 	time.Sleep(extraDelayForBroadcast)
 
 	if len(miniBlocks) > 0 {
-		// TODO: check if we need to pack also miniblock into smaller chunks
 		err := cm.BroadcastMiniBlocks(miniBlocks, pkBytes)
 		if err != nil {
 			log.Warn("commonMessenger.BroadcastBlockData: broadcast miniblocks", "error", err.Error())
diff --git a/epochStart/bootstrap/startInEpochScheduled.go b/epochStart/bootstrap/startInEpochScheduled.go
@@ -90,8 +90,9 @@ func (ses *startInEpochWithScheduledDataSyncer) IsInterfaceNil() bool {
 func (ses *startInEpochWithScheduledDataSyncer) getRequiredHeaderByHash(
 	notarizedShardHeader data.ShardHeaderHandler,
 ) (data.ShardHeaderHandler, map[string]data.HeaderHandler, error) {
-	// TODO: analyze the requested headers in this func, after andromeda committed blocks are final
-	//  it might not be needed to request based on prev header
+	if notarizedShardHeader.IsHeaderV3() {
+		return notarizedShardHeader, nil, nil
+	}
 
 	shardIDs, hashesToRequest := getShardIDAndHashesForIncludedMetaBlocks(notarizedShardHeader)
 
@@ -148,10 +149,6 @@ func (ses *startInEpochWithScheduledDataSyncer) getRequiredHeaderByHash(
 		}
 	}
 
-	if notarizedShardHeader.IsHeaderV3() {
-		headerToBeProcessed = notarizedShardHeader
-	}
-
 	return headerToBeProcessed, headers, nil
 }
 
diff --git a/epochStart/bootstrap/startInEpochScheduled_test.go b/epochStart/bootstrap/startInEpochScheduled_test.go
@@ -182,6 +182,28 @@ func TestStartInEpochWithScheduledDataSyncer_UpdateSyncDataIfNeededScheduledEnab
 	require.Equal(t, prevHeader, header)
 }
 
+func TestStartInEpochWithScheduledDataSyncer_getRequiredHeaderByHashV3HeaderShouldShortCircuit(t *testing.T) {
+	t.Parallel()
+
+	args := createDefaultDataSyncerFactoryArgs()
+	syncCalled := false
+	args.HeadersSyncer = &epochStartMocks.HeadersByHashSyncerStub{
+		SyncMissingHeadersByHashCalled: func(shardIDs []uint32, headersHashes [][]byte, ctx context.Context) error {
+			syncCalled = true
+			return nil
+		},
+	}
+	ds, _ := newStartInEpochShardHeaderDataSyncerWithScheduled(args.ScheduledTxsHandler, args.HeadersSyncer, args.MiniBlocksSyncer, args.TxSyncer, 0)
+
+	notarizedShardHeader := &block.HeaderV3{Nonce: 12, Epoch: 2, PrevHash: []byte("prevHash")}
+
+	header, headersMap, err := ds.getRequiredHeaderByHash(notarizedShardHeader)
+	require.Nil(t, err)
+	require.Nil(t, headersMap)
+	require.Equal(t, notarizedShardHeader, header)
+	require.False(t, syncCalled, "no prev-header sync should be performed for V3 headers")
+}
+
 func TestStartInEpochWithScheduledDataSyncer_getRequiredHeaderByHash(t *testing.T) {
 	// TODO: add test
 }
diff --git a/factory/processing/blockProcessorCreator.go b/factory/processing/blockProcessorCreator.go
@@ -394,7 +394,6 @@ func (pcf *processComponentsFactory) newShardBlockProcessor(
 		return nil, err
 	}
 
-	// TODO: evaluate disabling this entirely (for old flows) - the check is not triggered if async enabled but there are still some checks in the old flow
 	blockSizeComputationHandler, err := preprocess.NewBlockSizeComputation(
 		pcf.coreData.InternalMarshalizer(),
 		blockSizeThrottler,
diff --git a/go.mod b/go.mod
@@ -19,7 +19,7 @@ require (
 	github.com/libp2p/go-libp2p-pubsub v0.13.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/multiversx/mx-chain-communication-go v1.3.3-0.20260608072730-982186a1ad78
-	github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618090441-fe4dfcdcb341
+	github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618130450-9b7f1defd425
 	github.com/multiversx/mx-chain-crypto-go v1.3.1
 	github.com/multiversx/mx-chain-es-indexer-go v1.10.3-0.20260608081825-40e586306036
 	github.com/multiversx/mx-chain-logger-go v1.1.0
diff --git a/go.sum b/go.sum
@@ -401,8 +401,8 @@ github.com/multiversx/concurrent-map v0.1.4 h1:hdnbM8VE4b0KYJaGY5yJS2aNIW9TFFsUY
 github.com/multiversx/concurrent-map v0.1.4/go.mod h1:8cWFRJDOrWHOTNSqgYCUvwT7c7eFQ4U2vKMOp4A/9+o=
 github.com/multiversx/mx-chain-communication-go v1.3.3-0.20260608072730-982186a1ad78 h1:vdYSj8Jj83H5wMkQOcDKvBXf2yVLXgVmA1IthHuv3aY=
 github.com/multiversx/mx-chain-communication-go v1.3.3-0.20260608072730-982186a1ad78/go.mod h1:gDVWn6zUW6aCN1YOm/FbbT5MUmhgn/L1Rmpl8EoH3Yg=
-github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618090441-fe4dfcdcb341 h1:Q01qsxt5WFyI2xN/rYwBe3It76CP6G5h+MH37wS+q9g=
-github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618090441-fe4dfcdcb341/go.mod h1:IO+vspNan+gT0WOHnJ95uvWygiziHZvfXpff6KnxV7g=
+github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618130450-9b7f1defd425 h1:Y5mv8pJ7V7Qca28fAuoUoJrgVHb8wjDkSCjD/TzSfAs=
+github.com/multiversx/mx-chain-core-go v1.5.1-0.20260618130450-9b7f1defd425/go.mod h1:IO+vspNan+gT0WOHnJ95uvWygiziHZvfXpff6KnxV7g=
 github.com/multiversx/mx-chain-crypto-go v1.3.1 h1:tCoGkfiv0wz97kuW6AZPW4RVL0Yp7PBo8NKQj9f2oh4=
 github.com/multiversx/mx-chain-crypto-go v1.3.1/go.mod h1:nPIkxxzyTP8IquWKds+22Q2OJ9W7LtusC7cAosz7ojM=
 github.com/multiversx/mx-chain-es-indexer-go v1.10.3-0.20260608081825-40e586306036 h1:a0euQ0LrFvP3y7Uf4CJ39tXBo0tsTEzPLrvJriuO2oA=
diff --git a/process/block/interface.go b/process/block/interface.go
@@ -72,6 +72,7 @@ type MiniBlocksSelectionSession interface {
 	GetNumTxsAdded() uint32
 	AddMiniBlocksAndHashes(miniBlocksAndHashes []block.MiniblockAndHash) error
 	CreateAndAddMiniBlockFromTransactions(txHashes [][]byte) error
+	RemoveEmptyMiniBlocks()
 	IsInterfaceNil() bool
 }
 
diff --git a/process/block/mbsSelectionSession.go b/process/block/mbsSelectionSession.go
@@ -240,6 +240,33 @@ func (s *miniBlocksSelectionSession) AddMiniBlocksAndHashes(miniBlocksAndHashes
 	return nil
 }
 
+// RemoveEmptyMiniBlocks removes any mini blocks that contain no transactions, keeping the internal slices consistent
+func (s *miniBlocksSelectionSession) RemoveEmptyMiniBlocks() {
+	s.mut.Lock()
+	defer s.mut.Unlock()
+
+	filteredMiniBlocks := make(block.MiniBlockSlice, 0, len(s.miniBlocks))
+	filteredHeaders := make([]data.MiniBlockHeaderHandler, 0, len(s.miniBlockHeaderHandlers))
+	filteredHashes := make([][]byte, 0, len(s.miniBlockHashes))
+
+	for i, miniBlock := range s.miniBlocks {
+		if len(miniBlock.GetTxHashes()) == 0 {
+			log.Trace("miniBlocksSelectionSession.RemoveEmptyMiniBlocks: removed empty mini block",
+				"hash", s.miniBlockHashes[i])
+			delete(s.miniBlockHashesUnique, string(s.miniBlockHashes[i]))
+			continue
+		}
+
+		filteredMiniBlocks = append(filteredMiniBlocks, miniBlock)
+		filteredHeaders = append(filteredHeaders, s.miniBlockHeaderHandlers[i])
+		filteredHashes = append(filteredHashes, s.miniBlockHashes[i])
+	}
+
+	s.miniBlocks = filteredMiniBlocks
+	s.miniBlockHeaderHandlers = filteredHeaders
+	s.miniBlockHashes = filteredHashes
+}
+
 // CreateAndAddMiniBlockFromTransactions creates a mini block from the provided transaction hashes
 func (s *miniBlocksSelectionSession) CreateAndAddMiniBlockFromTransactions(txHashes [][]byte) error {
 	if len(txHashes) == 0 {
diff --git a/process/block/mbsSelectionSession_test.go b/process/block/mbsSelectionSession_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/multiversx/mx-chain-core-go/data"
 	"github.com/multiversx/mx-chain-core-go/data/block"
 	"github.com/multiversx/mx-chain-core-go/marshal/factory"
 	"github.com/stretchr/testify/require"
@@ -230,6 +231,42 @@ func TestMiniBlockSelectionSession_CreateAndAddMiniBlockFromTransactions(t *test
 	})
 }
 
+func TestMiniBlocksSelectionSession_RemoveEmptyMiniBlocks(t *testing.T) {
+	t.Parallel()
+
+	marshaller := &testscommon.MarshallerStub{}
+	hasher := &testscommon.HasherStub{}
+
+	newMbHeader := func(hash []byte, txCount uint32) *block.MiniBlockHeader {
+		return &block.MiniBlockHeader{Hash: hash, SenderShardID: 1, ReceiverShardID: 1, TxCount: txCount, Type: block.TxBlock}
+	}
+
+	session, _ := NewMiniBlocksSelectionSession(1, marshaller, hasher)
+	emptyMb := &block.MiniBlock{TxHashes: nil}
+	emptyHash := []byte("emptyHash")
+	nonEmptyMb := &block.MiniBlock{TxHashes: [][]byte{[]byte("tx1")}}
+	nonEmptyHash := []byte("nonEmptyHash")
+
+	session.miniBlocks = block.MiniBlockSlice{emptyMb, nonEmptyMb}
+	session.miniBlockHeaderHandlers = []data.MiniBlockHeaderHandler{newMbHeader(emptyHash, 0), newMbHeader(nonEmptyHash, 1)}
+	session.miniBlockHashes = [][]byte{emptyHash, nonEmptyHash}
+	session.miniBlockHashesUnique[string(emptyHash)] = struct{}{}
+	session.miniBlockHashesUnique[string(nonEmptyHash)] = struct{}{}
+
+	session.RemoveEmptyMiniBlocks()
+
+	require.Len(t, session.GetMiniBlocks(), 1)
+	require.Len(t, session.GetMiniBlockHeaderHandlers(), 1)
+	require.Len(t, session.GetMiniBlockHashes(), 1)
+	require.Equal(t, nonEmptyMb, session.GetMiniBlocks()[0])
+	require.Equal(t, nonEmptyHash, session.GetMiniBlockHashes()[0])
+
+	_, exists := session.miniBlockHashesUnique[string(emptyHash)]
+	require.False(t, exists)
+	_, exists = session.miniBlockHashesUnique[string(nonEmptyHash)]
+	require.True(t, exists)
+}
+
 func TestMiniBlocksSelectionSession_AddReferencedMetaBlock(t *testing.T) {
 	t.Parallel()
 
diff --git a/process/block/metablockProposal.go b/process/block/metablockProposal.go
@@ -170,19 +170,6 @@ func (mp *metaProcessor) CreateBlockProposal(
 		return nil, nil, err
 	}
 
-	txsInExecutionResults, err := getTxCountExecutionResults(metaHdr)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	totalProcessedTxs := getTxCount(shardDataHandlers) + txsInExecutionResults
-	// TODO: consider if tx count per metablock header is still needed
-	// as we still have it in the execution results
-	err = metaHdr.SetTxCount(totalProcessedTxs)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	marshalledBody, err := mp.marshalizer.Marshal(body)
 	if err != nil {
 		return nil, nil, err
diff --git a/process/block/metrics.go b/process/block/metrics.go
@@ -42,12 +42,26 @@ func getMetricsFromMetaHeader(
 	}
 
 	appStatusHandler.SetUInt64Value(common.MetricHeaderSize, headerSize)
-	appStatusHandler.SetUInt64Value(common.MetricNumTxInBlock, uint64(header.GetTxCount()))
+	appStatusHandler.SetUInt64Value(common.MetricNumTxInBlock, uint64(getMetaHeaderTxCount(header)))
 	appStatusHandler.SetUInt64Value(common.MetricNumMiniBlocks, numMiniBlocksMetaBlock)
 	appStatusHandler.SetUInt64Value(common.MetricNumShardHeadersProcessed, numShardHeadersProcessed)
 	appStatusHandler.SetUInt64Value(common.MetricNumShardHeadersFromPool, uint64(numShardHeadersFromPool))
 }
 
+func getMetaHeaderTxCount(header data.MetaHeaderHandler) uint32 {
+	if !header.IsHeaderV3() {
+		return header.GetTxCount()
+	}
+
+	txsInExecutionResults, err := getTxCountExecutionResults(header)
+	if err != nil {
+		log.Debug("getMetaHeaderTxCount: failed to compute tx count from execution results", "error", err)
+		return 0
+	}
+
+	return getTxCount(header.GetShardInfoHandlers()) + txsInExecutionResults
+}
+
 func getMetricsFromBlockBody(
 	body *block.Body,
 	marshalizer marshal.Marshalizer,
diff --git a/process/block/preprocess/interfaces.go b/process/block/preprocess/interfaces.go
@@ -74,6 +74,7 @@ type TxsForBlockHandler interface {
 	GetTxInfoByHash(hash []byte) (*process.TxInfo, bool)
 	GetAllCurrentUsedTxs() map[string]data.TransactionHandler
 	GetMissingTxsCount() int
+	ClearMissingTxsCount()
 	ReceivedTransaction(txHash []byte, tx data.TransactionHandler)
 	HasMissingTransactions() bool
 	ComputeExistingAndRequestMissing(
diff --git a/process/block/preprocess/rewardTxPreProcessor.go b/process/block/preprocess/rewardTxPreProcessor.go
@@ -101,7 +101,7 @@ func (rtp *rewardTxPreprocessor) IsDataPrepared(requestedRewardTxs int, haveTime
 			"num reward txs", requestedRewardTxs)
 		err := rtp.rewardTxsForBlock.WaitForRequestedData(haveTime())
 		missingRewardTxs := rtp.rewardTxsForBlock.GetMissingTxsCount()
-		// TODO: previously the number of missing reward txs was cleared in rewardTxsForBlock - check if this is still needed
+		rtp.rewardTxsForBlock.ClearMissingTxsCount()
 		log.Debug("received reward txs",
 			"num reward txs", requestedRewardTxs-missingRewardTxs)
 		if err != nil {
diff --git a/process/block/preprocess/smartContractResults.go b/process/block/preprocess/smartContractResults.go
@@ -113,7 +113,7 @@ func (scr *smartContractResults) IsDataPrepared(requestedScrs int, haveTime func
 			"num scrs", requestedScrs)
 		err := scr.scrForBlock.WaitForRequestedData(haveTime())
 		missingScrs := scr.scrForBlock.GetMissingTxsCount()
-		// TODO: previously the number of missing txs was cleared in scrForBlock - check if this is still needed
+		scr.scrForBlock.ClearMissingTxsCount()
 		log.Debug("received missing scrs",
 			"num scrs", requestedScrs-missingScrs)
 		if err != nil {
diff --git a/process/block/preprocess/transactions.go b/process/block/preprocess/transactions.go
@@ -191,7 +191,7 @@ func (txs *transactions) IsDataPrepared(requestedTxs int, haveTime func() time.D
 		log.Debug("requested missing txs", "num txs", requestedTxs)
 		err := txs.txsForCurrBlock.WaitForRequestedData(haveTime())
 		missingTxs := txs.txsForCurrBlock.GetMissingTxsCount()
-		// TODO: previously the number of missing txs was cleared in txsForCurrentBlock - check if this is still needed
+		txs.txsForCurrBlock.ClearMissingTxsCount()
 		log.Debug("received missing txs", "num txs", requestedTxs-missingTxs, "requested", requestedTxs, "missing", missingTxs)
 		if err != nil {
 			return err
@@ -914,8 +914,6 @@ func (txs *transactions) processAndRemoveBadTransaction(
 	}
 	if isNotExecutable {
 		txs.txExecutionOrderHandler.Remove(txHash)
-		// TODO: remove log if no longer needed for validation
-		log.Debug("processAndRemoveBadTransaction - found not executable transaction", "txHash", txHash)
 		if !isAsyncExecEnabled {
 			strCache := process.ShardCacherIdentifier(sndShardId, dstShardId)
 			txs.txPool.RemoveData(txHash, strCache)
diff --git a/process/block/preprocess/txsForBlock.go b/process/block/preprocess/txsForBlock.go
@@ -126,6 +126,14 @@ func (tfb *txsForBlock) GetMissingTxsCount() int {
 	return tfb.numMissingTxs
 }
 
+// ClearMissingTxsCount resets the missing transactions counter to zero
+func (tfb *txsForBlock) ClearMissingTxsCount() {
+	tfb.mutTxsForBlock.Lock()
+	defer tfb.mutTxsForBlock.Unlock()
+
+	tfb.numMissingTxs = 0
+}
+
 // ComputeExistingAndRequestMissing processes the block body to compute existing transactions (in the node tx pool) and request missing ones.
 func (tfb *txsForBlock) ComputeExistingAndRequestMissing(
 	body *block.Body,
diff --git a/process/block/preprocess/txsForBlock_test.go b/process/block/preprocess/txsForBlock_test.go
@@ -310,6 +310,44 @@ func TestTxsForBlock_GetMissingTxsCount(t *testing.T) {
 	require.Equal(t, 10, tfb.GetMissingTxsCount())
 }
 
+func TestTxsForBlock_ClearMissingTxsCount(t *testing.T) {
+	t.Parallel()
+
+	shardCoordinator := &mock.ShardCoordinatorMock{}
+
+	t.Run("clears the missing counter", func(t *testing.T) {
+		t.Parallel()
+
+		tfb, _ := NewTxsForBlock(shardCoordinator)
+		tfb.numMissingTxs = 7
+
+		tfb.ClearMissingTxsCount()
+		require.Equal(t, 0, tfb.GetMissingTxsCount())
+		require.False(t, tfb.HasMissingTransactions())
+	})
+	t.Run("late received transaction does not fire stale channel signal after clearing", func(t *testing.T) {
+		t.Parallel()
+
+		tfb, _ := NewTxsForBlock(shardCoordinator)
+		txHash := []byte("hash1")
+		tfb.txHashAndInfo[string(txHash)] = &process.TxInfo{TxShardInfo: &process.TxShardInfo{}}
+		tfb.numMissingTxs = 1
+
+		// simulate the wait timing out and the count being cleared right after
+		tfb.ClearMissingTxsCount()
+
+		// a late received transaction for a previously missing hash must be ignored
+		tfb.ReceivedTransaction(txHash, &transaction.Transaction{Nonce: 1})
+		require.Equal(t, 0, tfb.numMissingTxs)
+
+		select {
+		case <-tfb.chRcvAllTxs:
+			require.Fail(t, "no stale signal should be sent on chRcvAllTxs after clearing")
+		case <-time.After(100 * time.Millisecond):
+		}
+	})
+}
+
 func TestTxsForBlock_GetAllCurrentUsedTxs(t *testing.T) {
 	t.Parallel()
 
diff --git a/process/block/shardblockProposal.go b/process/block/shardblockProposal.go
@@ -348,7 +348,6 @@ func (sp *shardProcessor) ProcessBlockProposal(
 		return nil, err
 	}
 
-	// TODO: check again before saving the last executed result
 	err = sp.blockChainHook.SetCurrentHeader(header)
 	if err != nil {
 		return nil, err
@@ -654,7 +653,7 @@ func (sp *shardProcessor) createProposalMiniBlocks(
 		return err
 	}
 
-	// todo: maybe sanitize, removing empty miniBlocks
+	sp.miniBlocksSelectionSession.RemoveEmptyMiniBlocks()
 
 	return nil
 }
diff --git a/process/block/shardinfo_test.go b/process/block/shardinfo_test.go
diff --git a/process/coordinator/process.go b/process/coordinator/process.go
diff --git a/process/estimator/executionResultInclusionEstimator.go b/process/estimator/executionResultInclusionEstimator.go
diff --git a/process/track/shardBlockTrack_test.go b/process/track/shardBlockTrack_test.go
diff --git a/testscommon/mbSelection/mbSelectionSessionStub.go b/testscommon/mbSelection/mbSelectionSessionStub.go
diff --git a/testscommon/preprocMocks/txsForBlockStub.go b/testscommon/preprocMocks/txsForBlockStub.go
diff --git a/txcache/txCache_test.go b/txcache/txCache_test.go

Original file line number	Diff line number	Diff line change
`@@ -90,8 +90,9 @@ func (ses *startInEpochWithScheduledDataSyncer) IsInterfaceNil() bool {`
`90`	`90`	`func (ses *startInEpochWithScheduledDataSyncer) getRequiredHeaderByHash(`
`91`	`91`	`notarizedShardHeader data.ShardHeaderHandler,`
`92`	`92`	`) (data.ShardHeaderHandler, map[string]data.HeaderHandler, error) {`
`93`		`- // TODO: analyze the requested headers in this func, after andromeda committed blocks are final`
`94`		`- // it might not be needed to request based on prev header`
	`93`	`+ if notarizedShardHeader.IsHeaderV3() {`
	`94`	`+ return notarizedShardHeader, nil, nil`
	`95`	`+ }`
`95`	`96`
`96`	`97`	`shardIDs, hashesToRequest := getShardIDAndHashesForIncludedMetaBlocks(notarizedShardHeader)`
`97`	`98`
`@@ -148,10 +149,6 @@ func (ses *startInEpochWithScheduledDataSyncer) getRequiredHeaderByHash(`
`148`	`149`	`}`
`149`	`150`	`}`
`150`	`151`
`151`		`- if notarizedShardHeader.IsHeaderV3() {`
`152`		`- headerToBeProcessed = notarizedShardHeader`
`153`		`- }`
`154`		`-`
`155`	`152`	`return headerToBeProcessed, headers, nil`
`156`	`153`	`}`
`157`	`154`
Original file line number	Diff line number	Diff line change
`@@ -394,7 +394,6 @@ func (pcf *processComponentsFactory) newShardBlockProcessor(`
`394`	`394`	`return nil, err`
`395`	`395`	`}`
`396`	`396`
`397`		`- // TODO: evaluate disabling this entirely (for old flows) - the check is not triggered if async enabled but there are still some checks in the old flow`
`398`	`397`	`blockSizeComputationHandler, err := preprocess.NewBlockSizeComputation(`
`399`	`398`	`pcf.coreData.InternalMarshalizer(),`
`400`	`399`	`blockSizeThrottler,`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,7 @@ type MiniBlocksSelectionSession interface {`
`72`	`72`	`GetNumTxsAdded() uint32`
`73`	`73`	`AddMiniBlocksAndHashes(miniBlocksAndHashes []block.MiniblockAndHash) error`
`74`	`74`	`CreateAndAddMiniBlockFromTransactions(txHashes [][]byte) error`
	`75`	`+ RemoveEmptyMiniBlocks()`
`75`	`76`	`IsInterfaceNil() bool`
`76`	`77`	`}`
`77`	`78`