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

13 files changed, 877 insertions, 877 deletions

diff --git a/contrib/libs/pire/pire/extra/count.cpp b/contrib/libs/pire/pire/extra/count.cpp
index 27de4e3106..468ff61d92 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; 
+	return scanner;
+}
+}  // namespace Impl
+
+AdvancedCountingScanner::AdvancedCountingScanner(const Fsm& re, const Fsm& sep, bool* simple)
+	: AdvancedCountingScanner(Impl::MakeAdvancedCountingScanner<AdvancedCountingScanner>(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)) 
-{ 
-} 
- 
- 
+
+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); 
+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);
+}
+
 }
- 
-// 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 7a67f64e28..bd1526b98d 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 { 
+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>> {
 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>> { 
-public: 
-	using State = CountingState<MAX_RE_COUNT>; 
+	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*); 
+	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
 };
 
-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 << ')'; 
-		} 
+
+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
-}; 
- 
- 
-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 27bfd91522..984d708dfa 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 6ce6c9780e..f6e1ff734d 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 5c723ca427..3956e3c6ed 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 a92684cf3d..de5ea0af7b 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)) { 
+			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");
-			} 
-			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 1755114302..071c3414a2 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 ddc6a84b5b..120dc403b7 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 b993808bf7..29679e416e 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));
diff --git a/library/cpp/regex/hyperscan/hyperscan.cpp b/library/cpp/regex/hyperscan/hyperscan.cpp
index 82ca3880d1..ba321f9c29 100644
--- a/library/cpp/regex/hyperscan/hyperscan.cpp
+++ b/library/cpp/regex/hyperscan/hyperscan.cpp
@@ -17,201 +17,201 @@ namespace NHyperscan {
     using TCompileError = THolder<hs_compile_error_t, TDeleter<decltype(&hs_free_compile_error), &hs_free_compile_error>>;
 
     namespace NPrivate {
-        ERuntime DetectCurrentRuntime() { 
+        ERuntime DetectCurrentRuntime() {
             if (NX86::HaveAVX512F() && NX86::HaveAVX512BW()) {
-                return ERuntime::AVX512; 
+                return ERuntime::AVX512;
             } else if (NX86::HaveAVX() && NX86::HaveAVX2()) {
-                return ERuntime::AVX2; 
+                return ERuntime::AVX2;
             } else if (NX86::HaveSSE42() && NX86::HavePOPCNT()) {
-                return ERuntime::Corei7; 
+                return ERuntime::Corei7;
             } else {
-                return ERuntime::Core2; 
+                return ERuntime::Core2;
             }
         }
 
-        TCPUFeatures RuntimeCpuFeatures(ERuntime runtime) { 
-            switch (runtime) { 
-                default: 
-                    Y_ASSERT(false); 
+        TCPUFeatures RuntimeCpuFeatures(ERuntime runtime) {
+            switch (runtime) {
+                default:
+                    Y_ASSERT(false);
                     [[fallthrough]];
-                case ERuntime::Core2: 
-                case ERuntime::Corei7: 
-                    return 0; 
-                case ERuntime::AVX2: 
-                    return CPU_FEATURES_AVX2; 
-                case ERuntime::AVX512: 
-                    return CPU_FEATURES_AVX512; 
-            } 
+                case ERuntime::Core2:
+                case ERuntime::Corei7:
+                    return 0;
+                case ERuntime::AVX2:
+                    return CPU_FEATURES_AVX2;
+                case ERuntime::AVX512:
+                    return CPU_FEATURES_AVX512;
+            }
         }
 
-        hs_platform_info_t MakePlatformInfo(TCPUFeatures cpuFeatures) { 
-            hs_platform_info_t platformInfo{HS_TUNE_FAMILY_GENERIC, cpuFeatures, 0, 0}; 
-            return platformInfo; 
+        hs_platform_info_t MakePlatformInfo(TCPUFeatures cpuFeatures) {
+            hs_platform_info_t platformInfo{HS_TUNE_FAMILY_GENERIC, cpuFeatures, 0, 0};
+            return platformInfo;
         }
- 
+
         hs_platform_info_t MakeCurrentPlatformInfo() {
             return MakePlatformInfo(RuntimeCpuFeatures(DetectCurrentRuntime()));
         }
 
-        TImpl::TImpl(ERuntime runtime) { 
-            switch (runtime) { 
-                default: 
-                    Y_ASSERT(false); 
+        TImpl::TImpl(ERuntime runtime) {
+            switch (runtime) {
+                default:
+                    Y_ASSERT(false);
                     [[fallthrough]];
-                case ERuntime::Core2: 
-                    AllocScratch = core2_hs_alloc_scratch; 
-                    Scan = core2_hs_scan; 
-                    SerializeDatabase = core2_hs_serialize_database; 
-                    DeserializeDatabase = core2_hs_deserialize_database; 
-                    break; 
-                case ERuntime::Corei7: 
-                    AllocScratch = corei7_hs_alloc_scratch; 
-                    Scan = corei7_hs_scan; 
-                    SerializeDatabase = corei7_hs_serialize_database; 
-                    DeserializeDatabase = corei7_hs_deserialize_database; 
-                    break; 
-                case ERuntime::AVX2: 
-                    AllocScratch = avx2_hs_alloc_scratch; 
-                    Scan = avx2_hs_scan; 
-                    SerializeDatabase = avx2_hs_serialize_database; 
-                    DeserializeDatabase = avx2_hs_deserialize_database; 
-                    break; 
-                case ERuntime::AVX512: 
-                    AllocScratch = avx512_hs_alloc_scratch; 
-                    Scan = avx512_hs_scan; 
-                    SerializeDatabase = avx512_hs_serialize_database; 
-                    DeserializeDatabase = avx512_hs_deserialize_database; 
-            } 
+                case ERuntime::Core2:
+                    AllocScratch = core2_hs_alloc_scratch;
+                    Scan = core2_hs_scan;
+                    SerializeDatabase = core2_hs_serialize_database;
+                    DeserializeDatabase = core2_hs_deserialize_database;
+                    break;
+                case ERuntime::Corei7:
+                    AllocScratch = corei7_hs_alloc_scratch;
+                    Scan = corei7_hs_scan;
+                    SerializeDatabase = corei7_hs_serialize_database;
+                    DeserializeDatabase = corei7_hs_deserialize_database;
+                    break;
+                case ERuntime::AVX2:
+                    AllocScratch = avx2_hs_alloc_scratch;
+                    Scan = avx2_hs_scan;
+                    SerializeDatabase = avx2_hs_serialize_database;
+                    DeserializeDatabase = avx2_hs_deserialize_database;
+                    break;
+                case ERuntime::AVX512:
+                    AllocScratch = avx512_hs_alloc_scratch;
+                    Scan = avx512_hs_scan;
+                    SerializeDatabase = avx512_hs_serialize_database;
+                    DeserializeDatabase = avx512_hs_deserialize_database;
+            }
         }
- 
-        TDatabase Compile(const TStringBuf& regex, unsigned int flags, hs_platform_info_t* platform) { 
-            hs_database_t* rawDb = nullptr; 
-            hs_compile_error_t* rawCompileErr = nullptr; 
-            hs_error_t status = hs_compile( 
-                    regex.begin(), 
-                    flags, 
-                    HS_MODE_BLOCK, 
-                    platform, 
-                    &rawDb, 
-                    &rawCompileErr); 
-            TDatabase db(rawDb); 
-            NHyperscan::TCompileError compileError(rawCompileErr); 
-            if (status != HS_SUCCESS) { 
+
+        TDatabase Compile(const TStringBuf& regex, unsigned int flags, hs_platform_info_t* platform) {
+            hs_database_t* rawDb = nullptr;
+            hs_compile_error_t* rawCompileErr = nullptr;
+            hs_error_t status = hs_compile(
+                    regex.begin(),
+                    flags,
+                    HS_MODE_BLOCK,
+                    platform,
+                    &rawDb,
+                    &rawCompileErr);
+            TDatabase db(rawDb);
+            NHyperscan::TCompileError compileError(rawCompileErr);
+            if (status != HS_SUCCESS) {
                 ythrow TCompileException()
-                        << "Failed to compile regex: " << regex << ". " 
-                        << "Error message (hyperscan): " << compileError->message; 
+                        << "Failed to compile regex: " << regex << ". "
+                        << "Error message (hyperscan): " << compileError->message;
+            }
+            return db;
+        }
+
+        TDatabase CompileMulti(
+                const TVector<const char*>& regexs,
+                const TVector<unsigned int>& flags,
+                const TVector<unsigned int>& ids,
+                hs_platform_info_t* platform,
+                const TVector<const hs_expr_ext_t*>* extendedParameters) {
+            unsigned int count = regexs.size();
+            if (flags.size() != count) {
+                ythrow yexception()
+                        << "Mismatch of sizes vectors passed to CompileMulti. "
+                        << "size(regexs) = " << regexs.size() << ". "
+                        << "size(flags) = " << flags.size() << ".";
+            }
+            if (ids.size() != count) {
+                ythrow yexception()
+                        << "Mismatch of sizes vectors passed to CompileMulti. "
+                        << "size(regexs) = " << regexs.size() << ". "
+                        << "size(ids) = " << ids.size() << ".";
+            }
+            if (extendedParameters && extendedParameters->size() != count) {
+                ythrow yexception()
+                        << "Mismatch of sizes vectors passed to CompileMulti. "
+                        << "size(regexs) = " << regexs.size() << ". "
+                        << "size(extendedParameters) = " << extendedParameters->size() << ".";
             }
-            return db; 
+            hs_database_t* rawDb = nullptr;
+            hs_compile_error_t* rawCompileErr = nullptr;
+            hs_error_t status = hs_compile_ext_multi(
+                    regexs.data(),
+                    flags.data(),
+                    ids.data(),
+                    extendedParameters ? extendedParameters->data() : nullptr,
+                    count,
+                    HS_MODE_BLOCK,
+                    platform,
+                    &rawDb,
+                    &rawCompileErr);
+            TDatabase db(rawDb);
+            NHyperscan::TCompileError compileError(rawCompileErr);
+            if (status != HS_SUCCESS) {
+                if (compileError->expression >= 0) {
+                    const char* regex = regexs[compileError->expression];
+                    ythrow TCompileException()
+                            << "Failed to compile regex: " << regex << ". "
+                            << "Error message (hyperscan): " << compileError->message;
+                } else {
+                    ythrow TCompileException()
+                            << "Failed to compile multiple regexs. "
+                            << "Error message (hyperscan): " << compileError->message;
+                }
+            }
+            return db;
+        }
+
+        bool Matches(
+                const TDatabase& db,
+                const TScratch& scratch,
+                const TStringBuf& text,
+                const TImpl& impl) {
+            bool result = false;
+            auto callback = [&](unsigned int /* id */, unsigned long long /* from */, unsigned long long /* to */) {
+                result = true;
+                return 1; // stop scan
+            };
+            Scan(
+                    db,
+                    scratch,
+                    text,
+                    callback,
+                    impl);
+            return result;
         }
- 
-        TDatabase CompileMulti( 
-                const TVector<const char*>& regexs, 
-                const TVector<unsigned int>& flags, 
-                const TVector<unsigned int>& ids, 
-                hs_platform_info_t* platform, 
-                const TVector<const hs_expr_ext_t*>* extendedParameters) { 
-            unsigned int count = regexs.size(); 
-            if (flags.size() != count) { 
-                ythrow yexception() 
-                        << "Mismatch of sizes vectors passed to CompileMulti. " 
-                        << "size(regexs) = " << regexs.size() << ". " 
-                        << "size(flags) = " << flags.size() << "."; 
-            } 
-            if (ids.size() != count) { 
-                ythrow yexception() 
-                        << "Mismatch of sizes vectors passed to CompileMulti. " 
-                        << "size(regexs) = " << regexs.size() << ". " 
-                        << "size(ids) = " << ids.size() << "."; 
-            } 
-            if (extendedParameters && extendedParameters->size() != count) { 
-                ythrow yexception() 
-                        << "Mismatch of sizes vectors passed to CompileMulti. " 
-                        << "size(regexs) = " << regexs.size() << ". " 
-                        << "size(extendedParameters) = " << extendedParameters->size() << "."; 
-            } 
-            hs_database_t* rawDb = nullptr; 
-            hs_compile_error_t* rawCompileErr = nullptr; 
-            hs_error_t status = hs_compile_ext_multi( 
-                    regexs.data(), 
-                    flags.data(), 
-                    ids.data(), 
-                    extendedParameters ? extendedParameters->data() : nullptr, 
-                    count, 
-                    HS_MODE_BLOCK, 
-                    platform, 
-                    &rawDb, 
-                    &rawCompileErr); 
-            TDatabase db(rawDb); 
-            NHyperscan::TCompileError compileError(rawCompileErr); 
-            if (status != HS_SUCCESS) { 
-                if (compileError->expression >= 0) { 
-                    const char* regex = regexs[compileError->expression]; 
-                    ythrow TCompileException() 
-                            << "Failed to compile regex: " << regex << ". " 
-                            << "Error message (hyperscan): " << compileError->message; 
-                } else { 
-                    ythrow TCompileException() 
-                            << "Failed to compile multiple regexs. " 
-                            << "Error message (hyperscan): " << compileError->message; 
-                } 
-            } 
-            return db; 
-        } 
- 
-        bool Matches( 
-                const TDatabase& db, 
-                const TScratch& scratch, 
-                const TStringBuf& text, 
-                const TImpl& impl) { 
-            bool result = false; 
-            auto callback = [&](unsigned int /* id */, unsigned long long /* from */, unsigned long long /* to */) { 
-                result = true; 
-                return 1; // stop scan 
-            }; 
-            Scan( 
-                    db, 
-                    scratch, 
-                    text, 
-                    callback, 
-                    impl); 
-            return result; 
-        } 
-    } // namespace NPrivate 
- 
-    TDatabase Compile(const TStringBuf& regex, unsigned int flags) { 
+    } // namespace NPrivate
+
+    TDatabase Compile(const TStringBuf& regex, unsigned int flags) {
         auto platformInfo = NPrivate::MakeCurrentPlatformInfo();
         return NPrivate::Compile(regex, flags, &platformInfo);
     }
 
-    TDatabase Compile(const TStringBuf& regex, unsigned int flags, TCPUFeatures cpuFeatures) { 
-        auto platformInfo = NPrivate::MakePlatformInfo(cpuFeatures); 
-        return NPrivate::Compile(regex, flags, &platformInfo); 
-    } 
- 
-    TDatabase CompileMulti( 
-            const TVector<const char*>& regexs, 
-            const TVector<unsigned int>& flags, 
-            const TVector<unsigned int>& ids, 
-            const TVector<const hs_expr_ext_t*>* extendedParameters) 
-    { 
+    TDatabase Compile(const TStringBuf& regex, unsigned int flags, TCPUFeatures cpuFeatures) {
+        auto platformInfo = NPrivate::MakePlatformInfo(cpuFeatures);
+        return NPrivate::Compile(regex, flags, &platformInfo);
+    }
+
+    TDatabase CompileMulti(
+            const TVector<const char*>& regexs,
+            const TVector<unsigned int>& flags,
+            const TVector<unsigned int>& ids,
+            const TVector<const hs_expr_ext_t*>* extendedParameters)
+    {
         auto platformInfo = NPrivate::MakeCurrentPlatformInfo();
         return NPrivate::CompileMulti(regexs, flags, ids, &platformInfo, extendedParameters);
-    } 
- 
-    TDatabase CompileMulti( 
-        const TVector<const char*>& regexs, 
-        const TVector<unsigned int>& flags, 
-        const TVector<unsigned int>& ids, 
-        TCPUFeatures cpuFeatures, 
-        const TVector<const hs_expr_ext_t*>* extendedParameters) 
-    { 
-        auto platformInfo = NPrivate::MakePlatformInfo(cpuFeatures); 
-        return NPrivate::CompileMulti(regexs, flags, ids, &platformInfo, extendedParameters); 
-    } 
- 
+    }
+
+    TDatabase CompileMulti(
+        const TVector<const char*>& regexs,
+        const TVector<unsigned int>& flags,
+        const TVector<unsigned int>& ids,
+        TCPUFeatures cpuFeatures,
+        const TVector<const hs_expr_ext_t*>* extendedParameters)
+    {
+        auto platformInfo = NPrivate::MakePlatformInfo(cpuFeatures);
+        return NPrivate::CompileMulti(regexs, flags, ids, &platformInfo, extendedParameters);
+    }
+
     TScratch MakeScratch(const TDatabase& db) {
         hs_scratch_t* rawScratch = nullptr;
-        hs_error_t status = Singleton<NPrivate::TImpl>()->AllocScratch(db.Get(), &rawScratch); 
+        hs_error_t status = Singleton<NPrivate::TImpl>()->AllocScratch(db.Get(), &rawScratch);
         NHyperscan::TScratch scratch(rawScratch);
         if (status != HS_SUCCESS) {
             ythrow yexception() << "Failed to make scratch for hyperscan database";
@@ -221,7 +221,7 @@ namespace NHyperscan {
 
     void GrowScratch(TScratch& scratch, const TDatabase& db) {
         hs_scratch_t* rawScratch = scratch.Get();
-        hs_error_t status = Singleton<NPrivate::TImpl>()->AllocScratch(db.Get(), &rawScratch); 
+        hs_error_t status = Singleton<NPrivate::TImpl>()->AllocScratch(db.Get(), &rawScratch);
         if (rawScratch != scratch.Get()) {
             Y_UNUSED(scratch.Release()); // freed by hs_alloc_scratch
             scratch.Reset(rawScratch);
@@ -244,9 +244,9 @@ namespace NHyperscan {
     bool Matches(
         const TDatabase& db,
         const TScratch& scratch,
-        const TStringBuf& text) 
-    { 
-        return NPrivate::Matches(db, scratch, text, *Singleton<NPrivate::TImpl>()); 
+        const TStringBuf& text)
+    {
+        return NPrivate::Matches(db, scratch, text, *Singleton<NPrivate::TImpl>());
     }
 
     TString Serialize(const TDatabase& db) {
@@ -271,11 +271,11 @@ namespace NHyperscan {
             &rawDb);
         TDatabase db(rawDb);
         if (status != HS_SUCCESS) {
-            if (status == HS_DB_PLATFORM_ERROR) { 
-                ythrow yexception() << "Serialized Hyperscan database is incompatible with current CPU"; 
-            } else { 
-                ythrow yexception() << "Failed to deserialize hyperscan database"; 
-            } 
+            if (status == HS_DB_PLATFORM_ERROR) {
+                ythrow yexception() << "Serialized Hyperscan database is incompatible with current CPU";
+            } else {
+                ythrow yexception() << "Failed to deserialize hyperscan database";
+            }
         }
         return db;
     }
diff --git a/library/cpp/regex/hyperscan/hyperscan.h b/library/cpp/regex/hyperscan/hyperscan.h
index ef50cca08e..1c8f404389 100644
--- a/library/cpp/regex/hyperscan/hyperscan.h
+++ b/library/cpp/regex/hyperscan/hyperscan.h
@@ -9,14 +9,14 @@
 #include <util/system/cpu_id.h>
 
 namespace NHyperscan {
-    using TCPUFeatures = decltype(hs_platform_info_t::cpu_features); 
-    constexpr TCPUFeatures CPU_FEATURES_AVX2 = HS_CPU_FEATURES_AVX2; 
-    constexpr TCPUFeatures CPU_FEATURES_AVX512 = HS_CPU_FEATURES_AVX512 | HS_CPU_FEATURES_AVX2; 
- 
-    template<typename TNativeDeleter, TNativeDeleter NativeDeleter> 
+    using TCPUFeatures = decltype(hs_platform_info_t::cpu_features);
+    constexpr TCPUFeatures CPU_FEATURES_AVX2 = HS_CPU_FEATURES_AVX2;
+    constexpr TCPUFeatures CPU_FEATURES_AVX512 = HS_CPU_FEATURES_AVX512 | HS_CPU_FEATURES_AVX2;
+
+    template<typename TNativeDeleter, TNativeDeleter NativeDeleter>
     class TDeleter {
     public:
-        template<typename T> 
+        template<typename T>
         static void Destroy(T* ptr) {
             NativeDeleter(ptr);
         }
@@ -26,127 +26,127 @@ namespace NHyperscan {
 
     using TScratch = THolder<hs_scratch_t, TDeleter<decltype(&hs_free_scratch), &hs_free_scratch>>;
 
-    class TCompileException : public yexception { 
+    class TCompileException : public yexception {
     };
 
- 
+
     namespace NPrivate {
-        enum class ERuntime { 
-            Core2 = 0, 
-            Corei7 = 1, 
-            AVX2 = 2, 
-            AVX512 = 3 
-        }; 
- 
-        ERuntime DetectCurrentRuntime(); 
- 
-        TCPUFeatures RuntimeCpuFeatures(ERuntime runtime); 
- 
-        hs_platform_info_t MakePlatformInfo(TCPUFeatures cpuFeatures); 
- 
+        enum class ERuntime {
+            Core2 = 0,
+            Corei7 = 1,
+            AVX2 = 2,
+            AVX512 = 3
+        };
+
+        ERuntime DetectCurrentRuntime();
+
+        TCPUFeatures RuntimeCpuFeatures(ERuntime runtime);
+
+        hs_platform_info_t MakePlatformInfo(TCPUFeatures cpuFeatures);
+
         struct TImpl {
-            hs_error_t (*AllocScratch)(const hs_database_t* db, hs_scratch_t** scratch); 
-
-            hs_error_t (*Scan)(const hs_database_t* db, const char* data, 
-                                unsigned length, unsigned flags, hs_scratch_t* scratch, 
-                                match_event_handler onEvent, void* userCtx); 
- 
-            hs_error_t (*SerializeDatabase)(const hs_database_t* db, char** bytes, size_t* serialized_length); 
- 
-            hs_error_t (*DeserializeDatabase)(const char* bytes, size_t length, hs_database_t** info); 
- 
-            TImpl() : TImpl(DetectCurrentRuntime()) {} 
- 
-            explicit TImpl(ERuntime runtime); 
+            hs_error_t (*AllocScratch)(const hs_database_t* db, hs_scratch_t** scratch);
+
+            hs_error_t (*Scan)(const hs_database_t* db, const char* data,
+                                unsigned length, unsigned flags, hs_scratch_t* scratch,
+                                match_event_handler onEvent, void* userCtx);
+
+            hs_error_t (*SerializeDatabase)(const hs_database_t* db, char** bytes, size_t* serialized_length);
+
+            hs_error_t (*DeserializeDatabase)(const char* bytes, size_t length, hs_database_t** info);
+
+            TImpl() : TImpl(DetectCurrentRuntime()) {}
+
+            explicit TImpl(ERuntime runtime);
         };
- 
-        TDatabase Compile(const TStringBuf& regex, unsigned int flags, hs_platform_info_t* platform); 
- 
-        TDatabase CompileMulti( 
-            const TVector<const char*>& regexs, 
-            const TVector<unsigned int>& flags, 
-            const TVector<unsigned int>& ids, 
-            hs_platform_info_t* platform, 
-            const TVector<const hs_expr_ext_t*>* extendedParameters = nullptr); 
- 
-        // We need to parametrize Scan and Matches functions for testing purposes 
-        template<typename TCallback> 
-        void Scan( 
-            const TDatabase& db, 
-            const TScratch& scratch, 
-            const TStringBuf& text, 
-            TCallback& callback, // applied to index of matched regex 
-            const TImpl& impl 
-        ) { 
-            struct TCallbackWrapper { 
-                static int EventHandler( 
-                    unsigned int id, 
-                    unsigned long long from, 
-                    unsigned long long to, 
-                    unsigned int flags, 
-                    void* ctx) { 
-                    Y_UNUSED(flags); 
-                    TCallback& callback2 = *reinterpret_cast<TCallback*>(ctx); 
-                    if constexpr (std::is_same_v<int, std::invoke_result_t<TCallback, unsigned int, unsigned long long, unsigned long long>>) { 
-                        return callback2(id, from, to); 
-                    } else { 
-                        callback2(id, from, to); 
-                        return 0; 
-                    } 
-                } 
-            }; 
-            unsigned int flags = 0; // unused at present 
-            hs_error_t status = impl.Scan( 
-                db.Get(), 
-                text.begin(), 
-                text.size(), 
-                flags, 
-                scratch.Get(), 
-                &TCallbackWrapper::EventHandler, 
-                &callback); 
-            if (status != HS_SUCCESS && status != HS_SCAN_TERMINATED) { 
-                ythrow yexception() << "Failed to scan against text: " << text; 
-            } 
-        } 
- 
-        bool Matches( 
-            const TDatabase& db, 
-            const TScratch& scratch, 
-            const TStringBuf& text, 
-            const TImpl& impl); 
+
+        TDatabase Compile(const TStringBuf& regex, unsigned int flags, hs_platform_info_t* platform);
+
+        TDatabase CompileMulti(
+            const TVector<const char*>& regexs,
+            const TVector<unsigned int>& flags,
+            const TVector<unsigned int>& ids,
+            hs_platform_info_t* platform,
+            const TVector<const hs_expr_ext_t*>* extendedParameters = nullptr);
+
+        // We need to parametrize Scan and Matches functions for testing purposes
+        template<typename TCallback>
+        void Scan(
+            const TDatabase& db,
+            const TScratch& scratch,
+            const TStringBuf& text,
+            TCallback& callback, // applied to index of matched regex
+            const TImpl& impl
+        ) {
+            struct TCallbackWrapper {
+                static int EventHandler(
+                    unsigned int id,
+                    unsigned long long from,
+                    unsigned long long to,
+                    unsigned int flags,
+                    void* ctx) {
+                    Y_UNUSED(flags);
+                    TCallback& callback2 = *reinterpret_cast<TCallback*>(ctx);
+                    if constexpr (std::is_same_v<int, std::invoke_result_t<TCallback, unsigned int, unsigned long long, unsigned long long>>) {
+                        return callback2(id, from, to);
+                    } else {
+                        callback2(id, from, to);
+                        return 0;
+                    }
+                }
+            };
+            unsigned int flags = 0; // unused at present
+            hs_error_t status = impl.Scan(
+                db.Get(),
+                text.begin(),
+                text.size(),
+                flags,
+                scratch.Get(),
+                &TCallbackWrapper::EventHandler,
+                &callback);
+            if (status != HS_SUCCESS && status != HS_SCAN_TERMINATED) {
+                ythrow yexception() << "Failed to scan against text: " << text;
+            }
+        }
+
+        bool Matches(
+            const TDatabase& db,
+            const TScratch& scratch,
+            const TStringBuf& text,
+            const TImpl& impl);
     }
 
     TDatabase Compile(const TStringBuf& regex, unsigned int flags);
 
-    TDatabase Compile(const TStringBuf& regex, unsigned int flags, TCPUFeatures cpuFeatures); 
- 
+    TDatabase Compile(const TStringBuf& regex, unsigned int flags, TCPUFeatures cpuFeatures);
+
+    TDatabase CompileMulti(
+        const TVector<const char*>& regexs,
+        const TVector<unsigned int>& flags,
+        const TVector<unsigned int>& ids,
+        const TVector<const hs_expr_ext_t*>* extendedParameters = nullptr);
+
     TDatabase CompileMulti(
         const TVector<const char*>& regexs,
         const TVector<unsigned int>& flags,
         const TVector<unsigned int>& ids,
+        TCPUFeatures cpuFeatures,
         const TVector<const hs_expr_ext_t*>* extendedParameters = nullptr);
 
-    TDatabase CompileMulti( 
-        const TVector<const char*>& regexs, 
-        const TVector<unsigned int>& flags, 
-        const TVector<unsigned int>& ids, 
-        TCPUFeatures cpuFeatures, 
-        const TVector<const hs_expr_ext_t*>* extendedParameters = nullptr); 
- 
     TScratch MakeScratch(const TDatabase& db);
 
     void GrowScratch(TScratch& scratch, const TDatabase& db);
 
     TScratch CloneScratch(const TScratch& scratch);
 
-    template<typename TCallback> 
+    template<typename TCallback>
     void Scan(
         const TDatabase& db,
         const TScratch& scratch,
         const TStringBuf& text,
         TCallback& callback // applied to index of matched regex
     ) {
-        NPrivate::Scan<TCallback>(db, scratch, text, callback, *Singleton<NPrivate::TImpl>()); 
+        NPrivate::Scan<TCallback>(db, scratch, text, callback, *Singleton<NPrivate::TImpl>());
     }
 
     bool Matches(
diff --git a/library/cpp/regex/hyperscan/ut/hyperscan_ut.cpp b/library/cpp/regex/hyperscan/ut/hyperscan_ut.cpp
index 7abbaa4b08..9caa53f2e7 100644
--- a/library/cpp/regex/hyperscan/ut/hyperscan_ut.cpp
+++ b/library/cpp/regex/hyperscan/ut/hyperscan_ut.cpp
@@ -4,12 +4,12 @@
 
 #include <util/generic/set.h>
 
-#include <array> 
-#include <algorithm> 
- 
+#include <array>
+#include <algorithm>
+
 Y_UNIT_TEST_SUITE(HyperscanWrappers) {
     using namespace NHyperscan;
-    using namespace NHyperscan::NPrivate; 
+    using namespace NHyperscan::NPrivate;
 
     Y_UNIT_TEST(CompileAndScan) {
         TDatabase db = Compile("a.c", HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH);
@@ -120,112 +120,112 @@ Y_UNIT_TEST_SUITE(HyperscanWrappers) {
         scratch1.Reset();
         UNIT_ASSERT(NHyperscan::Matches(db, scratch2, "foo"));
     }
- 
-    class TSimpleSingleRegex { 
-    public: 
-        static TDatabase Compile(TCPUFeatures cpuFeatures) { 
-            return NHyperscan::Compile("foo", HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH, cpuFeatures); 
-        } 
-        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) { 
-            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db); 
-            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "foo", impl)); 
-            UNIT_ASSERT(!NHyperscan::NPrivate::Matches(db, scratch, "FOO", impl)); 
-        } 
-    }; 
- 
-    // This regex uses AVX2 instructions on long (>70) texts. 
-    // It crushes when compiled for machine with AVX2 and run on machine without it. 
-    class TAvx2SingleRegex { 
-        public: 
-        static TDatabase Compile(TCPUFeatures cpuFeatures) { 
-            auto regex = "[ЁАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюяё]+" 
-                         "[.][\\-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]{2,5}"; 
-            unsigned int flags = HS_FLAG_UTF8 | HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH | HS_FLAG_ALLOWEMPTY; 
-            return NHyperscan::Compile(regex, flags, cpuFeatures); 
-        } 
-        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) { 
-            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db); 
-            UNIT_ASSERT(NHyperscan::NPrivate::Matches( 
-                db, 
-                scratch, 
-                "_________________________________________________________________" 
-                "фу.bar" 
-                "_________________________________________________________________", 
-                impl)); 
-            UNIT_ASSERT(!NHyperscan::NPrivate::Matches( 
-                db, 
-                scratch, 
-                "_________________________________________________________________" 
-                "фу" 
-                "_________________________________________________________________", 
-                impl)); 
-        } 
-    }; 
- 
-    class TSimpleMultiRegex { 
-    public: 
-        static TDatabase Compile(TCPUFeatures cpuFeatures) { 
-            return NHyperscan::CompileMulti( 
-                { 
-                    "foo", 
-                    "bar", 
-                }, 
-                { 
-                    HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH, 
-                    HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH | HS_FLAG_CASELESS, 
-                }, 
-                { 
-                    42, 
-                    241, 
-                }, 
-                cpuFeatures); 
-        } 
-        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) { 
-            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db); 
- 
-            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "foo", impl)); 
-            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "bar", impl)); 
-            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "BAR", impl)); 
-            UNIT_ASSERT(!NHyperscan::NPrivate::Matches(db, scratch, "FOO", impl)); 
- 
-            TSet<unsigned int> foundIds; 
-            auto callback = [&](unsigned int id, unsigned long long /* from */, unsigned long long /* to */) { 
-                foundIds.insert(id); 
-            }; 
-            NHyperscan::NPrivate::Scan( 
-                    db, 
-                    scratch, 
-                    "fooBaR", 
-                    callback, 
-                    impl); 
-            UNIT_ASSERT_EQUAL(foundIds.size(), 2); 
-            UNIT_ASSERT(foundIds.contains(42)); 
-            UNIT_ASSERT(foundIds.contains(241)); 
-        } 
-    }; 
- 
-    template <class Regex> 
-    void TestCrossPlatformCompile() { 
-        const std::array<ERuntime, 4> runtimes = { 
-            ERuntime::Core2, 
-            ERuntime::Corei7, 
-            ERuntime::AVX2, 
-            ERuntime::AVX512 
-        }; 
- 
-        // Unfortunately, we cannot emulate runtimes with more capabilities than current machine. 
-        auto currentRuntimeIter = std::find(runtimes.cbegin(), runtimes.cend(), DetectCurrentRuntime()); 
-        Y_ASSERT(currentRuntimeIter != runtimes.cend()); 
- 
-        for (auto targetRuntime = runtimes.cbegin(); targetRuntime <= currentRuntimeIter; ++targetRuntime) { 
-            auto db = Regex::Compile(RuntimeCpuFeatures(*targetRuntime)); 
-            Regex::Check(db, NHyperscan::NPrivate::TImpl{*targetRuntime}); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(CrossPlatformCompile) { 
-        TestCrossPlatformCompile<TSimpleSingleRegex>(); 
-        TestCrossPlatformCompile<TAvx2SingleRegex>(); 
-        TestCrossPlatformCompile<TSimpleMultiRegex>(); 
-    } 
+
+    class TSimpleSingleRegex {
+    public:
+        static TDatabase Compile(TCPUFeatures cpuFeatures) {
+            return NHyperscan::Compile("foo", HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH, cpuFeatures);
+        }
+        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) {
+            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db);
+            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "foo", impl));
+            UNIT_ASSERT(!NHyperscan::NPrivate::Matches(db, scratch, "FOO", impl));
+        }
+    };
+
+    // This regex uses AVX2 instructions on long (>70) texts.
+    // It crushes when compiled for machine with AVX2 and run on machine without it.
+    class TAvx2SingleRegex {
+        public:
+        static TDatabase Compile(TCPUFeatures cpuFeatures) {
+            auto regex = "[ЁАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюяё]+"
+                         "[.][\\-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]{2,5}";
+            unsigned int flags = HS_FLAG_UTF8 | HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH | HS_FLAG_ALLOWEMPTY;
+            return NHyperscan::Compile(regex, flags, cpuFeatures);
+        }
+        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) {
+            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db);
+            UNIT_ASSERT(NHyperscan::NPrivate::Matches(
+                db,
+                scratch,
+                "_________________________________________________________________"
+                "фу.bar"
+                "_________________________________________________________________",
+                impl));
+            UNIT_ASSERT(!NHyperscan::NPrivate::Matches(
+                db,
+                scratch,
+                "_________________________________________________________________"
+                "фу"
+                "_________________________________________________________________",
+                impl));
+        }
+    };
+
+    class TSimpleMultiRegex {
+    public:
+        static TDatabase Compile(TCPUFeatures cpuFeatures) {
+            return NHyperscan::CompileMulti(
+                {
+                    "foo",
+                    "bar",
+                },
+                {
+                    HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH,
+                    HS_FLAG_DOTALL | HS_FLAG_SINGLEMATCH | HS_FLAG_CASELESS,
+                },
+                {
+                    42,
+                    241,
+                },
+                cpuFeatures);
+        }
+        static void Check(const TDatabase& db, const NHyperscan::NPrivate::TImpl& impl) {
+            NHyperscan::TScratch scratch = NHyperscan::MakeScratch(db);
+
+            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "foo", impl));
+            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "bar", impl));
+            UNIT_ASSERT(NHyperscan::NPrivate::Matches(db, scratch, "BAR", impl));
+            UNIT_ASSERT(!NHyperscan::NPrivate::Matches(db, scratch, "FOO", impl));
+
+            TSet<unsigned int> foundIds;
+            auto callback = [&](unsigned int id, unsigned long long /* from */, unsigned long long /* to */) {
+                foundIds.insert(id);
+            };
+            NHyperscan::NPrivate::Scan(
+                    db,
+                    scratch,
+                    "fooBaR",
+                    callback,
+                    impl);
+            UNIT_ASSERT_EQUAL(foundIds.size(), 2);
+            UNIT_ASSERT(foundIds.contains(42));
+            UNIT_ASSERT(foundIds.contains(241));
+        }
+    };
+
+    template <class Regex>
+    void TestCrossPlatformCompile() {
+        const std::array<ERuntime, 4> runtimes = {
+            ERuntime::Core2,
+            ERuntime::Corei7,
+            ERuntime::AVX2,
+            ERuntime::AVX512
+        };
+
+        // Unfortunately, we cannot emulate runtimes with more capabilities than current machine.
+        auto currentRuntimeIter = std::find(runtimes.cbegin(), runtimes.cend(), DetectCurrentRuntime());
+        Y_ASSERT(currentRuntimeIter != runtimes.cend());
+
+        for (auto targetRuntime = runtimes.cbegin(); targetRuntime <= currentRuntimeIter; ++targetRuntime) {
+            auto db = Regex::Compile(RuntimeCpuFeatures(*targetRuntime));
+            Regex::Check(db, NHyperscan::NPrivate::TImpl{*targetRuntime});
+        }
+    }
+
+    Y_UNIT_TEST(CrossPlatformCompile) {
+        TestCrossPlatformCompile<TSimpleSingleRegex>();
+        TestCrossPlatformCompile<TAvx2SingleRegex>();
+        TestCrossPlatformCompile<TSimpleMultiRegex>();
+    }
 }
diff --git a/library/cpp/regex/hyperscan/ya.make b/library/cpp/regex/hyperscan/ya.make
index e58d93502c..e99130ae18 100644
--- a/library/cpp/regex/hyperscan/ya.make
+++ b/library/cpp/regex/hyperscan/ya.make
@@ -15,5 +15,5 @@ SRCS(
 )
 
 END()
- 
-RECURSE_FOR_TESTS(ut) 
+
+RECURSE_FOR_TESTS(ut)