keep scan counters guard until result delivery (#19298)

swalrus1 · web-flow · commit 2df3e616e8e1 · 2025-06-05T10:32:04.000Z
diff --git a/ydb/core/tx/columnshard/columnshard_private_events.h b/ydb/core/tx/columnshard/columnshard_private_events.h
@@ -6,6 +6,7 @@
 
 #include <ydb/core/formats/arrow/special_keys.h>
 #include <ydb/core/protos/counters_columnshard.pb.h>
+#include <ydb/core/tx/columnshard/counters/scan.h>
 #include <ydb/core/tx/columnshard/engines/column_engine.h>
 #include <ydb/core/tx/columnshard/engines/writer/indexed_blob_constructor.h>
 #include <ydb/core/tx/columnshard/engines/writer/write_controller.h>
@@ -118,14 +119,17 @@ struct TEvPrivate {
     class TEvTaskProcessedResult: public NActors::TEventLocal<TEvTaskProcessedResult, EvTaskProcessedResult> {
     private:
         TConclusion<std::shared_ptr<NOlap::NReader::IApplyAction>> Result;
+        TCounterGuard ScanCounter;
 
     public:
         TConclusion<std::shared_ptr<NOlap::NReader::IApplyAction>> ExtractResult() {
             return std::move(Result);
         }
 
-        TEvTaskProcessedResult(const TConclusion<std::shared_ptr<NOlap::NReader::IApplyAction>>& result)
-            : Result(result) {
+        TEvTaskProcessedResult(
+            const TConclusion<std::shared_ptr<NOlap::NReader::IApplyAction>>& result, TCounterGuard&& scanCounters)
+            : Result(result)
+            , ScanCounter(std::move(scanCounters)) {
         }
     };
 
diff --git a/ydb/core/tx/columnshard/engines/reader/abstract/read_context.h b/ydb/core/tx/columnshard/engines/reader/abstract/read_context.h
@@ -88,8 +88,8 @@ class TReadContext {
 
     void AbortWithError(const TString& errorMessage) {
         if (AbortionFlag->Inc() == 1) {
-            NActors::TActivationContext::Send(
-                ScanActorId, std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(TConclusionStatus::Fail(errorMessage)));
+            NActors::TActivationContext::Send(ScanActorId, std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(
+                                                               TConclusionStatus::Fail(errorMessage), Counters.GetResultsForReplyGuard()));
         }
     }
 
diff --git a/ydb/core/tx/columnshard/engines/reader/actor/actor.cpp b/ydb/core/tx/columnshard/engines/reader/actor/actor.cpp
@@ -84,7 +84,6 @@ void TColumnShardScan::HandleScan(NColumnShard::TEvPrivate::TEvTaskProcessedResu
     } else {
         ACFL_DEBUG("event", "TEvTaskProcessedResult");
         auto t = static_pointer_cast<IApplyAction>(result.GetResult());
-        Y_DEBUG_ABORT_UNLESS(dynamic_pointer_cast<IDataTasksProcessor::ITask>(result.GetResult()));
         if (!ScanIterator->Finished()) {
             ScanIterator->Apply(t);
         }
diff --git a/ydb/core/tx/columnshard/engines/reader/common/conveyor_task.cpp b/ydb/core/tx/columnshard/engines/reader/common/conveyor_task.cpp
@@ -7,16 +7,17 @@ namespace NKikimr::NOlap::NReader {
 void IDataTasksProcessor::ITask::DoExecute(const std::shared_ptr<NConveyor::ITask>& taskPtr) {
     auto result = DoExecuteImpl();
     if (result.IsFail()) {
-        NActors::TActivationContext::AsActorContext().Send(OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(result));
-    } else {
         NActors::TActivationContext::AsActorContext().Send(
-            OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(static_pointer_cast<IDataTasksProcessor::ITask>(taskPtr)));
+            OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(result, std::move(Guard)));
+    } else {
+        NActors::TActivationContext::AsActorContext().Send(OwnerId,
+            new NColumnShard::TEvPrivate::TEvTaskProcessedResult(static_pointer_cast<IDataTasksProcessor::ITask>(taskPtr), std::move(Guard)));
     }
 }
 
 void IDataTasksProcessor::ITask::DoOnCannotExecute(const TString& reason) {
     NActors::TActivationContext::AsActorContext().Send(
-        OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(TConclusionStatus::Fail(reason)));
+        OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(TConclusionStatus::Fail(reason), std::move(Guard)));
 }
 
 }
diff --git a/ydb/core/tx/columnshard/engines/reader/common/conveyor_task.h b/ydb/core/tx/columnshard/engines/reader/common/conveyor_task.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <ydb/core/tx/columnshard/counters/scan.h>
 #include <ydb/core/tx/conveyor/usage/abstract.h>
 
 #include <ydb/library/accessor/accessor.h>
@@ -17,6 +18,7 @@ class IApplyAction {
     bool Apply(IDataReader& indexedDataRead) const {
         return DoApply(indexedDataRead);
     }
+    virtual ~IApplyAction() = default;
 };
 
 class IDataTasksProcessor {
@@ -25,6 +27,7 @@ class IDataTasksProcessor {
     private:
         using TBase = NConveyor::ITask;
         const NActors::TActorId OwnerId;
+        NColumnShard::TCounterGuard Guard;
         virtual TConclusionStatus DoExecuteImpl() = 0;
 
     protected:
@@ -35,10 +38,9 @@ class IDataTasksProcessor {
         using TPtr = std::shared_ptr<ITask>;
         virtual ~ITask() = default;
 
-        ITask(const NActors::TActorId& ownerId)
+        ITask(const NActors::TActorId& ownerId, NColumnShard::TCounterGuard&& scanCounter)
             : OwnerId(ownerId)
-        {
-
+            , Guard(std::move(scanCounter)) {
         }
     };
 };
diff --git a/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/constructor.cpp b/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/constructor.cpp
@@ -19,9 +19,12 @@ bool TBlobsFetcherTask::DoOnError(const TString& storageId, const TBlobRange& ra
     AFL_ERROR(NKikimrServices::TX_COLUMNSHARD_SCAN)("error_on_blob_reading", range.ToString())(
         "scan_actor_id", Context->GetCommonContext()->GetScanActorId())("status", status.GetErrorMessage())("status_code", status.GetStatus())(
         "storage_id", storageId);
-    NActors::TActorContext::AsActorContext().Send(
-        Context->GetCommonContext()->GetScanActorId(), std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(
-                                                           TConclusionStatus::Fail(TStringBuilder{} << "Error reading blob range for data: " << range.ToString() << ", error: " << status.GetErrorMessage() << ", status: " << NKikimrProto::EReplyStatus_Name(status.GetStatus()))));
+    NActors::TActorContext::AsActorContext().Send(Context->GetCommonContext()->GetScanActorId(),
+        std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(
+            TConclusionStatus::Fail(TStringBuilder{} << "Error reading blob range for data: " << range.ToString()
+                                                     << ", error: " << status.GetErrorMessage()
+                                                     << ", status: " << NKikimrProto::EReplyStatus_Name(status.GetStatus())),
+            std::move(Guard)));
     return false;
 }
 
diff --git a/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/constructor.h b/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/constructor.h
@@ -74,15 +74,18 @@ class TColumnsFetcherTask: public NBlobOperations::NRead::ITask, public NColumnS
     THashMap<ui32, std::shared_ptr<IKernelFetchLogic>> DataFetchers;
     TFetchingScriptCursor Cursor;
     NBlobOperations::NRead::TCompositeReadBlobs ProvidedBlobs;
-    const NColumnShard::TCounterGuard Guard;
+    NColumnShard::TCounterGuard Guard;
     virtual void DoOnDataReady(const std::shared_ptr<NResourceBroker::NSubscribe::TResourcesGuard>& resourcesGuard) override;
     virtual bool DoOnError(const TString& storageId, const TBlobRange& range, const IBlobsReadingAction::TErrorStatus& status) override {
         AFL_ERROR(NKikimrServices::TX_COLUMNSHARD_SCAN)("error_on_blob_reading", range.ToString())(
             "scan_actor_id", Source->GetContext()->GetCommonContext()->GetScanActorId())("status", status.GetErrorMessage())(
             "status_code", status.GetStatus())("storage_id", storageId);
         NActors::TActorContext::AsActorContext().Send(Source->GetContext()->GetCommonContext()->GetScanActorId(),
             std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(
-                TConclusionStatus::Fail(TStringBuilder{} << "Error reading blob range for columns: " << range.ToString() << ", error: " << status.GetErrorMessage() << ", status: " << NKikimrProto::EReplyStatus_Name(status.GetStatus()))));
+                TConclusionStatus::Fail(TStringBuilder{} << "Error reading blob range for columns: " << range.ToString()
+                                                         << ", error: " << status.GetErrorMessage()
+                                                         << ", status: " << NKikimrProto::EReplyStatus_Name(status.GetStatus())),
+                std::move(Guard)));
         return false;
     }
 
@@ -105,7 +108,7 @@ class TBlobsFetcherTask: public NBlobOperations::NRead::ITask, public NColumnSha
     const std::shared_ptr<IDataSource> Source;
     TFetchingScriptCursor Step;
     const std::shared_ptr<TSpecialReadContext> Context;
-    const NColumnShard::TCounterGuard Guard;
+    NColumnShard::TCounterGuard Guard;
 
     virtual void DoOnDataReady(const std::shared_ptr<NResourceBroker::NSubscribe::TResourcesGuard>& resourcesGuard) override;
     virtual bool DoOnError(const TString& storageId, const TBlobRange& range, const IBlobsReadingAction::TErrorStatus& status) override;
diff --git a/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetch_steps.cpp b/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetch_steps.cpp
@@ -74,12 +74,11 @@ TAllocateMemoryStep::TFetchingStepAllocation::TFetchingStepAllocation(const std:
 
 void TAllocateMemoryStep::TFetchingStepAllocation::DoOnAllocationImpossible(const TString& errorMessage) {
     auto sourcePtr = Source.lock();
+    AFL_WARN(NKikimrServices::TX_COLUMNSHARD_SCAN)("event", "allocation_impossible")("error", errorMessage);
     if (sourcePtr) {
         FOR_DEBUG_LOG(NKikimrServices::COLUMNSHARD_SCAN_EVLOG, sourcePtr->AddEvent("fail_malloc"));
         sourcePtr->GetContext()->GetCommonContext()->AbortWithError(
             "cannot allocate memory for step " + Step.GetName() + ": '" + errorMessage + "'");
-    } else {
-        AFL_WARN(NKikimrServices::TX_COLUMNSHARD_SCAN)("event", "allocation_impossible")("error", errorMessage);
     }
 }
 
diff --git a/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetching.cpp b/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetching.cpp
@@ -38,10 +38,9 @@ TConclusionStatus TStepAction::DoExecuteImpl() {
 
 TStepAction::TStepAction(const std::shared_ptr<IDataSource>& source, TFetchingScriptCursor&& cursor, const NActors::TActorId& ownerActorId,
     const bool changeSyncSection)
-    : TBase(ownerActorId)
+    : TBase(ownerActorId, source->GetContext()->GetCommonContext()->GetCounters().GetAssembleTasksGuard())
     , Source(source)
-    , Cursor(std::move(cursor))
-    , CountersGuard(Source->GetContext()->GetCommonContext()->GetCounters().GetAssembleTasksGuard()) {
+    , Cursor(std::move(cursor)) {
     if (changeSyncSection) {
         Source->StartAsyncSection();
     } else {
diff --git a/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetching.h b/ydb/core/tx/columnshard/engines/reader/common_reader/iterator/fetching.h
@@ -320,7 +320,6 @@ class TStepAction: public IDataTasksProcessor::ITask {
     std::shared_ptr<IDataSource> Source;
     TFetchingScriptCursor Cursor;
     bool FinishedFlag = false;
-    const NColumnShard::TCounterGuard CountersGuard;
 
 protected:
     virtual bool DoApply(IDataReader& owner) const override;
diff --git a/ydb/core/tx/columnshard/engines/reader/plain_reader/iterator/merge.h b/ydb/core/tx/columnshard/engines/reader/plain_reader/iterator/merge.h
@@ -61,7 +61,6 @@ class TBaseMergeTask: public IDataTasksProcessor::ITask, public NGroupedMemoryMa
 protected:
     std::shared_ptr<arrow::Table> ResultBatch;
     std::shared_ptr<arrow::RecordBatch> LastPK;
-    const NColumnShard::TCounterGuard Guard;
     std::shared_ptr<TSpecialReadContext> Context;
     mutable std::unique_ptr<NArrow::NMerger::TMergePartialStream> Merger;
     std::shared_ptr<TMergingContext> MergingContext;
@@ -83,9 +82,8 @@ class TBaseMergeTask: public IDataTasksProcessor::ITask, public NGroupedMemoryMa
 
 public:
     TBaseMergeTask(const std::shared_ptr<TMergingContext>& mergingContext, const std::shared_ptr<TSpecialReadContext>& readContext)
-        : TBase(readContext->GetCommonContext()->GetScanActorId())
+        : TBase(readContext->GetCommonContext()->GetScanActorId(), readContext->GetCommonContext()->GetCounters().GetMergeTasksGuard())
         , IAllocation(TValidator::CheckNotNull(mergingContext)->GetIntervalChunkMemory())
-        , Guard(readContext->GetCommonContext()->GetCounters().GetMergeTasksGuard())
         , Context(readContext)
         , MergingContext(mergingContext)
         , IntervalIdx(MergingContext->GetIntervalIdx()) {
diff --git a/ydb/core/tx/columnshard/engines/reader/simple_reader/iterator/fetching.cpp b/ydb/core/tx/columnshard/engines/reader/simple_reader/iterator/fetching.cpp
@@ -108,30 +108,18 @@ TConclusion<bool> TDetectInMem::DoExecuteInplace(const std::shared_ptr<IDataSour
 }
 
 namespace {
-class TApplySourceResult: public IDataTasksProcessor::ITask {
+class TApplySourceResult: public IApplyAction {
 private:
     using TBase = IDataTasksProcessor::ITask;
     YDB_READONLY_DEF(std::shared_ptr<IDataSource>, Source);
-    NColumnShard::TCounterGuard Guard;
     TFetchingScriptCursor Step;
 
 public:
-    virtual TString GetTaskClassIdentifier() const override {
-        return "TApplySourceResult";
-    }
-
-    TApplySourceResult(
-        const std::shared_ptr<IDataSource>& source, const TFetchingScriptCursor& step)
-        : TBase(NActors::TActorId())
-        , Source(source)
-        , Guard(source->GetContext()->GetCommonContext()->GetCounters().GetResultsForSourceGuard())
+    TApplySourceResult(const std::shared_ptr<IDataSource>& source, const TFetchingScriptCursor& step)
+        : Source(source)
         , Step(step) {
     }
 
-    virtual TConclusionStatus DoExecuteImpl() override {
-        AFL_VERIFY(false)("event", "not applicable");
-        return TConclusionStatus::Success();
-    }
     virtual bool DoApply(IDataReader& indexedDataRead) const override {
         auto* plainReader = static_cast<TPlainReadData*>(&indexedDataRead);
         Source->SetCursor(Step);
@@ -169,7 +157,8 @@ TConclusion<bool> TBuildResultStep::DoExecuteInplace(const std::shared_ptr<IData
     }
     source->MutableStageResult().SetResultChunk(std::move(resultBatch), StartIndex, RecordsCount);
     NActors::TActivationContext::AsActorContext().Send(context->GetCommonContext()->GetScanActorId(),
-        new NColumnShard::TEvPrivate::TEvTaskProcessedResult(std::make_shared<TApplySourceResult>(source, step)));
+        new NColumnShard::TEvPrivate::TEvTaskProcessedResult(std::make_shared<TApplySourceResult>(source, step),
+            source->GetContext()->GetCommonContext()->GetCounters().GetResultsForSourceGuard()));
     return false;
 }
 
diff --git a/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h b/ydb/core/tx/columnshard/engines/reader/sys_view/chunks/chunks.h
@@ -70,27 +70,16 @@ class TStatsIterator: public NAbstract::TStatsIterator<NKikimr::NSysView::Schema
     virtual ui32 PredictRecordsCount(const NAbstract::TGranuleMetaView& granule) const override;
     void AppendStats(const std::vector<std::unique_ptr<arrow::ArrayBuilder>>& builders, const TPortionDataAccessor& portion) const;
 
-    class TApplyResult: public IDataTasksProcessor::ITask {
+    class TApplyResult: public IApplyAction {
     private:
         using TBase = IDataTasksProcessor::ITask;
         YDB_READONLY_DEF(std::vector<TPortionDataAccessor>, Accessors);
-        NColumnShard::TCounterGuard WaitingCountersGuard;
-    public:
-        TString GetTaskClassIdentifier() const override {
-            return "TApplyResult";
-        }
 
-        TApplyResult(const std::vector<TPortionDataAccessor>& accessors, NColumnShard::TCounterGuard&& waitingCountersGuard)
-            : TBase(NActors::TActorId())
-            , Accessors(accessors)
-            , WaitingCountersGuard(std::move(waitingCountersGuard))
-        {
+    public:
+        TApplyResult(const std::vector<TPortionDataAccessor>& accessors)
+            : Accessors(accessors) {
         }
 
-        virtual TConclusionStatus DoExecuteImpl() override {
-            AFL_VERIFY(false)("event", "not applicable");
-            return TConclusionStatus::Success();
-        }
         virtual bool DoApply(IDataReader& /*indexedDataRead*/) const override {
             AFL_VERIFY(false);
             return false;
@@ -119,12 +108,13 @@ class TStatsIterator: public NAbstract::TStatsIterator<NKikimr::NSysView::Schema
         virtual void DoOnRequestsFinished(TDataAccessorsResult&& result) override {
             if (result.HasErrors()) {
                 NActors::TActivationContext::AsActorContext().Send(
-                    OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(TConclusionStatus::Fail("cannot fetch accessors")));
+                    OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(
+                                 TConclusionStatus::Fail("cannot fetch accessors"), std::move(WaitingCountersGuard)));
             } else {
                 AFL_VERIFY(result.GetPortions().size() == 1)("count", result.GetPortions().size());
                 NActors::TActivationContext::AsActorContext().Send(
                     OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(
-                                 std::make_shared<TApplyResult>(result.ExtractPortionsVector(), std::move(WaitingCountersGuard))));
+                                 std::make_shared<TApplyResult>(result.ExtractPortionsVector()), std::move(WaitingCountersGuard)));
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -88,8 +88,8 @@ class TReadContext {`
`88`	`88`
`89`	`89`	`void AbortWithError(const TString& errorMessage) {`
`90`	`90`	`if (AbortionFlag->Inc() == 1) {`
`91`		`- NActors::TActivationContext::Send(`
`92`		`- ScanActorId, std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(TConclusionStatus::Fail(errorMessage)));`
	`91`	`+ NActors::TActivationContext::Send(ScanActorId, std::make_unique<NColumnShard::TEvPrivate::TEvTaskProcessedResult>(`
	`92`	`+ TConclusionStatus::Fail(errorMessage), Counters.GetResultsForReplyGuard()));`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,6 @@ void TColumnShardScan::HandleScan(NColumnShard::TEvPrivate::TEvTaskProcessedResu`
`84`	`84`	`} else {`
`85`	`85`	`ACFL_DEBUG("event", "TEvTaskProcessedResult");`
`86`	`86`	`auto t = static_pointer_cast<IApplyAction>(result.GetResult());`
`87`		`- Y_DEBUG_ABORT_UNLESS(dynamic_pointer_cast<IDataTasksProcessor::ITask>(result.GetResult()));`
`88`	`87`	`if (!ScanIterator->Finished()) {`
`89`	`88`	`ScanIterator->Apply(t);`
`90`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,16 +7,17 @@ namespace NKikimr::NOlap::NReader {`
`7`	`7`	`void IDataTasksProcessor::ITask::DoExecute(const std::shared_ptr<NConveyor::ITask>& taskPtr) {`
`8`	`8`	`auto result = DoExecuteImpl();`
`9`	`9`	`if (result.IsFail()) {`
`10`		`- NActors::TActivationContext::AsActorContext().Send(OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(result));`
`11`		`- } else {`
`12`	`10`	`NActors::TActivationContext::AsActorContext().Send(`
`13`		`- OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(static_pointer_cast<IDataTasksProcessor::ITask>(taskPtr)));`
	`11`	`+ OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(result, std::move(Guard)));`
	`12`	`+ } else {`
	`13`	`+ NActors::TActivationContext::AsActorContext().Send(OwnerId,`
	`14`	`+ new NColumnShard::TEvPrivate::TEvTaskProcessedResult(static_pointer_cast<IDataTasksProcessor::ITask>(taskPtr), std::move(Guard)));`
`14`	`15`	`}`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`void IDataTasksProcessor::ITask::DoOnCannotExecute(const TString& reason) {`
`18`	`19`	`NActors::TActivationContext::AsActorContext().Send(`
`19`		`- OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(TConclusionStatus::Fail(reason)));`
	`20`	`+ OwnerId, new NColumnShard::TEvPrivate::TEvTaskProcessedResult(TConclusionStatus::Fail(reason), std::move(Guard)));`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,12 +74,11 @@ TAllocateMemoryStep::TFetchingStepAllocation::TFetchingStepAllocation(const std:`
`74`	`74`
`75`	`75`	`void TAllocateMemoryStep::TFetchingStepAllocation::DoOnAllocationImpossible(const TString& errorMessage) {`
`76`	`76`	`auto sourcePtr = Source.lock();`
	`77`	`+ AFL_WARN(NKikimrServices::TX_COLUMNSHARD_SCAN)("event", "allocation_impossible")("error", errorMessage);`
`77`	`78`	`if (sourcePtr) {`
`78`	`79`	`FOR_DEBUG_LOG(NKikimrServices::COLUMNSHARD_SCAN_EVLOG, sourcePtr->AddEvent("fail_malloc"));`
`79`	`80`	`sourcePtr->GetContext()->GetCommonContext()->AbortWithError(`
`80`	`81`	`"cannot allocate memory for step " + Step.GetName() + ": '" + errorMessage + "'");`
`81`		`- } else {`
`82`		`- AFL_WARN(NKikimrServices::TX_COLUMNSHARD_SCAN)("event", "allocation_impossible")("error", errorMessage);`
`83`	`82`	`}`
`84`	`83`	`}`
`85`	`84`