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

1 files changed, 481 insertions, 481 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/container/fixed_array.h b/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
index 839ba0bc16..3048219879 100644
--- a/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
+++ b/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
@@ -1,107 +1,107 @@
-// Copyright 2018 The Abseil Authors.
-//
-// 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,
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: fixed_array.h
-// -----------------------------------------------------------------------------
-//
-// A `FixedArray<T>` represents a non-resizable array of `T` where the length of
-// the array can be determined at run-time. It is a good replacement for
-// non-standard and deprecated uses of `alloca()` and variable length arrays
-// within the GCC extension. (See
-// https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html).
-//
-// `FixedArray` allocates small arrays inline, keeping performance fast by
-// avoiding heap operations. It also helps reduce the chances of
-// accidentally overflowing your stack if large input is passed to
-// your function.
-
-#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_
-#define ABSL_CONTAINER_FIXED_ARRAY_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <new>
-#include <type_traits>
-
-#include "absl/algorithm/algorithm.h"
+// Copyright 2018 The Abseil Authors. 
+// 
+// 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, 
+// 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: fixed_array.h 
+// ----------------------------------------------------------------------------- 
+// 
+// A `FixedArray<T>` represents a non-resizable array of `T` where the length of 
+// the array can be determined at run-time. It is a good replacement for 
+// non-standard and deprecated uses of `alloca()` and variable length arrays 
+// within the GCC extension. (See 
+// https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html). 
+// 
+// `FixedArray` allocates small arrays inline, keeping performance fast by 
+// avoiding heap operations. It also helps reduce the chances of 
+// accidentally overflowing your stack if large input is passed to 
+// your function. 
+ 
+#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_ 
+#define ABSL_CONTAINER_FIXED_ARRAY_H_ 
+ 
+#include <algorithm> 
+#include <cassert> 
+#include <cstddef> 
+#include <initializer_list> 
+#include <iterator> 
+#include <limits> 
+#include <memory> 
+#include <new> 
+#include <type_traits> 
+ 
+#include "absl/algorithm/algorithm.h" 
 #include "absl/base/config.h"
-#include "absl/base/dynamic_annotations.h"
-#include "absl/base/internal/throw_delegate.h"
-#include "absl/base/macros.h"
-#include "absl/base/optimization.h"
-#include "absl/base/port.h"
-#include "absl/container/internal/compressed_tuple.h"
-#include "absl/memory/memory.h"
-
-namespace absl {
+#include "absl/base/dynamic_annotations.h" 
+#include "absl/base/internal/throw_delegate.h" 
+#include "absl/base/macros.h" 
+#include "absl/base/optimization.h" 
+#include "absl/base/port.h" 
+#include "absl/container/internal/compressed_tuple.h" 
+#include "absl/memory/memory.h" 
+ 
+namespace absl { 
 ABSL_NAMESPACE_BEGIN
-
-constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
-
-// -----------------------------------------------------------------------------
-// FixedArray
-// -----------------------------------------------------------------------------
-//
-// A `FixedArray` provides a run-time fixed-size array, allocating a small array
-// inline for efficiency.
-//
-// Most users should not specify an `inline_elements` argument and let
-// `FixedArray` automatically determine the number of elements
-// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
-// `FixedArray` implementation will use inline storage for arrays with a
-// length <= `inline_elements`.
-//
-// Note that a `FixedArray` constructed with a `size_type` argument will
-// default-initialize its values by leaving trivially constructible types
-// uninitialized (e.g. int, int[4], double), and others default-constructed.
-// This matches the behavior of c-style arrays and `std::array`, but not
-// `std::vector`.
-template <typename T, size_t N = kFixedArrayUseDefault,
-          typename A = std::allocator<T>>
-class FixedArray {
-  static_assert(!std::is_array<T>::value || std::extent<T>::value > 0,
-                "Arrays with unknown bounds cannot be used with FixedArray.");
-
-  static constexpr size_t kInlineBytesDefault = 256;
-
-  using AllocatorTraits = std::allocator_traits<A>;
-  // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
-  // but this seems to be mostly pedantic.
-  template <typename Iterator>
-  using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
-      typename std::iterator_traits<Iterator>::iterator_category,
-      std::forward_iterator_tag>::value>;
-  static constexpr bool NoexceptCopyable() {
-    return std::is_nothrow_copy_constructible<StorageElement>::value &&
-           absl::allocator_is_nothrow<allocator_type>::value;
-  }
-  static constexpr bool NoexceptMovable() {
-    return std::is_nothrow_move_constructible<StorageElement>::value &&
-           absl::allocator_is_nothrow<allocator_type>::value;
-  }
-  static constexpr bool DefaultConstructorIsNonTrivial() {
-    return !absl::is_trivially_default_constructible<StorageElement>::value;
-  }
-
- public:
-  using allocator_type = typename AllocatorTraits::allocator_type;
+ 
+constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1); 
+ 
+// ----------------------------------------------------------------------------- 
+// FixedArray 
+// ----------------------------------------------------------------------------- 
+// 
+// A `FixedArray` provides a run-time fixed-size array, allocating a small array 
+// inline for efficiency. 
+// 
+// Most users should not specify an `inline_elements` argument and let 
+// `FixedArray` automatically determine the number of elements 
+// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the 
+// `FixedArray` implementation will use inline storage for arrays with a 
+// length <= `inline_elements`. 
+// 
+// Note that a `FixedArray` constructed with a `size_type` argument will 
+// default-initialize its values by leaving trivially constructible types 
+// uninitialized (e.g. int, int[4], double), and others default-constructed. 
+// This matches the behavior of c-style arrays and `std::array`, but not 
+// `std::vector`. 
+template <typename T, size_t N = kFixedArrayUseDefault, 
+          typename A = std::allocator<T>> 
+class FixedArray { 
+  static_assert(!std::is_array<T>::value || std::extent<T>::value > 0, 
+                "Arrays with unknown bounds cannot be used with FixedArray."); 
+ 
+  static constexpr size_t kInlineBytesDefault = 256; 
+ 
+  using AllocatorTraits = std::allocator_traits<A>; 
+  // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17, 
+  // but this seems to be mostly pedantic. 
+  template <typename Iterator> 
+  using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible< 
+      typename std::iterator_traits<Iterator>::iterator_category, 
+      std::forward_iterator_tag>::value>; 
+  static constexpr bool NoexceptCopyable() { 
+    return std::is_nothrow_copy_constructible<StorageElement>::value && 
+           absl::allocator_is_nothrow<allocator_type>::value; 
+  } 
+  static constexpr bool NoexceptMovable() { 
+    return std::is_nothrow_move_constructible<StorageElement>::value && 
+           absl::allocator_is_nothrow<allocator_type>::value; 
+  } 
+  static constexpr bool DefaultConstructorIsNonTrivial() { 
+    return !absl::is_trivially_default_constructible<StorageElement>::value; 
+  } 
+ 
+ public: 
+  using allocator_type = typename AllocatorTraits::allocator_type; 
   using value_type = typename AllocatorTraits::value_type;
   using pointer = typename AllocatorTraits::pointer;
   using const_pointer = typename AllocatorTraits::const_pointer;
@@ -109,419 +109,419 @@ class FixedArray {
   using const_reference = const value_type&;
   using size_type = typename AllocatorTraits::size_type;
   using difference_type = typename AllocatorTraits::difference_type;
-  using iterator = pointer;
-  using const_iterator = const_pointer;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-  static constexpr size_type inline_elements =
-      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
-                                  : static_cast<size_type>(N));
-
-  FixedArray(
-      const FixedArray& other,
-      const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable())
-      : FixedArray(other.begin(), other.end(), a) {}
-
-  FixedArray(
-      FixedArray&& other,
-      const allocator_type& a = allocator_type()) noexcept(NoexceptMovable())
-      : FixedArray(std::make_move_iterator(other.begin()),
-                   std::make_move_iterator(other.end()), a) {}
-
-  // Creates an array object that can store `n` elements.
-  // Note that trivially constructible elements will be uninitialized.
-  explicit FixedArray(size_type n, const allocator_type& a = allocator_type())
-      : storage_(n, a) {
-    if (DefaultConstructorIsNonTrivial()) {
-      memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
-                                      storage_.end());
-    }
-  }
-
-  // Creates an array initialized with `n` copies of `val`.
-  FixedArray(size_type n, const value_type& val,
-             const allocator_type& a = allocator_type())
-      : storage_(n, a) {
-    memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
-                                    storage_.end(), val);
-  }
-
-  // Creates an array initialized with the size and contents of `init_list`.
-  FixedArray(std::initializer_list<value_type> init_list,
-             const allocator_type& a = allocator_type())
-      : FixedArray(init_list.begin(), init_list.end(), a) {}
-
-  // Creates an array initialized with the elements from the input
-  // range. The array's size will always be `std::distance(first, last)`.
-  // REQUIRES: Iterator must be a forward_iterator or better.
-  template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
-  FixedArray(Iterator first, Iterator last,
-             const allocator_type& a = allocator_type())
-      : storage_(std::distance(first, last), a) {
-    memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last);
-  }
-
-  ~FixedArray() noexcept {
-    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
-      AllocatorTraits::destroy(storage_.alloc(), cur);
-    }
-  }
-
-  // Assignments are deleted because they break the invariant that the size of a
-  // `FixedArray` never changes.
-  void operator=(FixedArray&&) = delete;
-  void operator=(const FixedArray&) = delete;
-
-  // FixedArray::size()
-  //
-  // Returns the length of the fixed array.
-  size_type size() const { return storage_.size(); }
-
-  // FixedArray::max_size()
-  //
-  // Returns the largest possible value of `std::distance(begin(), end())` for a
-  // `FixedArray<T>`. This is equivalent to the most possible addressable bytes
-  // over the number of bytes taken by T.
-  constexpr size_type max_size() const {
-    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
-  }
-
-  // FixedArray::empty()
-  //
-  // Returns whether or not the fixed array is empty.
-  bool empty() const { return size() == 0; }
-
-  // FixedArray::memsize()
-  //
-  // Returns the memory size of the fixed array in bytes.
-  size_t memsize() const { return size() * sizeof(value_type); }
-
-  // FixedArray::data()
-  //
-  // Returns a const T* pointer to elements of the `FixedArray`. This pointer
-  // can be used to access (but not modify) the contained elements.
-  const_pointer data() const { return AsValueType(storage_.begin()); }
-
-  // Overload of FixedArray::data() to return a T* pointer to elements of the
-  // fixed array. This pointer can be used to access and modify the contained
-  // elements.
-  pointer data() { return AsValueType(storage_.begin()); }
-
-  // FixedArray::operator[]
-  //
-  // Returns a reference the ith element of the fixed array.
-  // REQUIRES: 0 <= i < size()
-  reference operator[](size_type i) {
+  using iterator = pointer; 
+  using const_iterator = const_pointer; 
+  using reverse_iterator = std::reverse_iterator<iterator>; 
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>; 
+ 
+  static constexpr size_type inline_elements = 
+      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type) 
+                                  : static_cast<size_type>(N)); 
+ 
+  FixedArray( 
+      const FixedArray& other, 
+      const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable()) 
+      : FixedArray(other.begin(), other.end(), a) {} 
+ 
+  FixedArray( 
+      FixedArray&& other, 
+      const allocator_type& a = allocator_type()) noexcept(NoexceptMovable()) 
+      : FixedArray(std::make_move_iterator(other.begin()), 
+                   std::make_move_iterator(other.end()), a) {} 
+ 
+  // Creates an array object that can store `n` elements. 
+  // Note that trivially constructible elements will be uninitialized. 
+  explicit FixedArray(size_type n, const allocator_type& a = allocator_type()) 
+      : storage_(n, a) { 
+    if (DefaultConstructorIsNonTrivial()) { 
+      memory_internal::ConstructRange(storage_.alloc(), storage_.begin(), 
+                                      storage_.end()); 
+    } 
+  } 
+ 
+  // Creates an array initialized with `n` copies of `val`. 
+  FixedArray(size_type n, const value_type& val, 
+             const allocator_type& a = allocator_type()) 
+      : storage_(n, a) { 
+    memory_internal::ConstructRange(storage_.alloc(), storage_.begin(), 
+                                    storage_.end(), val); 
+  } 
+ 
+  // Creates an array initialized with the size and contents of `init_list`. 
+  FixedArray(std::initializer_list<value_type> init_list, 
+             const allocator_type& a = allocator_type()) 
+      : FixedArray(init_list.begin(), init_list.end(), a) {} 
+ 
+  // Creates an array initialized with the elements from the input 
+  // range. The array's size will always be `std::distance(first, last)`. 
+  // REQUIRES: Iterator must be a forward_iterator or better. 
+  template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr> 
+  FixedArray(Iterator first, Iterator last, 
+             const allocator_type& a = allocator_type()) 
+      : storage_(std::distance(first, last), a) { 
+    memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last); 
+  } 
+ 
+  ~FixedArray() noexcept { 
+    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) { 
+      AllocatorTraits::destroy(storage_.alloc(), cur); 
+    } 
+  } 
+ 
+  // Assignments are deleted because they break the invariant that the size of a 
+  // `FixedArray` never changes. 
+  void operator=(FixedArray&&) = delete; 
+  void operator=(const FixedArray&) = delete; 
+ 
+  // FixedArray::size() 
+  // 
+  // Returns the length of the fixed array. 
+  size_type size() const { return storage_.size(); } 
+ 
+  // FixedArray::max_size() 
+  // 
+  // Returns the largest possible value of `std::distance(begin(), end())` for a 
+  // `FixedArray<T>`. This is equivalent to the most possible addressable bytes 
+  // over the number of bytes taken by T. 
+  constexpr size_type max_size() const { 
+    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type); 
+  } 
+ 
+  // FixedArray::empty() 
+  // 
+  // Returns whether or not the fixed array is empty. 
+  bool empty() const { return size() == 0; } 
+ 
+  // FixedArray::memsize() 
+  // 
+  // Returns the memory size of the fixed array in bytes. 
+  size_t memsize() const { return size() * sizeof(value_type); } 
+ 
+  // FixedArray::data() 
+  // 
+  // Returns a const T* pointer to elements of the `FixedArray`. This pointer 
+  // can be used to access (but not modify) the contained elements. 
+  const_pointer data() const { return AsValueType(storage_.begin()); } 
+ 
+  // Overload of FixedArray::data() to return a T* pointer to elements of the 
+  // fixed array. This pointer can be used to access and modify the contained 
+  // elements. 
+  pointer data() { return AsValueType(storage_.begin()); } 
+ 
+  // FixedArray::operator[] 
+  // 
+  // Returns a reference the ith element of the fixed array. 
+  // REQUIRES: 0 <= i < size() 
+  reference operator[](size_type i) { 
     ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // Overload of FixedArray::operator()[] to return a const reference to the
-  // ith element of the fixed array.
-  // REQUIRES: 0 <= i < size()
-  const_reference operator[](size_type i) const {
+    return data()[i]; 
+  } 
+ 
+  // Overload of FixedArray::operator()[] to return a const reference to the 
+  // ith element of the fixed array. 
+  // REQUIRES: 0 <= i < size() 
+  const_reference operator[](size_type i) const { 
     ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // FixedArray::at
-  //
+    return data()[i]; 
+  } 
+ 
+  // FixedArray::at 
+  // 
   // Bounds-checked access.  Returns a reference to the ith element of the fixed
   // array, or throws std::out_of_range
-  reference at(size_type i) {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // Overload of FixedArray::at() to return a const reference to the ith element
-  // of the fixed array.
-  const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // FixedArray::front()
-  //
-  // Returns a reference to the first element of the fixed array.
+  reference at(size_type i) { 
+    if (ABSL_PREDICT_FALSE(i >= size())) { 
+      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check"); 
+    } 
+    return data()[i]; 
+  } 
+ 
+  // Overload of FixedArray::at() to return a const reference to the ith element 
+  // of the fixed array. 
+  const_reference at(size_type i) const { 
+    if (ABSL_PREDICT_FALSE(i >= size())) { 
+      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check"); 
+    } 
+    return data()[i]; 
+  } 
+ 
+  // FixedArray::front() 
+  // 
+  // Returns a reference to the first element of the fixed array. 
   reference front() {
     ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
-
-  // Overload of FixedArray::front() to return a reference to the first element
-  // of a fixed array of const values.
+ 
+  // Overload of FixedArray::front() to return a reference to the first element 
+  // of a fixed array of const values. 
   const_reference front() const {
     ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
-
-  // FixedArray::back()
-  //
-  // Returns a reference to the last element of the fixed array.
+ 
+  // FixedArray::back() 
+  // 
+  // Returns a reference to the last element of the fixed array. 
   reference back() {
     ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
-
-  // Overload of FixedArray::back() to return a reference to the last element
-  // of a fixed array of const values.
+ 
+  // Overload of FixedArray::back() to return a reference to the last element 
+  // of a fixed array of const values. 
   const_reference back() const {
     ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
-
-  // FixedArray::begin()
-  //
-  // Returns an iterator to the beginning of the fixed array.
-  iterator begin() { return data(); }
-
-  // Overload of FixedArray::begin() to return a const iterator to the
-  // beginning of the fixed array.
-  const_iterator begin() const { return data(); }
-
-  // FixedArray::cbegin()
-  //
-  // Returns a const iterator to the beginning of the fixed array.
-  const_iterator cbegin() const { return begin(); }
-
-  // FixedArray::end()
-  //
-  // Returns an iterator to the end of the fixed array.
-  iterator end() { return data() + size(); }
-
-  // Overload of FixedArray::end() to return a const iterator to the end of the
-  // fixed array.
-  const_iterator end() const { return data() + size(); }
-
-  // FixedArray::cend()
-  //
-  // Returns a const iterator to the end of the fixed array.
-  const_iterator cend() const { return end(); }
-
-  // FixedArray::rbegin()
-  //
-  // Returns a reverse iterator from the end of the fixed array.
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-
-  // Overload of FixedArray::rbegin() to return a const reverse iterator from
-  // the end of the fixed array.
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-
-  // FixedArray::crbegin()
-  //
-  // Returns a const reverse iterator from the end of the fixed array.
-  const_reverse_iterator crbegin() const { return rbegin(); }
-
-  // FixedArray::rend()
-  //
-  // Returns a reverse iterator from the beginning of the fixed array.
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-
-  // Overload of FixedArray::rend() for returning a const reverse iterator
-  // from the beginning of the fixed array.
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  // FixedArray::crend()
-  //
-  // Returns a reverse iterator from the beginning of the fixed array.
-  const_reverse_iterator crend() const { return rend(); }
-
-  // FixedArray::fill()
-  //
-  // Assigns the given `value` to all elements in the fixed array.
-  void fill(const value_type& val) { std::fill(begin(), end(), val); }
-
-  // Relational operators. Equality operators are elementwise using
-  // `operator==`, while order operators order FixedArrays lexicographically.
-  friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
-    return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-  }
-
-  friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) {
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
-                                        rhs.end());
-  }
-
-  friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) {
-    return rhs < lhs;
-  }
-
-  friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(rhs < lhs);
-  }
-
-  friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(lhs < rhs);
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H h, const FixedArray& v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      v.size());
-  }
-
- private:
-  // StorageElement
-  //
-  // For FixedArrays with a C-style-array value_type, StorageElement is a POD
-  // wrapper struct called StorageElementWrapper that holds the value_type
-  // instance inside. This is needed for construction and destruction of the
-  // entire array regardless of how many dimensions it has. For all other cases,
-  // StorageElement is just an alias of value_type.
-  //
-  // Maintainer's Note: The simpler solution would be to simply wrap value_type
-  // in a struct whether it's an array or not. That causes some paranoid
-  // diagnostics to misfire, believing that 'data()' returns a pointer to a
-  // single element, rather than the packed array that it really is.
-  // e.g.:
-  //
-  //     FixedArray<char> buf(1);
-  //     sprintf(buf.data(), "foo");
-  //
-  //     error: call to int __builtin___sprintf_chk(etc...)
-  //     will always overflow destination buffer [-Werror]
-  //
-  template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>,
-            size_t InnerN = std::extent<OuterT>::value>
-  struct StorageElementWrapper {
-    InnerT array[InnerN];
-  };
-
-  using StorageElement =
-      absl::conditional_t<std::is_array<value_type>::value,
-                          StorageElementWrapper<value_type>, value_type>;
-
-  static pointer AsValueType(pointer ptr) { return ptr; }
-  static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
-    return std::addressof(ptr->array);
-  }
-
-  static_assert(sizeof(StorageElement) == sizeof(value_type), "");
-  static_assert(alignof(StorageElement) == alignof(value_type), "");
-
-  class NonEmptyInlinedStorage {
-   public:
-    StorageElement* data() { return reinterpret_cast<StorageElement*>(buff_); }
-    void AnnotateConstruct(size_type n);
-    void AnnotateDestruct(size_type n);
-
+ 
+  // FixedArray::begin() 
+  // 
+  // Returns an iterator to the beginning of the fixed array. 
+  iterator begin() { return data(); } 
+ 
+  // Overload of FixedArray::begin() to return a const iterator to the 
+  // beginning of the fixed array. 
+  const_iterator begin() const { return data(); } 
+ 
+  // FixedArray::cbegin() 
+  // 
+  // Returns a const iterator to the beginning of the fixed array. 
+  const_iterator cbegin() const { return begin(); } 
+ 
+  // FixedArray::end() 
+  // 
+  // Returns an iterator to the end of the fixed array. 
+  iterator end() { return data() + size(); } 
+ 
+  // Overload of FixedArray::end() to return a const iterator to the end of the 
+  // fixed array. 
+  const_iterator end() const { return data() + size(); } 
+ 
+  // FixedArray::cend() 
+  // 
+  // Returns a const iterator to the end of the fixed array. 
+  const_iterator cend() const { return end(); } 
+ 
+  // FixedArray::rbegin() 
+  // 
+  // Returns a reverse iterator from the end of the fixed array. 
+  reverse_iterator rbegin() { return reverse_iterator(end()); } 
+ 
+  // Overload of FixedArray::rbegin() to return a const reverse iterator from 
+  // the end of the fixed array. 
+  const_reverse_iterator rbegin() const { 
+    return const_reverse_iterator(end()); 
+  } 
+ 
+  // FixedArray::crbegin() 
+  // 
+  // Returns a const reverse iterator from the end of the fixed array. 
+  const_reverse_iterator crbegin() const { return rbegin(); } 
+ 
+  // FixedArray::rend() 
+  // 
+  // Returns a reverse iterator from the beginning of the fixed array. 
+  reverse_iterator rend() { return reverse_iterator(begin()); } 
+ 
+  // Overload of FixedArray::rend() for returning a const reverse iterator 
+  // from the beginning of the fixed array. 
+  const_reverse_iterator rend() const { 
+    return const_reverse_iterator(begin()); 
+  } 
+ 
+  // FixedArray::crend() 
+  // 
+  // Returns a reverse iterator from the beginning of the fixed array. 
+  const_reverse_iterator crend() const { return rend(); } 
+ 
+  // FixedArray::fill() 
+  // 
+  // Assigns the given `value` to all elements in the fixed array. 
+  void fill(const value_type& val) { std::fill(begin(), end(), val); } 
+ 
+  // Relational operators. Equality operators are elementwise using 
+  // `operator==`, while order operators order FixedArrays lexicographically. 
+  friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) { 
+    return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); 
+  } 
+ 
+  friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) { 
+    return !(lhs == rhs); 
+  } 
+ 
+  friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) { 
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), 
+                                        rhs.end()); 
+  } 
+ 
+  friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) { 
+    return rhs < lhs; 
+  } 
+ 
+  friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) { 
+    return !(rhs < lhs); 
+  } 
+ 
+  friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) { 
+    return !(lhs < rhs); 
+  } 
+ 
+  template <typename H> 
+  friend H AbslHashValue(H h, const FixedArray& v) { 
+    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()), 
+                      v.size()); 
+  } 
+ 
+ private: 
+  // StorageElement 
+  // 
+  // For FixedArrays with a C-style-array value_type, StorageElement is a POD 
+  // wrapper struct called StorageElementWrapper that holds the value_type 
+  // instance inside. This is needed for construction and destruction of the 
+  // entire array regardless of how many dimensions it has. For all other cases, 
+  // StorageElement is just an alias of value_type. 
+  // 
+  // Maintainer's Note: The simpler solution would be to simply wrap value_type 
+  // in a struct whether it's an array or not. That causes some paranoid 
+  // diagnostics to misfire, believing that 'data()' returns a pointer to a 
+  // single element, rather than the packed array that it really is. 
+  // e.g.: 
+  // 
+  //     FixedArray<char> buf(1); 
+  //     sprintf(buf.data(), "foo"); 
+  // 
+  //     error: call to int __builtin___sprintf_chk(etc...) 
+  //     will always overflow destination buffer [-Werror] 
+  // 
+  template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>, 
+            size_t InnerN = std::extent<OuterT>::value> 
+  struct StorageElementWrapper { 
+    InnerT array[InnerN]; 
+  }; 
+ 
+  using StorageElement = 
+      absl::conditional_t<std::is_array<value_type>::value, 
+                          StorageElementWrapper<value_type>, value_type>; 
+ 
+  static pointer AsValueType(pointer ptr) { return ptr; } 
+  static pointer AsValueType(StorageElementWrapper<value_type>* ptr) { 
+    return std::addressof(ptr->array); 
+  } 
+ 
+  static_assert(sizeof(StorageElement) == sizeof(value_type), ""); 
+  static_assert(alignof(StorageElement) == alignof(value_type), ""); 
+ 
+  class NonEmptyInlinedStorage { 
+   public: 
+    StorageElement* data() { return reinterpret_cast<StorageElement*>(buff_); } 
+    void AnnotateConstruct(size_type n); 
+    void AnnotateDestruct(size_type n); 
+ 
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-    void* RedzoneBegin() { return &redzone_begin_; }
-    void* RedzoneEnd() { return &redzone_end_ + 1; }
+    void* RedzoneBegin() { return &redzone_begin_; } 
+    void* RedzoneEnd() { return &redzone_end_ + 1; } 
 #endif  // ABSL_HAVE_ADDRESS_SANITIZER
-
-   private:
+ 
+   private: 
     ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
-    alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
+    alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])]; 
     ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
-  };
-
-  class EmptyInlinedStorage {
-   public:
-    StorageElement* data() { return nullptr; }
-    void AnnotateConstruct(size_type) {}
-    void AnnotateDestruct(size_type) {}
-  };
-
-  using InlinedStorage =
-      absl::conditional_t<inline_elements == 0, EmptyInlinedStorage,
-                          NonEmptyInlinedStorage>;
-
-  // Storage
-  //
-  // An instance of Storage manages the inline and out-of-line memory for
-  // instances of FixedArray. This guarantees that even when construction of
-  // individual elements fails in the FixedArray constructor body, the
-  // destructor for Storage will still be called and out-of-line memory will be
-  // properly deallocated.
-  //
-  class Storage : public InlinedStorage {
-   public:
-    Storage(size_type n, const allocator_type& a)
-        : size_alloc_(n, a), data_(InitializeData()) {}
-
-    ~Storage() noexcept {
-      if (UsingInlinedStorage(size())) {
-        InlinedStorage::AnnotateDestruct(size());
-      } else {
-        AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size());
-      }
-    }
-
-    size_type size() const { return size_alloc_.template get<0>(); }
-    StorageElement* begin() const { return data_; }
-    StorageElement* end() const { return begin() + size(); }
-    allocator_type& alloc() { return size_alloc_.template get<1>(); }
-
-   private:
-    static bool UsingInlinedStorage(size_type n) {
-      return n <= inline_elements;
-    }
-
-    StorageElement* InitializeData() {
-      if (UsingInlinedStorage(size())) {
-        InlinedStorage::AnnotateConstruct(size());
-        return InlinedStorage::data();
-      } else {
-        return reinterpret_cast<StorageElement*>(
-            AllocatorTraits::allocate(alloc(), size()));
-      }
-    }
-
-    // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
-    container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
-    StorageElement* data_;
-  };
-
-  Storage storage_;
-};
-
-template <typename T, size_t N, typename A>
-constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
-
-template <typename T, size_t N, typename A>
-constexpr typename FixedArray<T, N, A>::size_type
-    FixedArray<T, N, A>::inline_elements;
-
-template <typename T, size_t N, typename A>
-void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
-    typename FixedArray<T, N, A>::size_type n) {
+  }; 
+ 
+  class EmptyInlinedStorage { 
+   public: 
+    StorageElement* data() { return nullptr; } 
+    void AnnotateConstruct(size_type) {} 
+    void AnnotateDestruct(size_type) {} 
+  }; 
+ 
+  using InlinedStorage = 
+      absl::conditional_t<inline_elements == 0, EmptyInlinedStorage, 
+                          NonEmptyInlinedStorage>; 
+ 
+  // Storage 
+  // 
+  // An instance of Storage manages the inline and out-of-line memory for 
+  // instances of FixedArray. This guarantees that even when construction of 
+  // individual elements fails in the FixedArray constructor body, the 
+  // destructor for Storage will still be called and out-of-line memory will be 
+  // properly deallocated. 
+  // 
+  class Storage : public InlinedStorage { 
+   public: 
+    Storage(size_type n, const allocator_type& a) 
+        : size_alloc_(n, a), data_(InitializeData()) {} 
+ 
+    ~Storage() noexcept { 
+      if (UsingInlinedStorage(size())) { 
+        InlinedStorage::AnnotateDestruct(size()); 
+      } else { 
+        AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size()); 
+      } 
+    } 
+ 
+    size_type size() const { return size_alloc_.template get<0>(); } 
+    StorageElement* begin() const { return data_; } 
+    StorageElement* end() const { return begin() + size(); } 
+    allocator_type& alloc() { return size_alloc_.template get<1>(); } 
+ 
+   private: 
+    static bool UsingInlinedStorage(size_type n) { 
+      return n <= inline_elements; 
+    } 
+ 
+    StorageElement* InitializeData() { 
+      if (UsingInlinedStorage(size())) { 
+        InlinedStorage::AnnotateConstruct(size()); 
+        return InlinedStorage::data(); 
+      } else { 
+        return reinterpret_cast<StorageElement*>( 
+            AllocatorTraits::allocate(alloc(), size())); 
+      } 
+    } 
+ 
+    // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s 
+    container_internal::CompressedTuple<size_type, allocator_type> size_alloc_; 
+    StorageElement* data_; 
+  }; 
+ 
+  Storage storage_; 
+}; 
+ 
+template <typename T, size_t N, typename A> 
+constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault; 
+ 
+template <typename T, size_t N, typename A> 
+constexpr typename FixedArray<T, N, A>::size_type 
+    FixedArray<T, N, A>::inline_elements; 
+ 
+template <typename T, size_t N, typename A> 
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct( 
+    typename FixedArray<T, N, A>::size_type n) { 
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  if (!n) return;
+  if (!n) return; 
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
                                      data() + n);
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
                                      RedzoneBegin());
 #endif  // ABSL_HAVE_ADDRESS_SANITIZER
-  static_cast<void>(n);  // Mark used when not in asan mode
-}
-
-template <typename T, size_t N, typename A>
-void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
-    typename FixedArray<T, N, A>::size_type n) {
+  static_cast<void>(n);  // Mark used when not in asan mode 
+} 
+ 
+template <typename T, size_t N, typename A> 
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct( 
+    typename FixedArray<T, N, A>::size_type n) { 
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  if (!n) return;
+  if (!n) return; 
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
                                      RedzoneEnd());
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
                                      data());
 #endif  // ABSL_HAVE_ADDRESS_SANITIZER
-  static_cast<void>(n);  // Mark used when not in asan mode
-}
+  static_cast<void>(n);  // Mark used when not in asan mode 
+} 
 ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_FIXED_ARRAY_H_
+}  // namespace absl 
+ 
+#endif  // ABSL_CONTAINER_FIXED_ARRAY_H_