Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.

8 files changed, 396 insertions, 396 deletions

diff --git a/contrib/libs/re2/util/logging.h b/contrib/libs/re2/util/logging.h
index 5b2217f29c..924e2165f6 100644
--- a/contrib/libs/re2/util/logging.h
+++ b/contrib/libs/re2/util/logging.h
@@ -1,109 +1,109 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_LOGGING_H_
-#define UTIL_LOGGING_H_
-
-// Simplified version of Google's logging.
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ostream>
-#include <sstream>
-
-#include "util/util.h"
-
-// Debug-only checking.
-#define DCHECK(condition) assert(condition)
-#define DCHECK_EQ(val1, val2) assert((val1) == (val2))
-#define DCHECK_NE(val1, val2) assert((val1) != (val2))
-#define DCHECK_LE(val1, val2) assert((val1) <= (val2))
-#define DCHECK_LT(val1, val2) assert((val1) < (val2))
-#define DCHECK_GE(val1, val2) assert((val1) >= (val2))
-#define DCHECK_GT(val1, val2) assert((val1) > (val2))
-
-// Always-on checking
-#define CHECK(x)	if(x){}else LogMessageFatal(__FILE__, __LINE__).stream() << "Check failed: " #x
-#define CHECK_LT(x, y)	CHECK((x) < (y))
-#define CHECK_GT(x, y)	CHECK((x) > (y))
-#define CHECK_LE(x, y)	CHECK((x) <= (y))
-#define CHECK_GE(x, y)	CHECK((x) >= (y))
-#define CHECK_EQ(x, y)	CHECK((x) == (y))
-#define CHECK_NE(x, y)	CHECK((x) != (y))
-
-#define LOG_INFO LogMessage(__FILE__, __LINE__)
-#define LOG_WARNING LogMessage(__FILE__, __LINE__)
-#define LOG_ERROR LogMessage(__FILE__, __LINE__)
-#define LOG_FATAL LogMessageFatal(__FILE__, __LINE__)
-#define LOG_QFATAL LOG_FATAL
-
-// It seems that one of the Windows header files defines ERROR as 0.
-#ifdef _WIN32
-#define LOG_0 LOG_INFO
-#endif
-
-#ifdef NDEBUG
-#define LOG_DFATAL LOG_ERROR
-#else
-#define LOG_DFATAL LOG_FATAL
-#endif
-
-#define LOG(severity) LOG_ ## severity.stream()
-
-#define VLOG(x) if((x)>0){}else LOG_INFO.stream()
-
-class LogMessage {
- public:
-  LogMessage(const char* file, int line)
-      : flushed_(false) {
-    stream() << file << ":" << line << ": ";
-  }
-  void Flush() {
-    stream() << "\n";
+// Copyright 2009 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_LOGGING_H_ 
+#define UTIL_LOGGING_H_ 
+ 
+// Simplified version of Google's logging. 
+ 
+#include <assert.h> 
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <ostream> 
+#include <sstream> 
+ 
+#include "util/util.h" 
+ 
+// Debug-only checking. 
+#define DCHECK(condition) assert(condition) 
+#define DCHECK_EQ(val1, val2) assert((val1) == (val2)) 
+#define DCHECK_NE(val1, val2) assert((val1) != (val2)) 
+#define DCHECK_LE(val1, val2) assert((val1) <= (val2)) 
+#define DCHECK_LT(val1, val2) assert((val1) < (val2)) 
+#define DCHECK_GE(val1, val2) assert((val1) >= (val2)) 
+#define DCHECK_GT(val1, val2) assert((val1) > (val2)) 
+ 
+// Always-on checking 
+#define CHECK(x)	if(x){}else LogMessageFatal(__FILE__, __LINE__).stream() << "Check failed: " #x 
+#define CHECK_LT(x, y)	CHECK((x) < (y)) 
+#define CHECK_GT(x, y)	CHECK((x) > (y)) 
+#define CHECK_LE(x, y)	CHECK((x) <= (y)) 
+#define CHECK_GE(x, y)	CHECK((x) >= (y)) 
+#define CHECK_EQ(x, y)	CHECK((x) == (y)) 
+#define CHECK_NE(x, y)	CHECK((x) != (y)) 
+ 
+#define LOG_INFO LogMessage(__FILE__, __LINE__) 
+#define LOG_WARNING LogMessage(__FILE__, __LINE__) 
+#define LOG_ERROR LogMessage(__FILE__, __LINE__) 
+#define LOG_FATAL LogMessageFatal(__FILE__, __LINE__) 
+#define LOG_QFATAL LOG_FATAL 
+ 
+// It seems that one of the Windows header files defines ERROR as 0. 
+#ifdef _WIN32 
+#define LOG_0 LOG_INFO 
+#endif 
+ 
+#ifdef NDEBUG 
+#define LOG_DFATAL LOG_ERROR 
+#else 
+#define LOG_DFATAL LOG_FATAL 
+#endif 
+ 
+#define LOG(severity) LOG_ ## severity.stream() 
+ 
+#define VLOG(x) if((x)>0){}else LOG_INFO.stream() 
+ 
+class LogMessage { 
+ public: 
+  LogMessage(const char* file, int line) 
+      : flushed_(false) { 
+    stream() << file << ":" << line << ": "; 
+  } 
+  void Flush() { 
+    stream() << "\n"; 
     std::string s = str_.str();
-    size_t n = s.size();
-    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc
-    flushed_ = true;
-  }
-  ~LogMessage() {
-    if (!flushed_) {
-      Flush();
-    }
-  }
-  std::ostream& stream() { return str_; }
-
- private:
-  bool flushed_;
-  std::ostringstream str_;
-
-  LogMessage(const LogMessage&) = delete;
-  LogMessage& operator=(const LogMessage&) = delete;
-};
-
-// Silence "destructor never returns" warning for ~LogMessageFatal().
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4722)
-#endif
-
-class LogMessageFatal : public LogMessage {
- public:
-  LogMessageFatal(const char* file, int line)
-      : LogMessage(file, line) {}
+    size_t n = s.size(); 
+    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc 
+    flushed_ = true; 
+  } 
+  ~LogMessage() { 
+    if (!flushed_) { 
+      Flush(); 
+    } 
+  } 
+  std::ostream& stream() { return str_; } 
+ 
+ private: 
+  bool flushed_; 
+  std::ostringstream str_; 
+ 
+  LogMessage(const LogMessage&) = delete; 
+  LogMessage& operator=(const LogMessage&) = delete; 
+}; 
+ 
+// Silence "destructor never returns" warning for ~LogMessageFatal(). 
+// Since this is a header file, push and then pop to limit the scope. 
+#ifdef _MSC_VER 
+#pragma warning(push) 
+#pragma warning(disable: 4722) 
+#endif 
+ 
+class LogMessageFatal : public LogMessage { 
+ public: 
+  LogMessageFatal(const char* file, int line) 
+      : LogMessage(file, line) {} 
   ATTRIBUTE_NORETURN ~LogMessageFatal() {
-    Flush();
-    abort();
-  }
- private:
-  LogMessageFatal(const LogMessageFatal&) = delete;
-  LogMessageFatal& operator=(const LogMessageFatal&) = delete;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif  // UTIL_LOGGING_H_
+    Flush(); 
+    abort(); 
+  } 
+ private: 
+  LogMessageFatal(const LogMessageFatal&) = delete; 
+  LogMessageFatal& operator=(const LogMessageFatal&) = delete; 
+}; 
+ 
+#ifdef _MSC_VER 
+#pragma warning(pop) 
+#endif 
+ 
+#endif  // UTIL_LOGGING_H_ 
diff --git a/contrib/libs/re2/util/mix.h b/contrib/libs/re2/util/mix.h
index d85c172ab0..4404a27761 100644
--- a/contrib/libs/re2/util/mix.h
+++ b/contrib/libs/re2/util/mix.h
@@ -1,41 +1,41 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MIX_H_
-#define UTIL_MIX_H_
-
-#include <stddef.h>
-#include <limits>
-
-namespace re2 {
-
-// Silence "truncation of constant value" warning for kMul in 32-bit mode.
-// Since this is a header file, push and then pop to limit the scope.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4309)
-#endif
-
-class HashMix {
- public:
-  HashMix() : hash_(1) {}
-  explicit HashMix(size_t val) : hash_(val + 83) {}
-  void Mix(size_t val) {
-    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) + val;
-  }
-  size_t get() const { return hash_; }
- private:
-  size_t hash_;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-}  // namespace re2
-
-#endif  // UTIL_MIX_H_
+// Copyright 2016 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_MIX_H_ 
+#define UTIL_MIX_H_ 
+ 
+#include <stddef.h> 
+#include <limits> 
+ 
+namespace re2 { 
+ 
+// Silence "truncation of constant value" warning for kMul in 32-bit mode. 
+// Since this is a header file, push and then pop to limit the scope. 
+#ifdef _MSC_VER 
+#pragma warning(push) 
+#pragma warning(disable: 4309) 
+#endif 
+ 
+class HashMix { 
+ public: 
+  HashMix() : hash_(1) {} 
+  explicit HashMix(size_t val) : hash_(val + 83) {} 
+  void Mix(size_t val) { 
+    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL); 
+    hash_ *= kMul; 
+    hash_ = ((hash_ << 19) | 
+             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) + val; 
+  } 
+  size_t get() const { return hash_; } 
+ private: 
+  size_t hash_; 
+}; 
+ 
+#ifdef _MSC_VER 
+#pragma warning(pop) 
+#endif 
+ 
+}  // namespace re2 
+ 
+#endif  // UTIL_MIX_H_ 
diff --git a/contrib/libs/re2/util/mutex.h b/contrib/libs/re2/util/mutex.h
index 158046bb5c..6619daa4c4 100644
--- a/contrib/libs/re2/util/mutex.h
+++ b/contrib/libs/re2/util/mutex.h
@@ -1,15 +1,15 @@
-// Copyright 2007 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_MUTEX_H_
-#define UTIL_MUTEX_H_
-
-/*
- * A simple mutex wrapper, supporting locks and read-write locks.
- * You should assume the locks are *not* re-entrant.
- */
-
+// Copyright 2007 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_MUTEX_H_ 
+#define UTIL_MUTEX_H_ 
+ 
+/* 
+ * A simple mutex wrapper, supporting locks and read-write locks. 
+ * You should assume the locks are *not* re-entrant. 
+ */ 
+ 
 #ifdef _WIN32
 // Requires Windows Vista or Windows Server 2008 at minimum.
 #include <windows.h>
@@ -17,55 +17,55 @@
 #define MUTEX_IS_WIN32_SRWLOCK
 #endif
 #else
-#ifndef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE 200809L
-#endif
-#include <unistd.h>
-#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
-#define MUTEX_IS_PTHREAD_RWLOCK
-#endif
-#endif
-
+#ifndef _POSIX_C_SOURCE 
+#define _POSIX_C_SOURCE 200809L 
+#endif 
+#include <unistd.h> 
+#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0 
+#define MUTEX_IS_PTHREAD_RWLOCK 
+#endif 
+#endif 
+ 
 #if defined(MUTEX_IS_WIN32_SRWLOCK)
 typedef SRWLOCK MutexType;
 #elif defined(MUTEX_IS_PTHREAD_RWLOCK)
-#include <pthread.h>
-#include <stdlib.h>
-typedef pthread_rwlock_t MutexType;
-#else
-#include <mutex>
-typedef std::mutex MutexType;
-#endif
-
-namespace re2 {
-
-class Mutex {
- public:
-  inline Mutex();
-  inline ~Mutex();
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();   // Block until free or shared then acquire a share
-  inline void ReaderUnlock(); // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
-
- private:
-  MutexType mutex_;
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(Mutex *ignored);
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-};
-
+#include <pthread.h> 
+#include <stdlib.h> 
+typedef pthread_rwlock_t MutexType; 
+#else 
+#include <mutex> 
+typedef std::mutex MutexType; 
+#endif 
+ 
+namespace re2 { 
+ 
+class Mutex { 
+ public: 
+  inline Mutex(); 
+  inline ~Mutex(); 
+  inline void Lock();    // Block if needed until free then acquire exclusively 
+  inline void Unlock();  // Release a lock acquired via Lock() 
+  // Note that on systems that don't support read-write locks, these may 
+  // be implemented as synonyms to Lock() and Unlock().  So you can use 
+  // these for efficiency, but don't use them anyplace where being able 
+  // to do shared reads is necessary to avoid deadlock. 
+  inline void ReaderLock();   // Block until free or shared then acquire a share 
+  inline void ReaderUnlock(); // Release a read share of this Mutex 
+  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock 
+  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock() 
+ 
+ private: 
+  MutexType mutex_; 
+ 
+  // Catch the error of writing Mutex when intending MutexLock. 
+  Mutex(Mutex *ignored); 
+ 
+  Mutex(const Mutex&) = delete; 
+  Mutex& operator=(const Mutex&) = delete; 
+}; 
+ 
 #if defined(MUTEX_IS_WIN32_SRWLOCK)
-
+ 
 Mutex::Mutex()             : mutex_(SRWLOCK_INIT) { }
 Mutex::~Mutex()            { }
 void Mutex::Lock()         { AcquireSRWLockExclusive(&mutex_); }
@@ -75,74 +75,74 @@ void Mutex::ReaderUnlock() { ReleaseSRWLockShared(&mutex_); }
 
 #elif defined(MUTEX_IS_PTHREAD_RWLOCK)
 
-#define SAFE_PTHREAD(fncall)    \
-  do {                          \
-    if ((fncall) != 0) abort(); \
-  } while (0)
-
-Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
-
-#undef SAFE_PTHREAD
-
-#else
-
-Mutex::Mutex()             { }
-Mutex::~Mutex()            { }
-void Mutex::Lock()         { mutex_.lock(); }
-void Mutex::Unlock()       { mutex_.unlock(); }
-void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex.
-void Mutex::ReaderUnlock() { Unlock(); }
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
- private:
-  Mutex * const mu_;
-
-  MutexLock(const MutexLock&) = delete;
-  MutexLock& operator=(const MutexLock&) = delete;
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
- private:
-  Mutex * const mu_;
-
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
- private:
-  Mutex * const mu_;
-
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name")
-#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name")
-#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name")
-
-}  // namespace re2
-
-#endif  // UTIL_MUTEX_H_
+#define SAFE_PTHREAD(fncall)    \ 
+  do {                          \ 
+    if ((fncall) != 0) abort(); \ 
+  } while (0) 
+ 
+Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); } 
+Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); } 
+void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); } 
+void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 
+void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); } 
+void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); } 
+ 
+#undef SAFE_PTHREAD 
+ 
+#else 
+ 
+Mutex::Mutex()             { } 
+Mutex::~Mutex()            { } 
+void Mutex::Lock()         { mutex_.lock(); } 
+void Mutex::Unlock()       { mutex_.unlock(); } 
+void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex. 
+void Mutex::ReaderUnlock() { Unlock(); } 
+ 
+#endif 
+ 
+// -------------------------------------------------------------------------- 
+// Some helper classes 
+ 
+// MutexLock(mu) acquires mu when constructed and releases it when destroyed. 
+class MutexLock { 
+ public: 
+  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); } 
+  ~MutexLock() { mu_->Unlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  MutexLock(const MutexLock&) = delete; 
+  MutexLock& operator=(const MutexLock&) = delete; 
+}; 
+ 
+// ReaderMutexLock and WriterMutexLock do the same, for rwlocks 
+class ReaderMutexLock { 
+ public: 
+  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); } 
+  ~ReaderMutexLock() { mu_->ReaderUnlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  ReaderMutexLock(const ReaderMutexLock&) = delete; 
+  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete; 
+}; 
+ 
+class WriterMutexLock { 
+ public: 
+  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); } 
+  ~WriterMutexLock() { mu_->WriterUnlock(); } 
+ private: 
+  Mutex * const mu_; 
+ 
+  WriterMutexLock(const WriterMutexLock&) = delete; 
+  WriterMutexLock& operator=(const WriterMutexLock&) = delete; 
+}; 
+ 
+// Catch bug where variable name is omitted, e.g. MutexLock (&mu); 
+#define MutexLock(x) static_assert(false, "MutexLock declaration missing variable name") 
+#define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name") 
+#define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name") 
+ 
+}  // namespace re2 
+ 
+#endif  // UTIL_MUTEX_H_ 
diff --git a/contrib/libs/re2/util/rune.cc b/contrib/libs/re2/util/rune.cc
index 4f625ea380..d3066d2789 100644
--- a/contrib/libs/re2/util/rune.cc
+++ b/contrib/libs/re2/util/rune.cc
@@ -11,10 +11,10 @@
  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
  * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
  */
-
+ 
 #include <stdarg.h>
 #include <string.h>
-
+ 
 #include "util/utf.h"
 
 namespace re2 {
@@ -135,7 +135,7 @@ runetochar(char *str, const Rune *rune)
 	 */
 	c = *rune;
 	if(c <= Rune1) {
-		str[0] = static_cast<char>(c);
+		str[0] = static_cast<char>(c); 
 		return 1;
 	}
 
@@ -144,7 +144,7 @@ runetochar(char *str, const Rune *rune)
 	 *	0080-07FF => T2 Tx
 	 */
 	if(c <= Rune2) {
-		str[0] = T2 | static_cast<char>(c >> 1*Bitx);
+		str[0] = T2 | static_cast<char>(c >> 1*Bitx); 
 		str[1] = Tx | (c & Maskx);
 		return 2;
 	}
@@ -163,9 +163,9 @@ runetochar(char *str, const Rune *rune)
 	 *	0800-FFFF => T3 Tx Tx
 	 */
 	if (c <= Rune3) {
-		str[0] = T3 | static_cast<char>(c >> 2*Bitx);
+		str[0] = T3 | static_cast<char>(c >> 2*Bitx); 
 		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
-		str[2] = Tx | (c & Maskx);
+		str[2] = Tx | (c & Maskx); 
 		return 3;
 	}
 
@@ -173,7 +173,7 @@ runetochar(char *str, const Rune *rune)
 	 * four character sequence (21-bit value)
 	 *     10000-1FFFFF => T4 Tx Tx Tx
 	 */
-	str[0] = T4 | static_cast<char>(c >> 3*Bitx);
+	str[0] = T4 | static_cast<char>(c >> 3*Bitx); 
 	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
 	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
 	str[3] = Tx | (c & Maskx);
diff --git a/contrib/libs/re2/util/strutil.cc b/contrib/libs/re2/util/strutil.cc
index fb7e6b1b0c..475216a7e6 100644
--- a/contrib/libs/re2/util/strutil.cc
+++ b/contrib/libs/re2/util/strutil.cc
@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "util/strutil.h"
-
-#ifdef _WIN32
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#endif
-
+#include <stdarg.h> 
+#include <stdio.h> 
+
+#include "util/strutil.h" 
+ 
+#ifdef _WIN32 
+#define snprintf _snprintf 
+#define vsnprintf _vsnprintf 
+#endif 
+ 
 namespace re2 {
 
 // ----------------------------------------------------------------------
@@ -19,16 +19,16 @@ namespace re2 {
 //    Copies 'src' to 'dest', escaping dangerous characters using
 //    C-style escape sequences.  'src' and 'dest' should not overlap.
 //    Returns the number of bytes written to 'dest' (not including the \0)
-//    or (size_t)-1 if there was insufficient space.
+//    or (size_t)-1 if there was insufficient space. 
 // ----------------------------------------------------------------------
-static size_t CEscapeString(const char* src, size_t src_len,
-                            char* dest, size_t dest_len) {
+static size_t CEscapeString(const char* src, size_t src_len, 
+                            char* dest, size_t dest_len) { 
   const char* src_end = src + src_len;
-  size_t used = 0;
+  size_t used = 0; 
 
   for (; src < src_end; src++) {
-    if (dest_len - used < 2)   // space for two-character escape
-      return (size_t)-1;
+    if (dest_len - used < 2)   // space for two-character escape 
+      return (size_t)-1; 
 
     unsigned char c = *src;
     switch (c) {
@@ -43,9 +43,9 @@ static size_t CEscapeString(const char* src, size_t src_len,
         // digit then that digit must be escaped too to prevent it being
         // interpreted as part of the character code by C.
         if (c < ' ' || c > '~') {
-          if (dest_len - used < 5)   // space for four-character escape + \0
-            return (size_t)-1;
-          snprintf(dest + used, 5, "\\%03o", c);
+          if (dest_len - used < 5)   // space for four-character escape + \0 
+            return (size_t)-1; 
+          snprintf(dest + used, 5, "\\%03o", c); 
           used += 4;
         } else {
           dest[used++] = c; break;
@@ -54,7 +54,7 @@ static size_t CEscapeString(const char* src, size_t src_len,
   }
 
   if (dest_len - used < 1)   // make sure that there is room for \0
-    return (size_t)-1;
+    return (size_t)-1; 
 
   dest[used] = '\0';   // doesn't count towards return value though
   return used;
@@ -66,10 +66,10 @@ static size_t CEscapeString(const char* src, size_t src_len,
 //    C-style escape sequences.  'src' and 'dest' should not overlap.
 // ----------------------------------------------------------------------
 std::string CEscape(const StringPiece& src) {
-  const size_t dest_len = src.size() * 4 + 1; // Maximum possible expansion
-  char* dest = new char[dest_len];
-  const size_t used = CEscapeString(src.data(), src.size(),
-                                    dest, dest_len);
+  const size_t dest_len = src.size() * 4 + 1; // Maximum possible expansion 
+  char* dest = new char[dest_len]; 
+  const size_t used = CEscapeString(src.data(), src.size(), 
+                                    dest, dest_len); 
   std::string s = std::string(dest, used);
   delete[] dest;
   return s;
@@ -93,57 +93,57 @@ void PrefixSuccessor(std::string* prefix) {
 }
 
 static void StringAppendV(std::string* dst, const char* format, va_list ap) {
-  // First try with a small fixed size buffer
-  char space[1024];
-
-  // It's possible for methods that use a va_list to invalidate
-  // the data in it upon use.  The fix is to make a copy
-  // of the structure before using it and use that copy instead.
-  va_list backup_ap;
-  va_copy(backup_ap, ap);
-  int result = vsnprintf(space, sizeof(space), format, backup_ap);
-  va_end(backup_ap);
-
-  if ((result >= 0) && (static_cast<size_t>(result) < sizeof(space))) {
-    // It fit
-    dst->append(space, result);
-    return;
-  }
-
-  // Repeatedly increase buffer size until it fits
-  int length = sizeof(space);
-  while (true) {
-    if (result < 0) {
-      // Older behavior: just try doubling the buffer size
-      length *= 2;
-    } else {
-      // We need exactly "result+1" characters
-      length = result+1;
-    }
-    char* buf = new char[length];
-
-    // Restore the va_list before we use it again
-    va_copy(backup_ap, ap);
-    result = vsnprintf(buf, length, format, backup_ap);
-    va_end(backup_ap);
-
-    if ((result >= 0) && (result < length)) {
-      // It fit
-      dst->append(buf, result);
-      delete[] buf;
-      return;
-    }
-    delete[] buf;
-  }
-}
-
+  // First try with a small fixed size buffer 
+  char space[1024]; 
+ 
+  // It's possible for methods that use a va_list to invalidate 
+  // the data in it upon use.  The fix is to make a copy 
+  // of the structure before using it and use that copy instead. 
+  va_list backup_ap; 
+  va_copy(backup_ap, ap); 
+  int result = vsnprintf(space, sizeof(space), format, backup_ap); 
+  va_end(backup_ap); 
+ 
+  if ((result >= 0) && (static_cast<size_t>(result) < sizeof(space))) { 
+    // It fit 
+    dst->append(space, result); 
+    return; 
+  } 
+ 
+  // Repeatedly increase buffer size until it fits 
+  int length = sizeof(space); 
+  while (true) { 
+    if (result < 0) { 
+      // Older behavior: just try doubling the buffer size 
+      length *= 2; 
+    } else { 
+      // We need exactly "result+1" characters 
+      length = result+1; 
+    } 
+    char* buf = new char[length]; 
+ 
+    // Restore the va_list before we use it again 
+    va_copy(backup_ap, ap); 
+    result = vsnprintf(buf, length, format, backup_ap); 
+    va_end(backup_ap); 
+ 
+    if ((result >= 0) && (result < length)) { 
+      // It fit 
+      dst->append(buf, result); 
+      delete[] buf; 
+      return; 
+    } 
+    delete[] buf; 
+  } 
+} 
+ 
 std::string StringPrintf(const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
+  va_list ap; 
+  va_start(ap, format); 
   std::string result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-
+  StringAppendV(&result, format, ap); 
+  va_end(ap); 
+  return result; 
+} 
+ 
 }  // namespace re2
diff --git a/contrib/libs/re2/util/strutil.h b/contrib/libs/re2/util/strutil.h
index a69908a0dd..a8109c847f 100644
--- a/contrib/libs/re2/util/strutil.h
+++ b/contrib/libs/re2/util/strutil.h
@@ -1,21 +1,21 @@
-// Copyright 2016 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_STRUTIL_H_
-#define UTIL_STRUTIL_H_
-
-#include <string>
-
-#include "re2/stringpiece.h"
-#include "util/util.h"
-
-namespace re2 {
-
+// Copyright 2016 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_STRUTIL_H_ 
+#define UTIL_STRUTIL_H_ 
+ 
+#include <string> 
+ 
+#include "re2/stringpiece.h" 
+#include "util/util.h" 
+ 
+namespace re2 { 
+ 
 std::string CEscape(const StringPiece& src);
 void PrefixSuccessor(std::string* prefix);
 std::string StringPrintf(const char* format, ...);
+ 
+}  // namespace re2 
 
-}  // namespace re2
-
-#endif  // UTIL_STRUTIL_H_
+#endif  // UTIL_STRUTIL_H_ 
diff --git a/contrib/libs/re2/util/utf.h b/contrib/libs/re2/util/utf.h
index 85b4297239..b61561389f 100644
--- a/contrib/libs/re2/util/utf.h
+++ b/contrib/libs/re2/util/utf.h
@@ -15,9 +15,9 @@
  * in name space re2.
  */
 
-#ifndef UTIL_UTF_H_
-#define UTIL_UTF_H_
-
+#ifndef UTIL_UTF_H_ 
+#define UTIL_UTF_H_ 
+ 
 #include <stdint.h>
 
 namespace re2 {
@@ -41,4 +41,4 @@ char* utfrune(const char*, Rune);
 
 }  // namespace re2
 
-#endif  // UTIL_UTF_H_
+#endif  // UTIL_UTF_H_ 
diff --git a/contrib/libs/re2/util/util.h b/contrib/libs/re2/util/util.h
index 56e46c1a33..cfc30316bc 100644
--- a/contrib/libs/re2/util/util.h
+++ b/contrib/libs/re2/util/util.h
@@ -1,12 +1,12 @@
-// Copyright 2009 The RE2 Authors.  All Rights Reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef UTIL_UTIL_H_
-#define UTIL_UTIL_H_
-
+// Copyright 2009 The RE2 Authors.  All Rights Reserved. 
+// Use of this source code is governed by a BSD-style 
+// license that can be found in the LICENSE file. 
+ 
+#ifndef UTIL_UTIL_H_ 
+#define UTIL_UTIL_H_ 
+ 
 #define arraysize(array) (sizeof(array)/sizeof((array)[0]))
-
+ 
 #ifndef ATTRIBUTE_NORETURN
 #if defined(__GNUC__)
 #define ATTRIBUTE_NORETURN __attribute__((noreturn))
@@ -16,7 +16,7 @@
 #define ATTRIBUTE_NORETURN
 #endif
 #endif
-
+ 
 #ifndef ATTRIBUTE_UNUSED
 #if defined(__GNUC__)
 #define ATTRIBUTE_UNUSED __attribute__((unused))
@@ -25,18 +25,18 @@
 #endif
 #endif
 
-#ifndef FALLTHROUGH_INTENDED
+#ifndef FALLTHROUGH_INTENDED 
 #if defined(__clang__)
 #define FALLTHROUGH_INTENDED [[clang::fallthrough]]
 #elif defined(__GNUC__) && __GNUC__ >= 7
 #define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
 #else
 #define FALLTHROUGH_INTENDED do {} while (0)
+#endif 
 #endif
-#endif
-
-#ifndef NO_THREAD_SAFETY_ANALYSIS
-#define NO_THREAD_SAFETY_ANALYSIS
-#endif
-
-#endif  // UTIL_UTIL_H_
+ 
+#ifndef NO_THREAD_SAFETY_ANALYSIS 
+#define NO_THREAD_SAFETY_ANALYSIS 
+#endif 
+ 
+#endif  // UTIL_UTIL_H_