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

14 files changed, 47 insertions, 47 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h b/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
index 25f791535f..f405c562d4 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
@@ -23,7 +23,7 @@
 #include <vector>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
+#include "absl/base/internal/endian.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h b/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
index 963b7690f1..615ed41ce5 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
@@ -22,7 +22,7 @@
 #include <cmath>
 #include <cstdint>
 
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -34,10 +34,10 @@ namespace random_internal {
 // for instance--std::log2 rounds up rather than down, which introduces
 // definite skew in the results.
 inline int IntLog2Floor(uint64_t n) {
-  return (n <= 1) ? 0 : (63 - countl_zero(n));
+  return (n <= 1) ? 0 : (63 - countl_zero(n)); 
 }
 inline int IntLog2Ceil(uint64_t n) {
-  return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
+  return (n <= 1) ? 0 : (64 - countl_zero(n - 1)); 
 }
 
 inline double StirlingLogFactorial(double n) {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h b/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
index d5fbb44c24..6c08de7834 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
@@ -24,7 +24,7 @@
 #include <type_traits>
 
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/traits.h"
 
@@ -120,7 +120,7 @@ inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
 
   // Number of leading zeros is mapped to the exponent: 2^-clz
   // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
-  int clz = countl_zero(bits);
+  int clz = countl_zero(bits); 
   bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
   exp -= clz;                                 // set the exponent.
   bits >>= (63 - kExp);
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h b/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
index 9d6ab21ef5..0b1180d708 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
@@ -80,13 +80,13 @@ class MockHelpers {
   }
 
  public:
-  // InvokeMock is private; this provides access for some specialized use cases.
-  template <typename URBG>
-  static inline bool PrivateInvokeMock(URBG* urbg, IdType type,
-                                       void* args_tuple, void* result) {
-    return urbg->InvokeMock(type, args_tuple, result);
-  }
-
+  // InvokeMock is private; this provides access for some specialized use cases. 
+  template <typename URBG> 
+  static inline bool PrivateInvokeMock(URBG* urbg, IdType type, 
+                                       void* args_tuple, void* result) { 
+    return urbg->InvokeMock(type, args_tuple, result); 
+  } 
+ 
   // Invoke a mock for the KeyT (may or may not be a signature).
   //
   // KeyT is used to generate a typeid-based lookup key for the mock.
@@ -116,14 +116,14 @@ class MockHelpers {
   // The mocked function signature will be composed from KeyT as:
   //   result_type(args...)
   template <typename KeyT, typename MockURBG>
-  static auto MockFor(MockURBG& m)
-      -> decltype(m.template RegisterMock<
-                  typename KeySignature<KeyT>::result_type,
-                  typename KeySignature<KeyT>::arg_tuple_type>(
-          m, std::declval<IdType>())) {
+  static auto MockFor(MockURBG& m) 
+      -> decltype(m.template RegisterMock< 
+                  typename KeySignature<KeyT>::result_type, 
+                  typename KeySignature<KeyT>::arg_tuple_type>( 
+          m, std::declval<IdType>())) { 
     return m.template RegisterMock<typename KeySignature<KeyT>::result_type,
                                    typename KeySignature<KeyT>::arg_tuple_type>(
-        m, ::absl::base_internal::FastTypeId<KeyT>());
+        m, ::absl::base_internal::FastTypeId<KeyT>()); 
   }
 };
 
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h b/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
index 0d9c6c120c..6f3d33d917 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
@@ -44,12 +44,12 @@ struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> {
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
   using KeyT = Ret(DistrT, std::tuple<Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
+ 
+  template <typename MockURBG> 
+  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers) 
       -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, 
+                  "Mocking requires an absl::MockingBitGen"); 
     return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
   }
 };
@@ -60,14 +60,14 @@ struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> {
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
   using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen,
-                  const ::testing::Matcher<Args>&... matchers)
+ 
+  template <typename MockURBG> 
+  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen, 
+                  const ::testing::Matcher<Args>&... matchers) 
       -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher,
                                                              matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, 
+                  "Mocking requires an absl::MockingBitGen"); 
     return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
   }
 };
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h b/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
index 8efaf2e09a..0b07417aeb 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
@@ -19,7 +19,7 @@
 
 #include "absl/base/config.h"
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/iostream_state_saver.h"
@@ -262,7 +262,7 @@ struct pcg_xsl_rr_128_64 {
     uint64_t rotate = h >> 58u;
     uint64_t s = Uint128Low64(state) ^ h;
 #endif
-    return rotr(s, rotate);
+    return rotr(s, rotate); 
   }
 };
 
@@ -282,8 +282,8 @@ struct pcg_xsh_rr_64_32 {
   using state_type = uint64_t;
   using result_type = uint32_t;
   inline uint32_t operator()(uint64_t state) {
-    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27),
-                state >> 59);
+    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27), 
+                state >> 59); 
   }
 };
 
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc b/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
index c1bc044435..ad8ac3bb6d 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
@@ -17,7 +17,7 @@
 #include "absl/base/internal/raw_logging.h"
 #include "absl/random/internal/randen_detect.h"
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
index 9a3840b8f1..acb34f3908 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
@@ -26,7 +26,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc b/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
index bbe7b96532..c8de07ac7f 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
@@ -1,13 +1,13 @@
 // Copyright 2017 The Abseil Authors.
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
+// Licensed under the Apache License, Version 2.0 (the "License"); 
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
+// distributed under the License is distributed on an "AS IS" BASIS, 
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
index 372c3ac2bd..870ee2caf4 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
@@ -23,7 +23,7 @@
 #include <limits>
 #include <type_traits>
 
-#include "absl/base/internal/endian.h"
+#include "absl/base/internal/endian.h" 
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/randen.h"
@@ -77,7 +77,7 @@ class alignas(16) randen_engine {
       impl_.Generate(state_);
     }
 
-    return little_endian::ToHost(state_[next_++]);
+    return little_endian::ToHost(state_[next_++]); 
   }
 
   template <class SeedSequence>
@@ -189,8 +189,8 @@ class alignas(16) randen_engine {
       // In the case that `elem` is `uint8_t`, it must be cast to something
       // larger so that it prints as an integer rather than a character. For
       // simplicity, apply the cast all circumstances.
-      os << static_cast<numeric_type>(little_endian::FromHost(elem))
-         << os.fill();
+      os << static_cast<numeric_type>(little_endian::FromHost(elem)) 
+         << os.fill(); 
     }
     os << engine.next_;
     return os;
@@ -209,7 +209,7 @@ class alignas(16) randen_engine {
       // necessary to read a wider type and then cast it to uint8_t.
       numeric_type value;
       is >> value;
-      elem = little_endian::ToHost(static_cast<result_type>(value));
+      elem = little_endian::ToHost(static_cast<result_type>(value)); 
     }
     is >> next;
     if (is.fail()) {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
index 71a7f69f25..4c241dc743 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
@@ -26,7 +26,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
index 532c3a8991..abc23ce6b0 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
@@ -23,7 +23,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // RandenSlow implements the basic state manipulation methods for
 // architectures lacking AES hardware acceleration intrinsics.
 class RandenSlow {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
index 120022c9fb..18e6d38d14 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
@@ -28,7 +28,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h b/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
index b6e6c4b6aa..609d411f73 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
@@ -26,7 +26,7 @@
 #endif
 
 #include "absl/base/config.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/traits.h"