Restoring authorship annotation for <jakovenko-dm@yandex-team.ru>. Commit 1 of 2.

9 files changed, 487 insertions, 487 deletions

diff --git a/contrib/libs/pire/pire/extra/count.cpp b/contrib/libs/pire/pire/extra/count.cpp
index 468ff61d92..27de4e3106 100644
--- a/contrib/libs/pire/pire/extra/count.cpp
+++ b/contrib/libs/pire/pire/extra/count.cpp
@@ -837,9 +837,9 @@ CountingScanner::CountingScanner(const Fsm& re, const Fsm& sep)
 	BuildScanner(sq, *this);
 }
 
-namespace Impl {
-template <class AdvancedScanner>
-AdvancedScanner MakeAdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple) {
+namespace Impl { 
+template <class AdvancedScanner> 
+AdvancedScanner MakeAdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple) { 
 	Impl::CountingFsm countingFsm{re, sep};
 	if (!countingFsm.Determine()) {
 		throw Error("regexp pattern too complicated");
@@ -852,31 +852,31 @@ AdvancedScanner MakeAdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool*
 	const auto& determined = countingFsm.Determined();
 	const auto& letters = countingFsm.Letters();
 
-	AdvancedScanner scanner;
-	scanner.Init(determined.Size(), letters, determined.Initial(), 1);
+	AdvancedScanner scanner; 
+	scanner.Init(determined.Size(), letters, determined.Initial(), 1); 
 	for (size_t from = 0; from != determined.Size(); ++from) {
 		for (auto&& lettersEl : letters) {
 			const auto letter = lettersEl.first;
 			const auto& tos = determined.Destinations(from, letter);
 			Y_ASSERT(tos.size() == 1);
-			scanner.SetJump(from, letter, *tos.begin(), scanner.RemapAction(countingFsm.Output(from, letter)));
+			scanner.SetJump(from, letter, *tos.begin(), scanner.RemapAction(countingFsm.Output(from, letter))); 
 		}
 	}
-	return scanner;
-}
-}  // namespace Impl
-
-AdvancedCountingScanner::AdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple)
-	: AdvancedCountingScanner(Impl::MakeAdvancedCountingScanner<AdvancedCountingScanner>(re, sep, simple))
-{
+	return scanner; 
 }
-
-NoGlueLimitCountingScanner::NoGlueLimitCountingScanner(const Fsm& re, const Fsm& sep, bool* simple)
-	: NoGlueLimitCountingScanner(Impl::MakeAdvancedCountingScanner<NoGlueLimitCountingScanner>(re, sep, simple))
-{
-}
-
-
+}  // namespace Impl 
+
+AdvancedCountingScanner::AdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple) 
+	: AdvancedCountingScanner(Impl::MakeAdvancedCountingScanner<AdvancedCountingScanner>(re, sep, simple)) 
+{ 
+} 
+ 
+NoGlueLimitCountingScanner::NoGlueLimitCountingScanner(const Fsm& re, const Fsm& sep, bool* simple) 
+	: NoGlueLimitCountingScanner(Impl::MakeAdvancedCountingScanner<NoGlueLimitCountingScanner>(re, sep, simple)) 
+{ 
+} 
+ 
+ 
 namespace Impl {
 
 template<class Scanner>
@@ -908,7 +908,7 @@ public:
 			Action(this->Lhs(), States[from].first, letter) | (Action(this->Rhs(), States[from].second, letter) << this->Lhs().RegexpsCount()));
 	}
 
-protected:
+protected: 
 	TVector<State> States;
 	TAction Action(const Scanner& sc, InternalState state, Char letter) const
 	{
@@ -919,74 +919,74 @@ protected:
 	}
 };
 
-class NoGlueLimitCountingScannerGlueTask : public CountingScannerGlueTask<NoGlueLimitCountingScanner> {
-public:
-	using ActionIndex = NoGlueLimitCountingScanner::ActionIndex;
-	struct TGlueAction {
-		TVector<ActionIndex> resets;
-		TVector<ActionIndex> increments;
-		bool operator<(const TGlueAction& rhs) const {
-			return std::tie(increments, resets) < std::tie(rhs.increments, rhs.resets);
-		}
-	};
-	using TGlueMap = TMap<TGlueAction, ActionIndex>;
-
-	NoGlueLimitCountingScannerGlueTask(const NoGlueLimitCountingScanner& lhs, const NoGlueLimitCountingScanner& rhs)
-		: CountingScannerGlueTask(lhs, rhs)
-	{
-	}
-
-	void Connect(size_t from, size_t to, Char letter)
-	{
-		TGlueAction glue_action;
-		this->Lhs().GetActions(Action(this->Lhs(), States[from].first, letter), 0,
-							   std::back_inserter(glue_action.resets), std::back_inserter(glue_action.increments));
-		this->Rhs().GetActions(Action(this->Rhs(), States[from].second, letter), this->Lhs().RegexpsCount(),
-							   std::back_inserter(glue_action.resets), std::back_inserter(glue_action.increments));
-		Y_ASSERT(
-			std::is_sorted(glue_action.increments.begin(), glue_action.increments.end()) &&
-			std::is_sorted(glue_action.resets.begin(), glue_action.resets.end())
-		);
-
-		if (glue_action.increments.empty() && glue_action.resets.empty()) {
-			this->Sc().SetJump(from, letter, to, 0);
-			return;
-		}
-
-		auto action_iter = glue_map_.find(glue_action);
-		if (action_iter == glue_map_.end()) {
-			glue_map_[glue_action] = glue_actions_.size();
-			for (const auto& ids : {glue_action.resets, glue_action.increments}) {
-				glue_actions_.push_back(ids.size());
-				std::copy(ids.begin(), ids.end(), std::back_inserter(glue_actions_));
-			}
-		}
-
-		this->Sc().SetJump(from, letter, to, glue_map_[glue_action]);
-	}
-
-	// Return type is same as in parent class
-	// TODO: Maybe return by value to use move semantic?
-	const NoGlueLimitCountingScanner& Success()
-	{
-		glue_actions_[0] = glue_actions_.size();
-		Sc().AcceptActions(glue_actions_);
-		return Sc();
-	}
-
-private:
-	TGlueMap glue_map_;
-	TVector<ActionIndex> glue_actions_ = {1};
-};
-
-
+class NoGlueLimitCountingScannerGlueTask : public CountingScannerGlueTask<NoGlueLimitCountingScanner> { 
+public: 
+	using ActionIndex = NoGlueLimitCountingScanner::ActionIndex; 
+	struct TGlueAction { 
+		TVector<ActionIndex> resets; 
+		TVector<ActionIndex> increments; 
+		bool operator<(const TGlueAction& rhs) const { 
+			return std::tie(increments, resets) < std::tie(rhs.increments, rhs.resets); 
+		} 
+	}; 
+	using TGlueMap = TMap<TGlueAction, ActionIndex>; 
+ 
+	NoGlueLimitCountingScannerGlueTask(const NoGlueLimitCountingScanner& lhs, const NoGlueLimitCountingScanner& rhs) 
+		: CountingScannerGlueTask(lhs, rhs) 
+	{ 
+	} 
+ 
+	void Connect(size_t from, size_t to, Char letter) 
+	{ 
+		TGlueAction glue_action; 
+		this->Lhs().GetActions(Action(this->Lhs(), States[from].first, letter), 0, 
+							   std::back_inserter(glue_action.resets), std::back_inserter(glue_action.increments)); 
+		this->Rhs().GetActions(Action(this->Rhs(), States[from].second, letter), this->Lhs().RegexpsCount(), 
+							   std::back_inserter(glue_action.resets), std::back_inserter(glue_action.increments)); 
+		Y_ASSERT( 
+			std::is_sorted(glue_action.increments.begin(), glue_action.increments.end()) && 
+			std::is_sorted(glue_action.resets.begin(), glue_action.resets.end()) 
+		); 
+ 
+		if (glue_action.increments.empty() && glue_action.resets.empty()) { 
+			this->Sc().SetJump(from, letter, to, 0); 
+			return; 
+		} 
+ 
+		auto action_iter = glue_map_.find(glue_action); 
+		if (action_iter == glue_map_.end()) { 
+			glue_map_[glue_action] = glue_actions_.size(); 
+			for (const auto& ids : {glue_action.resets, glue_action.increments}) { 
+				glue_actions_.push_back(ids.size()); 
+				std::copy(ids.begin(), ids.end(), std::back_inserter(glue_actions_)); 
+			} 
+		} 
+ 
+		this->Sc().SetJump(from, letter, to, glue_map_[glue_action]); 
+	} 
+ 
+	// Return type is same as in parent class 
+	// TODO: Maybe return by value to use move semantic? 
+	const NoGlueLimitCountingScanner& Success() 
+	{ 
+		glue_actions_[0] = glue_actions_.size(); 
+		Sc().AcceptActions(glue_actions_); 
+		return Sc(); 
+	} 
+ 
+private: 
+	TGlueMap glue_map_; 
+	TVector<ActionIndex> glue_actions_ = {1}; 
+}; 
+ 
+ 
 }
 
 CountingScanner CountingScanner::Glue(const CountingScanner& lhs, const CountingScanner& rhs, size_t maxSize /* = 0 */)
 {
-	if (lhs.RegexpsCount() + rhs.RegexpsCount() > MAX_RE_COUNT) {
-		return CountingScanner();
-	}
+	if (lhs.RegexpsCount() + rhs.RegexpsCount() > MAX_RE_COUNT) { 
+		return CountingScanner(); 
+	} 
 	static constexpr size_t DefMaxSize = 250000;
 	Impl::CountingScannerGlueTask<CountingScanner> task(lhs, rhs);
 	return Impl::Determine(task, maxSize ? maxSize : DefMaxSize);
@@ -994,75 +994,75 @@ CountingScanner CountingScanner::Glue(const CountingScanner& lhs, const Counting
 
 AdvancedCountingScanner AdvancedCountingScanner::Glue(const AdvancedCountingScanner& lhs, const AdvancedCountingScanner& rhs, size_t maxSize /* = 0 */)
 {
-	if (lhs.RegexpsCount() + rhs.RegexpsCount() > MAX_RE_COUNT) {
-		return AdvancedCountingScanner();
-	}
+	if (lhs.RegexpsCount() + rhs.RegexpsCount() > MAX_RE_COUNT) { 
+		return AdvancedCountingScanner(); 
+	} 
 	static constexpr size_t DefMaxSize = 250000;
 	Impl::CountingScannerGlueTask<AdvancedCountingScanner> task(lhs, rhs);
 	return Impl::Determine(task, maxSize ? maxSize : DefMaxSize);
 }
 
-NoGlueLimitCountingScanner NoGlueLimitCountingScanner::Glue(const NoGlueLimitCountingScanner& lhs, const NoGlueLimitCountingScanner& rhs, size_t maxSize /* = 0 */)
-{
-	static constexpr size_t DefMaxSize = 250000;
-	Impl::NoGlueLimitCountingScannerGlueTask task(lhs, rhs);
-	return Impl::Determine(task, maxSize ? maxSize : DefMaxSize);
-}
-
-// Should Save(), Load() and Mmap() functions return stream/pointer in aligned state?
-// Now they don't because tests don't require it.
-void NoGlueLimitCountingScanner::Save(yostream* s) const {
-	Y_ASSERT(!AdvancedScannerCompatibilityMode);
-	LoadedScanner::Save(s, ScannerIOTypes::NoGlueLimitCountingScanner);
-	if (Actions) {
-		SavePodArray(s, Actions, *Actions);
-	} else {
-		const ActionIndex zeroSize = 0;
-		SavePodType(s, zeroSize);
-	}
-}
-
-void NoGlueLimitCountingScanner::Load(yistream* s) {
-	ui32 type;
-	LoadedScanner::Load(s, &type);
-	ActionIndex actionsSize;
-	if (type == ScannerIOTypes::NoGlueLimitCountingScanner) {
-		LoadPodType(s, actionsSize);
-
-		if (actionsSize == 0) {
-			ActionsBuffer.reset();
-			Actions = nullptr;
-		} else {
-			ActionsBuffer = TActionsBuffer(new ActionIndex[actionsSize]);
-			ActionsBuffer[0] = actionsSize;
-			LoadPodArray(s, &ActionsBuffer[1], actionsSize - 1);
-			Actions = ActionsBuffer.get();
-		}
-	} else {
-		Y_ASSERT(type == ScannerIOTypes::LoadedScanner);
-		AdvancedScannerCompatibilityMode = true;
-	}
-}
-
-const void* NoGlueLimitCountingScanner::Mmap(const void* ptr, size_t size) {
-	NoGlueLimitCountingScanner scanner;
-	ui32 type;
-	auto p = static_cast<const size_t*> (scanner.LoadedScanner::Mmap(ptr, size, &type));
-
-	if (type == ScannerIOTypes::NoGlueLimitCountingScanner) {
-		scanner.Actions = reinterpret_cast<const ActionIndex*>(p);
-		if (*scanner.Actions == 0) {
-			scanner.Actions = nullptr;
-			Impl::AdvancePtr(p, size, sizeof(ActionIndex));
-		} else {
-			Impl::AdvancePtr(p, size, *scanner.Actions * sizeof(ActionIndex));
-		}
-	} else {
-		Y_ASSERT(type == ScannerIOTypes::LoadedScanner);
-		scanner.AdvancedScannerCompatibilityMode = true;
-	}
-	Swap(scanner);
-	return static_cast<const void*>(p);
-}
-
+NoGlueLimitCountingScanner NoGlueLimitCountingScanner::Glue(const NoGlueLimitCountingScanner& lhs, const NoGlueLimitCountingScanner& rhs, size_t maxSize /* = 0 */) 
+{ 
+	static constexpr size_t DefMaxSize = 250000; 
+	Impl::NoGlueLimitCountingScannerGlueTask task(lhs, rhs); 
+	return Impl::Determine(task, maxSize ? maxSize : DefMaxSize); 
 }
+ 
+// Should Save(), Load() and Mmap() functions return stream/pointer in aligned state? 
+// Now they don't because tests don't require it. 
+void NoGlueLimitCountingScanner::Save(yostream* s) const { 
+	Y_ASSERT(!AdvancedScannerCompatibilityMode); 
+	LoadedScanner::Save(s, ScannerIOTypes::NoGlueLimitCountingScanner); 
+	if (Actions) { 
+		SavePodArray(s, Actions, *Actions); 
+	} else { 
+		const ActionIndex zeroSize = 0; 
+		SavePodType(s, zeroSize); 
+	} 
+} 
+ 
+void NoGlueLimitCountingScanner::Load(yistream* s) { 
+	ui32 type; 
+	LoadedScanner::Load(s, &type); 
+	ActionIndex actionsSize; 
+	if (type == ScannerIOTypes::NoGlueLimitCountingScanner) { 
+		LoadPodType(s, actionsSize); 
+ 
+		if (actionsSize == 0) { 
+			ActionsBuffer.reset(); 
+			Actions = nullptr; 
+		} else { 
+			ActionsBuffer = TActionsBuffer(new ActionIndex[actionsSize]); 
+			ActionsBuffer[0] = actionsSize; 
+			LoadPodArray(s, &ActionsBuffer[1], actionsSize - 1); 
+			Actions = ActionsBuffer.get(); 
+		} 
+	} else { 
+		Y_ASSERT(type == ScannerIOTypes::LoadedScanner); 
+		AdvancedScannerCompatibilityMode = true; 
+	} 
+} 
+ 
+const void* NoGlueLimitCountingScanner::Mmap(const void* ptr, size_t size) { 
+	NoGlueLimitCountingScanner scanner; 
+	ui32 type; 
+	auto p = static_cast<const size_t*> (scanner.LoadedScanner::Mmap(ptr, size, &type)); 
+ 
+	if (type == ScannerIOTypes::NoGlueLimitCountingScanner) { 
+		scanner.Actions = reinterpret_cast<const ActionIndex*>(p); 
+		if (*scanner.Actions == 0) { 
+			scanner.Actions = nullptr; 
+			Impl::AdvancePtr(p, size, sizeof(ActionIndex)); 
+		} else { 
+			Impl::AdvancePtr(p, size, *scanner.Actions * sizeof(ActionIndex)); 
+		} 
+	} else { 
+		Y_ASSERT(type == ScannerIOTypes::LoadedScanner); 
+		scanner.AdvancedScannerCompatibilityMode = true; 
+	} 
+	Swap(scanner); 
+	return static_cast<const void*>(p); 
+} 
+ 
+} 
diff --git a/contrib/libs/pire/pire/extra/count.h b/contrib/libs/pire/pire/extra/count.h
index bd1526b98d..7a67f64e28 100644
--- a/contrib/libs/pire/pire/extra/count.h
+++ b/contrib/libs/pire/pire/extra/count.h
@@ -27,8 +27,8 @@
 #include <contrib/libs/pire/pire/scanners/loaded.h>
 #include <contrib/libs/pire/pire/fsm.h>
 
-#include <algorithm>
-
+#include <algorithm> 
+ 
 namespace Pire {
 class Fsm;
 
@@ -38,11 +38,11 @@ namespace Impl {
 
 	template<class T>
 	class CountingScannerGlueTask;
-
-	class NoGlueLimitCountingScannerGlueTask;
-
-	template <class AdvancedScanner>
-	AdvancedScanner MakeAdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple);
+ 
+	class NoGlueLimitCountingScannerGlueTask; 
+ 
+	template <class AdvancedScanner> 
+	AdvancedScanner MakeAdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple); 
 };
 
 template<size_t I>
@@ -115,7 +115,7 @@ public:
  * given regexp separated by another regexp
  * in input text.
  */
-template<class DerivedScanner, class State>
+template<class DerivedScanner, class State> 
 class BaseCountingScanner: public LoadedScanner {
 public:
 	enum {
@@ -137,7 +137,7 @@ public:
 	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION
 	void TakeAction(State& s, Action a) const
 	{
-		static_cast<const DerivedScanner*>(this)->template TakeActionImpl<MAX_RE_COUNT>(s, a);
+		static_cast<const DerivedScanner*>(this)->template TakeActionImpl<MAX_RE_COUNT>(s, a); 
 	}
 
 	bool CanStop(const State&) const { return false; }
@@ -203,41 +203,41 @@ protected:
 	}
 };
 
-template <size_t MAX_RE_COUNT>
-class CountingState {
-public:
-	size_t Result(int i) const { return ymax(m_current[i], m_total[i]); }
-private:
-	using InternalState = LoadedScanner::InternalState;
-	InternalState m_state;
-	ui32 m_current[MAX_RE_COUNT];
-	ui32 m_total[MAX_RE_COUNT];
-	size_t m_updatedMask;
-
-	template <class DerivedScanner, class State>
-	friend class BaseCountingScanner;
-
-	template<size_t I>
-	friend class IncrementPerformer;
-
-	template<size_t I>
-	friend class ResetPerformer;
-
-#ifdef PIRE_DEBUG
-	friend yostream& operator << (yostream& s, const State& state)
-		{
-			s << state.m_state << " ( ";
-			for (size_t i = 0; i < MAX_RE_COUNT; ++i)
-				s << state.m_current[i] << '/' << state.m_total[i] << ' ';
-			return s << ')';
-		}
-#endif
-};
-
-
-class CountingScanner : public BaseCountingScanner<CountingScanner, CountingState<LoadedScanner::MAX_RE_COUNT>> {
+template <size_t MAX_RE_COUNT> 
+class CountingState { 
 public:
-	using State = CountingState<MAX_RE_COUNT>;
+	size_t Result(int i) const { return ymax(m_current[i], m_total[i]); } 
+private: 
+	using InternalState = LoadedScanner::InternalState; 
+	InternalState m_state; 
+	ui32 m_current[MAX_RE_COUNT]; 
+	ui32 m_total[MAX_RE_COUNT]; 
+	size_t m_updatedMask; 
+ 
+	template <class DerivedScanner, class State> 
+	friend class BaseCountingScanner; 
+ 
+	template<size_t I> 
+	friend class IncrementPerformer; 
+ 
+	template<size_t I> 
+	friend class ResetPerformer; 
+ 
+#ifdef PIRE_DEBUG 
+	friend yostream& operator << (yostream& s, const State& state) 
+		{ 
+			s << state.m_state << " ( "; 
+			for (size_t i = 0; i < MAX_RE_COUNT; ++i) 
+				s << state.m_current[i] << '/' << state.m_total[i] << ' '; 
+			return s << ')'; 
+		} 
+#endif 
+}; 
+ 
+ 
+class CountingScanner : public BaseCountingScanner<CountingScanner, CountingState<LoadedScanner::MAX_RE_COUNT>> { 
+public: 
+	using State = CountingState<MAX_RE_COUNT>; 
 	enum {
 		Matched = 2,
 	};
@@ -273,10 +273,10 @@ private:
 	friend class Impl::CountingScannerGlueTask<CountingScanner>;
 };
 
-class AdvancedCountingScanner : public BaseCountingScanner<AdvancedCountingScanner, CountingState<LoadedScanner::MAX_RE_COUNT>> {
+class AdvancedCountingScanner : public BaseCountingScanner<AdvancedCountingScanner, CountingState<LoadedScanner::MAX_RE_COUNT>> { 
 public:
-	using State = CountingState<MAX_RE_COUNT>;
-
+	using State = CountingState<MAX_RE_COUNT>; 
+ 
 	AdvancedCountingScanner() {}
 	AdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple = nullptr);
 
@@ -309,196 +309,196 @@ private:
 
 	friend class Impl::ScannerGlueCommon<AdvancedCountingScanner>;
 	friend class Impl::CountingScannerGlueTask<AdvancedCountingScanner>;
-	friend AdvancedCountingScanner Impl::MakeAdvancedCountingScanner<AdvancedCountingScanner>(const Fsm&, const Fsm&, bool*);
-};
-
-class NoGlueLimitCountingState {
-public:
-	size_t Result(int i) const { return ymax(m_current[i], m_total[i]); }
-    void Initialize(size_t initial, size_t regexpsCount) {
-		m_state = initial;
-		m_current.assign(regexpsCount, 0);
-		m_total.assign(regexpsCount, 0);
-	}
-	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION
-	void Reset(size_t regexpId) {
-		m_current[regexpId] = 0;
-	}
-	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION
-	void Increment(size_t regexp_id) {
-		++m_current[regexp_id];
-		m_total[regexp_id] = ymax(m_total[regexp_id], m_current[regexp_id]);
-	}
-
-	template<size_t I>
-	friend class IncrementPerformer;
-
-	template<size_t I>
-	friend class ResetPerformer;
-
-private:
-	LoadedScanner::InternalState m_state;
-	TVector<ui32> m_current;
-	TVector<ui32> m_total;
-
-	template <class DerivedScanner, class State>
-	friend class BaseCountingScanner;
-
-#ifdef PIRE_DEBUG
-	yostream& operator << (yostream& s, const State& state)
-		{
-			s << state.m_state << " ( ";
-			for (size_t i = 0; i < state.m_current.size(); ++i)
-				s << state.m_current[i] << '/' << state.m_total[i] << ' ';
-			return s << ')';
-		}
-#endif
+	friend AdvancedCountingScanner Impl::MakeAdvancedCountingScanner<AdvancedCountingScanner>(const Fsm&, const Fsm&, bool*); 
 };
 
-
-class NoGlueLimitCountingScanner : public BaseCountingScanner<NoGlueLimitCountingScanner, NoGlueLimitCountingState> {
-public:
-	using State = NoGlueLimitCountingState;
-	using ActionIndex = ui32;
-	using TActionsBuffer = std::unique_ptr<ActionIndex[]>;
-
-private:
-	TActionsBuffer ActionsBuffer;
-	const ActionIndex* Actions = nullptr;
-	bool AdvancedScannerCompatibilityMode = false;
-
-public:
-	NoGlueLimitCountingScanner() = default;
-	NoGlueLimitCountingScanner(const Fsm& re, const Fsm& sep, bool* simple = nullptr);
-	NoGlueLimitCountingScanner(const NoGlueLimitCountingScanner& rhs)
-	    : BaseCountingScanner(rhs)
-	    , AdvancedScannerCompatibilityMode(rhs.AdvancedScannerCompatibilityMode)
-	{
-		if (rhs.ActionsBuffer) {
-			Y_ASSERT(rhs.Actions);
-			ActionsBuffer = TActionsBuffer(new ActionIndex [*rhs.Actions]);
-			std::copy_n(rhs.ActionsBuffer.get(), *rhs.Actions, ActionsBuffer.get());
-			Actions = ActionsBuffer.get();
-		} else {
-			Actions = rhs.Actions;
-		}
-	}
-
-	NoGlueLimitCountingScanner(NoGlueLimitCountingScanner&& other) : BaseCountingScanner() {
-		Swap(other);
-	}
-
-	NoGlueLimitCountingScanner& operator=(NoGlueLimitCountingScanner rhs) {
-		Swap(rhs);
-		return *this;
-	}
-
-	void Swap(NoGlueLimitCountingScanner& s) {
-		LoadedScanner::Swap(s);
-		DoSwap(ActionsBuffer, s.ActionsBuffer);
-		DoSwap(Actions, s.Actions);
-		DoSwap(AdvancedScannerCompatibilityMode, s.AdvancedScannerCompatibilityMode);
-	}
-
-	void Initialize(State& state) const
-	{
-		state.Initialize(m.initial, RegexpsCount());
-	}
-
-	template <size_t ActualReCount>
-	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION
-	void TakeActionImpl(State& s, Action a) const
-	{
-		if (!a) {
-			return;
-		}
-		if (AdvancedScannerCompatibilityMode) {
-			AdvancedScannerTakeActionImpl<ActualReCount>(s, a);
-			return;
-		}
-		// Note: it's important to perform resets before increments,
-		// as it's possible for one repetition group to stop and another begin at the same symbol
-		if (Actions) {
-			auto action = Actions + a;
-			for (auto reset_count = *action++; reset_count--;) {
-				s.Reset(*action++);
-			}
-			for (auto inc_count = *action++; inc_count--;) {
-				s.Increment(*action++);
-			}
-		} else {
-			Y_ASSERT(RegexpsCount() == 1);
-			if (a & ResetAction) {
-				s.Reset(0);
-			}
-			if (a & IncrementAction) {
-				s.Increment(0);
-			}
-		}
-	}
-
-	void Save(yostream* s) const;
-
-	void Load(yistream* s);
-
-	const void* Mmap(const void* ptr, size_t size);
-
-	static NoGlueLimitCountingScanner Glue(const NoGlueLimitCountingScanner& a, const NoGlueLimitCountingScanner& b, size_t maxSize = 0);
-
-private:
-	Action RemapAction(Action action)
-	{
-		return action;
-	}
-
-	template <class Iterator>
-	void GetActions(Action a, ActionIndex id_shift, Iterator output_resets, Iterator output_increments) const {
-		if (!a) {
-			return;
-		}
-		if (!Actions) {
-			if (a & ResetAction) {
-				*output_resets++ = id_shift;
-			}
-			if (a & NoGlueLimitCountingScanner::IncrementAction) {
-				*output_increments++ = id_shift;
-			}
-			return;
-		}
-		auto action = Actions + a;
-		for (auto output : {output_resets, output_increments}) {
-			for (auto count = *action++; count--;) {
-				*output++ = *action++ + id_shift;
-			}
-		}
-	}
-
-	void AcceptActions(const TVector<ActionIndex>& actions) {
-		Y_ASSERT(!Actions);
-		Y_ASSERT(!actions.empty());
-		Y_ASSERT(actions[0] == actions.size());
-
-		ActionsBuffer = TActionsBuffer(new ActionIndex[actions.size()]);
-		std::copy(actions.begin(), actions.end(), ActionsBuffer.get());
-		Actions = ActionsBuffer.get();
-	}
-
-	template <size_t ActualReCount>
-	void AdvancedScannerTakeActionImpl(State& s, Action a) const {
-		if (a & ResetMask) {
-			ResetPerformer<ActualReCount>::Do(s, a);
-		}
-		if (a & IncrementMask) {
-			IncrementPerformer<ActualReCount>::Do(s, a);
-		}
-	}
-
-	friend class Impl::ScannerGlueCommon<NoGlueLimitCountingScanner>;
-	friend class Impl::CountingScannerGlueTask<NoGlueLimitCountingScanner>;
-	friend class Impl::NoGlueLimitCountingScannerGlueTask;
-	friend NoGlueLimitCountingScanner Impl::MakeAdvancedCountingScanner<NoGlueLimitCountingScanner>(const Fsm&, const Fsm&, bool*);
-};
-
-}
-
+class NoGlueLimitCountingState { 
+public: 
+	size_t Result(int i) const { return ymax(m_current[i], m_total[i]); } 
+    void Initialize(size_t initial, size_t regexpsCount) { 
+		m_state = initial; 
+		m_current.assign(regexpsCount, 0); 
+		m_total.assign(regexpsCount, 0); 
+	} 
+	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION 
+	void Reset(size_t regexpId) { 
+		m_current[regexpId] = 0; 
+	} 
+	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION 
+	void Increment(size_t regexp_id) { 
+		++m_current[regexp_id]; 
+		m_total[regexp_id] = ymax(m_total[regexp_id], m_current[regexp_id]); 
+	} 
+
+	template<size_t I> 
+	friend class IncrementPerformer; 
+
+	template<size_t I> 
+	friend class ResetPerformer; 
+ 
+private: 
+	LoadedScanner::InternalState m_state; 
+	TVector<ui32> m_current; 
+	TVector<ui32> m_total; 
+ 
+	template <class DerivedScanner, class State> 
+	friend class BaseCountingScanner; 
+ 
+#ifdef PIRE_DEBUG 
+	yostream& operator << (yostream& s, const State& state) 
+		{ 
+			s << state.m_state << " ( "; 
+			for (size_t i = 0; i < state.m_current.size(); ++i) 
+				s << state.m_current[i] << '/' << state.m_total[i] << ' '; 
+			return s << ')'; 
+		} 
 #endif
+}; 
+ 
+ 
+class NoGlueLimitCountingScanner : public BaseCountingScanner<NoGlueLimitCountingScanner, NoGlueLimitCountingState> { 
+public: 
+	using State = NoGlueLimitCountingState; 
+	using ActionIndex = ui32; 
+	using TActionsBuffer = std::unique_ptr<ActionIndex[]>; 
+ 
+private: 
+	TActionsBuffer ActionsBuffer; 
+	const ActionIndex* Actions = nullptr; 
+	bool AdvancedScannerCompatibilityMode = false; 
+ 
+public: 
+	NoGlueLimitCountingScanner() = default; 
+	NoGlueLimitCountingScanner(const Fsm& re, const Fsm& sep, bool* simple = nullptr); 
+	NoGlueLimitCountingScanner(const NoGlueLimitCountingScanner& rhs) 
+	    : BaseCountingScanner(rhs) 
+	    , AdvancedScannerCompatibilityMode(rhs.AdvancedScannerCompatibilityMode) 
+	{ 
+		if (rhs.ActionsBuffer) { 
+			Y_ASSERT(rhs.Actions); 
+			ActionsBuffer = TActionsBuffer(new ActionIndex [*rhs.Actions]); 
+			std::copy_n(rhs.ActionsBuffer.get(), *rhs.Actions, ActionsBuffer.get()); 
+			Actions = ActionsBuffer.get(); 
+		} else { 
+			Actions = rhs.Actions; 
+		} 
+	} 
+ 
+	NoGlueLimitCountingScanner(NoGlueLimitCountingScanner&& other) : BaseCountingScanner() { 
+		Swap(other); 
+	} 
+ 
+	NoGlueLimitCountingScanner& operator=(NoGlueLimitCountingScanner rhs) { 
+		Swap(rhs); 
+		return *this; 
+	} 
+ 
+	void Swap(NoGlueLimitCountingScanner& s) { 
+		LoadedScanner::Swap(s); 
+		DoSwap(ActionsBuffer, s.ActionsBuffer); 
+		DoSwap(Actions, s.Actions); 
+		DoSwap(AdvancedScannerCompatibilityMode, s.AdvancedScannerCompatibilityMode); 
+	} 
+ 
+	void Initialize(State& state) const 
+	{ 
+		state.Initialize(m.initial, RegexpsCount()); 
+	} 
+ 
+	template <size_t ActualReCount> 
+	PIRE_FORCED_INLINE PIRE_HOT_FUNCTION 
+	void TakeActionImpl(State& s, Action a) const 
+	{ 
+		if (!a) { 
+			return; 
+		} 
+		if (AdvancedScannerCompatibilityMode) { 
+			AdvancedScannerTakeActionImpl<ActualReCount>(s, a); 
+			return; 
+		} 
+		// Note: it's important to perform resets before increments, 
+		// as it's possible for one repetition group to stop and another begin at the same symbol 
+		if (Actions) { 
+			auto action = Actions + a; 
+			for (auto reset_count = *action++; reset_count--;) { 
+				s.Reset(*action++); 
+			} 
+			for (auto inc_count = *action++; inc_count--;) { 
+				s.Increment(*action++); 
+			} 
+		} else { 
+			Y_ASSERT(RegexpsCount() == 1); 
+			if (a & ResetAction) { 
+				s.Reset(0); 
+			} 
+			if (a & IncrementAction) { 
+				s.Increment(0); 
+			} 
+		} 
+	} 
+ 
+	void Save(yostream* s) const; 
+ 
+	void Load(yistream* s); 
+ 
+	const void* Mmap(const void* ptr, size_t size); 
+ 
+	static NoGlueLimitCountingScanner Glue(const NoGlueLimitCountingScanner& a, const NoGlueLimitCountingScanner& b, size_t maxSize = 0); 
+ 
+private: 
+	Action RemapAction(Action action) 
+	{ 
+		return action; 
+	} 
+ 
+	template <class Iterator> 
+	void GetActions(Action a, ActionIndex id_shift, Iterator output_resets, Iterator output_increments) const { 
+		if (!a) { 
+			return; 
+		} 
+		if (!Actions) { 
+			if (a & ResetAction) { 
+				*output_resets++ = id_shift; 
+			} 
+			if (a & NoGlueLimitCountingScanner::IncrementAction) { 
+				*output_increments++ = id_shift; 
+			} 
+			return; 
+		} 
+		auto action = Actions + a; 
+		for (auto output : {output_resets, output_increments}) { 
+			for (auto count = *action++; count--;) { 
+				*output++ = *action++ + id_shift; 
+			} 
+		} 
+	} 
+ 
+	void AcceptActions(const TVector<ActionIndex>& actions) { 
+		Y_ASSERT(!Actions); 
+		Y_ASSERT(!actions.empty()); 
+		Y_ASSERT(actions[0] == actions.size()); 
+ 
+		ActionsBuffer = TActionsBuffer(new ActionIndex[actions.size()]); 
+		std::copy(actions.begin(), actions.end(), ActionsBuffer.get()); 
+		Actions = ActionsBuffer.get(); 
+	} 
+ 
+	template <size_t ActualReCount> 
+	void AdvancedScannerTakeActionImpl(State& s, Action a) const { 
+		if (a & ResetMask) { 
+			ResetPerformer<ActualReCount>::Do(s, a); 
+		} 
+		if (a & IncrementMask) { 
+			IncrementPerformer<ActualReCount>::Do(s, a); 
+		} 
+	} 
+ 
+	friend class Impl::ScannerGlueCommon<NoGlueLimitCountingScanner>; 
+	friend class Impl::CountingScannerGlueTask<NoGlueLimitCountingScanner>; 
+	friend class Impl::NoGlueLimitCountingScannerGlueTask; 
+	friend NoGlueLimitCountingScanner Impl::MakeAdvancedCountingScanner<NoGlueLimitCountingScanner>(const Fsm&, const Fsm&, bool*); 
+}; 
+ 
+} 
+ 
+#endif 
diff --git a/contrib/libs/pire/pire/fsm.cpp b/contrib/libs/pire/pire/fsm.cpp
index 984d708dfa..27bfd91522 100644
--- a/contrib/libs/pire/pire/fsm.cpp
+++ b/contrib/libs/pire/pire/fsm.cpp
@@ -612,7 +612,7 @@ Fsm& Fsm::Reverse()
 				out.Connect(j, from, i.first);
 
 	// Invert initial and final states
-	out.m_final.clear();
+	out.m_final.clear(); 
 	out.SetFinal(initial, true);
 	for (auto i : m_final)
 		out.Connect(Size(), i, Epsilon);
diff --git a/contrib/libs/pire/pire/run.h b/contrib/libs/pire/pire/run.h
index f6e1ff734d..6ce6c9780e 100644
--- a/contrib/libs/pire/pire/run.h
+++ b/contrib/libs/pire/pire/run.h
@@ -31,7 +31,7 @@
 #include "platform.h"
 #include "defs.h"
 
-#include <string>
+#include <string> 
 
 namespace Pire {
 
@@ -283,67 +283,67 @@ void Run(const Scanner& sc, typename Scanner::State& st, const char* begin, cons
 	Run(sc, st, TStringBuf(begin, end));
 }
 
-/// Returns default constructed string_view{} if there is no matching prefix
-/// Returns str.substr(0, 0) if matching prefix is empty
+/// Returns default constructed string_view{} if there is no matching prefix 
+/// Returns str.substr(0, 0) if matching prefix is empty 
 template<class Scanner>
-std::string_view LongestPrefix(const Scanner& sc, std::string_view str, bool throughBeginMark = false, bool throughEndMark = false)
+std::string_view LongestPrefix(const Scanner& sc, std::string_view str, bool throughBeginMark = false, bool throughEndMark = false) 
 {
 	typename Scanner::State st;
 	sc.Initialize(st);
 	if (throughBeginMark)
 		Pire::Step(sc, st, BeginMark);
-	const char* pos = (sc.Final(st) ? str.data() : nullptr);
+	const char* pos = (sc.Final(st) ? str.data() : nullptr); 
 	Impl::DoRun(sc, st, str, Impl::LongestPrefixPred<Scanner>(pos));
 	if (throughEndMark) {
 		Pire::Step(sc, st, EndMark);
 		if (sc.Final(st))
-			pos = str.data() + str.size();
+			pos = str.data() + str.size(); 
 	}
-	return pos ? str.substr(0, pos - str.data()) : std::string_view{};
+	return pos ? str.substr(0, pos - str.data()) : std::string_view{}; 
 }
 
 template<class Scanner>
 const char* LongestPrefix(const Scanner& sc, const char* begin, const char* end, bool throughBeginMark = false, bool throughEndMark = false)
 {
-	auto prefix = LongestPrefix(sc, std::string_view(begin, end - begin), throughBeginMark, throughEndMark);
-	return prefix.data() + prefix.size();
+	auto prefix = LongestPrefix(sc, std::string_view(begin, end - begin), throughBeginMark, throughEndMark); 
+	return prefix.data() + prefix.size(); 
 }
 
-/// Returns default constructed string_view{} if there is no matching prefix
-/// Returns str.substr(0, 0) if matching prefix is empty
+/// Returns default constructed string_view{} if there is no matching prefix 
+/// Returns str.substr(0, 0) if matching prefix is empty 
 template<class Scanner>
-std::string_view ShortestPrefix(const Scanner& sc, std::string_view str, bool throughBeginMark = false, bool throughEndMark = false)
+std::string_view ShortestPrefix(const Scanner& sc, std::string_view str, bool throughBeginMark = false, bool throughEndMark = false) 
 {
 	typename Scanner::State st;
 	sc.Initialize(st);
 	if (throughBeginMark)
 		Pire::Step(sc, st, BeginMark);
 	if (sc.Final(st))
-		return str.substr(0, 0);
-	const char* pos = nullptr;
+		return str.substr(0, 0); 
+	const char* pos = nullptr; 
 	Impl::DoRun(sc, st, str, Impl::ShortestPrefixPred<Scanner>(pos));
 	if (throughEndMark) {
 		Pire::Step(sc, st, EndMark);
-		if (sc.Final(st) && !pos)
-			pos = str.data() + str.size();
+		if (sc.Final(st) && !pos) 
+			pos = str.data() + str.size(); 
 	}
-	return pos ? str.substr(0, pos - str.data()) : std::string_view{};
+	return pos ? str.substr(0, pos - str.data()) : std::string_view{}; 
 }
 
 template<class Scanner>
 const char* ShortestPrefix(const Scanner& sc, const char* begin, const char* end, bool throughBeginMark = false, bool throughEndMark = false)
 {
-    auto prefix = ShortestPrefix(sc, std::string_view(begin, end - begin), throughBeginMark, throughEndMark);
-    return prefix.data() + prefix.size();
+    auto prefix = ShortestPrefix(sc, std::string_view(begin, end - begin), throughBeginMark, throughEndMark); 
+    return prefix.data() + prefix.size(); 
 }
 
 	
 /// The same as above, but scans string in reverse direction
 /// (consider using Fsm::Reverse() for using in this function).
-/// Returns default constructed string_view{} if there is no matching suffix
-/// Returns str.substr(str.size(), 0) if matching suffix is empty
+/// Returns default constructed string_view{} if there is no matching suffix 
+/// Returns str.substr(str.size(), 0) if matching suffix is empty 
 template<class Scanner>
-inline std::string_view LongestSuffix(const Scanner& scanner, std::string_view str, bool throughEndMark = false, bool throughBeginMark = false)
+inline std::string_view LongestSuffix(const Scanner& scanner, std::string_view str, bool throughEndMark = false, bool throughBeginMark = false) 
 {
 	typename Scanner::State state;
 	scanner.Initialize(state);
@@ -352,38 +352,38 @@ inline std::string_view LongestSuffix(const Scanner& scanner, std::string_view s
 	PIRE_IFDEBUG(Cdbg << "Running LongestSuffix on string " << ystring(str) << Endl);
 	PIRE_IFDEBUG(Cdbg << "Initial state " << StDump(scanner, state) << Endl);
 
-	std::string_view suffix{};
-	auto begin = str.data() + str.size();
-	while (begin != str.data() && !scanner.Dead(state)) {
+	std::string_view suffix{}; 
+	auto begin = str.data() + str.size(); 
+	while (begin != str.data() && !scanner.Dead(state)) { 
 		if (scanner.Final(state))
-			suffix = str.substr(begin - str.data());
-		--begin;
-		Step(scanner, state, (unsigned char)*begin);
-		PIRE_IFDEBUG(Cdbg << *begin << " => state " << StDump(scanner, state) << Endl);
+			suffix = str.substr(begin - str.data()); 
+		--begin; 
+		Step(scanner, state, (unsigned char)*begin); 
+		PIRE_IFDEBUG(Cdbg << *begin << " => state " << StDump(scanner, state) << Endl); 
 	}
 	if (scanner.Final(state))
-		suffix = str.substr(begin - str.data());
+		suffix = str.substr(begin - str.data()); 
 	if (throughBeginMark) {
 		Step(scanner, state, BeginMark);
 		if (scanner.Final(state))
-			suffix = str.substr(begin - str.data());
+			suffix = str.substr(begin - str.data()); 
 	}
-	return suffix;
+	return suffix; 
 }
 
 template<class Scanner>
 inline const char* LongestSuffix(const Scanner& scanner, const char* rbegin, const char* rend, bool throughEndMark = false, bool throughBeginMark = false) {
-	auto suffix = LongestSuffix(scanner, std::string_view(rend + 1, rbegin - rend), throughEndMark, throughBeginMark);
-    return suffix.data() ? suffix.data() - 1 : nullptr;
+	auto suffix = LongestSuffix(scanner, std::string_view(rend + 1, rbegin - rend), throughEndMark, throughBeginMark); 
+    return suffix.data() ? suffix.data() - 1 : nullptr; 
 }
 
 /// The same as above, but scans string in reverse direction
-/// Returns default constructed string_view{} if there is no matching suffix
-/// Returns str.substr(str.size(), 0) if matching suffix is empty
+/// Returns default constructed string_view{} if there is no matching suffix 
+/// Returns str.substr(str.size(), 0) if matching suffix is empty 
 template<class Scanner>
-inline std::string_view ShortestSuffix(const Scanner& scanner, std::string_view str, bool throughEndMark = false, bool throughBeginMark = false)
+inline std::string_view ShortestSuffix(const Scanner& scanner, std::string_view str, bool throughEndMark = false, bool throughBeginMark = false) 
 {
-	auto begin = str.data() + str.size();
+	auto begin = str.data() + str.size(); 
 	typename Scanner::State state;
 	scanner.Initialize(state);
 	if (throughEndMark)
@@ -391,20 +391,20 @@ inline std::string_view ShortestSuffix(const Scanner& scanner, std::string_view
 	PIRE_IFDEBUG(Cdbg << "Running ShortestSuffix on string " << ystring(str) << Endl);
 	PIRE_IFDEBUG(Cdbg << "Initial state " << StDump(scanner, state) << Endl);
 
-	while (begin != str.data() && !scanner.Final(state) && !scanner.Dead(state)) {
-		--begin;
-		scanner.Next(state, (unsigned char)*begin);
+	while (begin != str.data() && !scanner.Final(state) && !scanner.Dead(state)) { 
+		--begin; 
+		scanner.Next(state, (unsigned char)*begin); 
 		PIRE_IFDEBUG(Cdbg << *rbegin << " => state " << StDump(scanner, state) << Endl);
 	}
 	if (throughBeginMark)
 		Step(scanner, state, BeginMark);
-	return scanner.Final(state) ? str.substr(begin - str.data()) : std::string_view{};
+	return scanner.Final(state) ? str.substr(begin - str.data()) : std::string_view{}; 
 }
 
 template<class Scanner>
 inline const char* ShortestSuffix(const Scanner& scanner, const char* rbegin, const char* rend, bool throughEndMark = false, bool throughBeginMark = false) {
-	auto suffix = ShortestSuffix(scanner, std::string_view(rend + 1, rbegin - rend), throughEndMark, throughBeginMark);
-	return suffix.data() ? suffix.data() - 1 : nullptr;
+	auto suffix = ShortestSuffix(scanner, std::string_view(rend + 1, rbegin - rend), throughEndMark, throughBeginMark); 
+	return suffix.data() ? suffix.data() - 1 : nullptr; 
 }
 
 
diff --git a/contrib/libs/pire/pire/scanner_io.cpp b/contrib/libs/pire/pire/scanner_io.cpp
index 3956e3c6ed..5c723ca427 100644
--- a/contrib/libs/pire/pire/scanner_io.cpp
+++ b/contrib/libs/pire/pire/scanner_io.cpp
@@ -169,14 +169,14 @@ void SlowScanner::Load(yistream* s)
 	Swap(sc);
 }
 
-void LoadedScanner::Save(yostream* s) const {
-	Save(s, ScannerIOTypes::LoadedScanner);
-}
-
-void LoadedScanner::Save(yostream* s, ui32 type) const
+void LoadedScanner::Save(yostream* s) const { 
+	Save(s, ScannerIOTypes::LoadedScanner); 
+} 
+ 
+void LoadedScanner::Save(yostream* s, ui32 type) const 
 {
-	Y_ASSERT(type == ScannerIOTypes::LoadedScanner || type == ScannerIOTypes::NoGlueLimitCountingScanner);
-	SavePodType(s, Header(type, sizeof(m)));
+	Y_ASSERT(type == ScannerIOTypes::LoadedScanner || type == ScannerIOTypes::NoGlueLimitCountingScanner); 
+	SavePodType(s, Header(type, sizeof(m))); 
 	Impl::AlignSave(s, sizeof(Header));
 	Locals mc = m;
 	mc.initial -= reinterpret_cast<size_t>(m_jumps);
@@ -188,17 +188,17 @@ void LoadedScanner::Save(yostream* s, ui32 type) const
 	Impl::AlignedSaveArray(s, m_tags, m.statesCount);
 }
 
-void LoadedScanner::Load(yistream* s) {
-	Load(s, nullptr);
-}
-
-void LoadedScanner::Load(yistream* s, ui32* type)
+void LoadedScanner::Load(yistream* s) { 
+	Load(s, nullptr); 
+} 
+ 
+void LoadedScanner::Load(yistream* s, ui32* type) 
 {
 	LoadedScanner sc;
 	Header header = Impl::ValidateHeader(s, ScannerIOTypes::LoadedScanner, sizeof(sc.m));
-	if (type) {
-		*type = header.Type;
-	}
+	if (type) { 
+		*type = header.Type; 
+	} 
 	LoadPodType(s, sc.m);
 	Impl::AlignLoad(s, sizeof(sc.m));
 	sc.m_buffer = BufferType(new char[sc.BufSize()]);
diff --git a/contrib/libs/pire/pire/scanners/common.h b/contrib/libs/pire/pire/scanners/common.h
index de5ea0af7b..a92684cf3d 100644
--- a/contrib/libs/pire/pire/scanners/common.h
+++ b/contrib/libs/pire/pire/scanners/common.h
@@ -36,8 +36,8 @@ namespace Pire {
 			Scanner = 1,
 			SimpleScanner = 2,
 			SlowScanner = 3,
-			LoadedScanner = 4,
-			NoGlueLimitCountingScanner = 5,
+			LoadedScanner = 4, 
+			NoGlueLimitCountingScanner = 5, 
 		};
 	}
 
@@ -68,12 +68,12 @@ namespace Pire {
 				throw Error("Serialized regexp incompatible with your system");
 			if (Version != RE_VERSION && Version != RE_VERSION_WITH_MACTIONS)
 				throw Error("You are trying to used an incompatible version of a serialized regexp");
-			if (type != ScannerIOTypes::NoScanner && type != Type &&
-			   !(type == ScannerIOTypes::LoadedScanner && Type == ScannerIOTypes::NoGlueLimitCountingScanner)) {
-				throw Error("Serialized regexp incompatible with your system");
-			}
-			if (hdrsize != 0 && HdrSize != hdrsize)
+			if (type != ScannerIOTypes::NoScanner && type != Type && 
+			   !(type == ScannerIOTypes::LoadedScanner && Type == ScannerIOTypes::NoGlueLimitCountingScanner)) { 
 				throw Error("Serialized regexp incompatible with your system");
+			} 
+			if (hdrsize != 0 && HdrSize != hdrsize) 
+				throw Error("Serialized regexp incompatible with your system"); 
 		}
 	};
 
diff --git a/contrib/libs/pire/pire/scanners/half_final.h b/contrib/libs/pire/pire/scanners/half_final.h
index 071c3414a2..1755114302 100644
--- a/contrib/libs/pire/pire/scanners/half_final.h
+++ b/contrib/libs/pire/pire/scanners/half_final.h
@@ -210,13 +210,13 @@ private:
 	void BuildFinals(const HalfFinalFsm& fsm) {
 		Y_ASSERT(Scanner::m_buffer);
 		Y_ASSERT(fsm.GetFsm().Size() == Scanner::Size());
-		auto finalWriter = Scanner::m_final;
+		auto finalWriter = Scanner::m_final; 
 		for (size_t state = 0; state < Scanner::Size(); ++state) {
-			Scanner::m_finalIndex[state] = finalWriter - Scanner::m_final;
+			Scanner::m_finalIndex[state] = finalWriter - Scanner::m_final; 
 			for (size_t i = 0; i < fsm.GetCount(state); i++) {
-				*finalWriter++ = 0;
+				*finalWriter++ = 0; 
 			}
-			*finalWriter++ = static_cast<size_t>(-1);
+			*finalWriter++ = static_cast<size_t>(-1); 
 		}
 	}
 
diff --git a/contrib/libs/pire/pire/scanners/loaded.h b/contrib/libs/pire/pire/scanners/loaded.h
index 120dc403b7..ddc6a84b5b 100644
--- a/contrib/libs/pire/pire/scanners/loaded.h
+++ b/contrib/libs/pire/pire/scanners/loaded.h
@@ -103,13 +103,13 @@ protected:
 	}
 
 	LoadedScanner& operator = (const LoadedScanner& s) { LoadedScanner(s).Swap(*this); return *this; }
-	LoadedScanner (LoadedScanner&& other) : LoadedScanner() {
-		Swap(other);
-	}
-	LoadedScanner& operator=(LoadedScanner&& other) {
-		Swap(other);
-		return *this;
-	}
+	LoadedScanner (LoadedScanner&& other) : LoadedScanner() { 
+		Swap(other); 
+	} 
+	LoadedScanner& operator=(LoadedScanner&& other) { 
+		Swap(other); 
+		return *this; 
+	} 
 
 public:
 	size_t Size() const { return m.statesCount; }
@@ -120,19 +120,19 @@ public:
 
 	size_t LettersCount() const { return m.lettersCount; }
 
-	const void* Mmap(const void* ptr, size_t size) {
-		return Mmap(ptr, size, nullptr);
-	}
-
-	const void* Mmap(const void* ptr, size_t size, ui32* type)
+	const void* Mmap(const void* ptr, size_t size) { 
+		return Mmap(ptr, size, nullptr); 
+	} 
+ 
+	const void* Mmap(const void* ptr, size_t size, ui32* type) 
 	{
 		Impl::CheckAlign(ptr);
 		LoadedScanner s;
 		const size_t* p = reinterpret_cast<const size_t*>(ptr);
 		Header header = Impl::ValidateHeader(p, size, ScannerIOTypes::LoadedScanner, sizeof(s.m));
-		if (type) {
-			*type = header.Type;
-		}
+		if (type) { 
+			*type = header.Type; 
+		} 
 
 		Locals* locals;
 		Impl::MapPtr(locals, 1, p, size);
@@ -152,9 +152,9 @@ public:
 		return (const void*) p;
 	}
 
-	void Save(yostream*, ui32 type) const;
+	void Save(yostream*, ui32 type) const; 
 	void Save(yostream*) const;
-	void Load(yistream*, ui32* type);
+	void Load(yistream*, ui32* type); 
 	void Load(yistream*);
 
 		template<class Eq>
diff --git a/contrib/libs/pire/pire/scanners/multi.h b/contrib/libs/pire/pire/scanners/multi.h
index 29679e416e..b993808bf7 100644
--- a/contrib/libs/pire/pire/scanners/multi.h
+++ b/contrib/libs/pire/pire/scanners/multi.h
@@ -24,7 +24,7 @@
 #ifndef PIRE_SCANNERS_MULTI_H
 #define PIRE_SCANNERS_MULTI_H
 
-#include <cstring>
+#include <cstring> 
 #include <string.h>
 #include <contrib/libs/pire/pire/approx_matching.h>
 #include <contrib/libs/pire/pire/fsm.h>
@@ -348,7 +348,7 @@ protected:
 	template<class Eq>
 	void Init(size_t states, const Partition<Char, Eq>& letters, size_t finalStatesCount, size_t startState, size_t regexpsCount = 1)
 	{
-		std::memset(&m, 0, sizeof(m));
+		std::memset(&m, 0, sizeof(m)); 
 		m.relocationSignature = Relocation::Signature;
 		m.shortcuttingSignature = Shortcutting::Signature;
 		m.statesCount = states;
@@ -407,7 +407,7 @@ protected:
 		m.relocationSignature = Relocation::Signature;
 		m.shortcuttingSignature = Shortcutting::Signature;
 		m_buffer = BufferType(new char[BufSize() + sizeof(size_t)]);
-		std::memset(m_buffer.Get(), 0, BufSize() + sizeof(size_t));
+		std::memset(m_buffer.Get(), 0, BufSize() + sizeof(size_t)); 
 		Markup(AlignUp(m_buffer.Get(), sizeof(size_t)));
 
 		// Values in letter-to-leterclass table take into account row header size
@@ -513,12 +513,12 @@ protected:
 	void FinishBuild()
 	{
 		Y_ASSERT(m_buffer);
-		auto finalWriter = m_final;
+		auto finalWriter = m_final; 
 		for (size_t state = 0; state != Size(); ++state) {
-			m_finalIndex[state] = finalWriter - m_final;
+			m_finalIndex[state] = finalWriter - m_final; 
 			if (Header(IndexToState(state)).Common.Flags & FinalFlag)
-				*finalWriter++ = 0;
-			*finalWriter++ = static_cast<size_t>(-1);
+				*finalWriter++ = 0; 
+			*finalWriter++ = static_cast<size_t>(-1); 
 		}
 		BuildShortcuts();
 	}
@@ -1022,12 +1022,12 @@ public:
 		this->SetSc(THolder<Scanner>(new Scanner));
 		Sc().Init(states.size(), Letters(), finalTableSize, size_t(0), Lhs().RegexpsCount() + Rhs().RegexpsCount());
 
-		auto finalWriter = Sc().m_final;
+		auto finalWriter = Sc().m_final; 
 		for (size_t state = 0; state != states.size(); ++state) {
-			Sc().m_finalIndex[state] = finalWriter - Sc().m_final;
-			finalWriter = Shift(Lhs().AcceptedRegexps(states[state].first), 0, finalWriter);
-			finalWriter = Shift(Rhs().AcceptedRegexps(states[state].second), Lhs().RegexpsCount(), finalWriter);
-			*finalWriter++ = static_cast<size_t>(-1);
+			Sc().m_finalIndex[state] = finalWriter - Sc().m_final; 
+			finalWriter = Shift(Lhs().AcceptedRegexps(states[state].first), 0, finalWriter); 
+			finalWriter = Shift(Rhs().AcceptedRegexps(states[state].second), Lhs().RegexpsCount(), finalWriter); 
+			*finalWriter++ = static_cast<size_t>(-1); 
 
 			Sc().SetTag(state, ((Lhs().Final(states[state].first) || Rhs().Final(states[state].second)) ? Scanner::FinalFlag : 0)
 				| ((Lhs().Dead(states[state].first) && Rhs().Dead(states[state].second)) ? Scanner::DeadFlag : 0));