diff --git a/c10/benchmark/intrusive_ptr_benchmark.cpp b/c10/benchmark/intrusive_ptr_benchmark.cpp
index 4336c4e1094..75237ecdedd 100644
--- a/c10/benchmark/intrusive_ptr_benchmark.cpp
+++ b/c10/benchmark/intrusive_ptr_benchmark.cpp
@@ -18,7 +18,6 @@ class Foo : public intrusive_ptr_target {
   int param;
 };
 
-
 class Bar : public std::enable_shared_from_this<Bar> {
  public:
   Bar(int param_) : param(param_) {}
@@ -48,7 +47,7 @@ BENCHMARK(BM_SharedPtrCtorDtor);
 static void BM_IntrusivePtrArray(benchmark::State& state) {
   intrusive_ptr<Foo> var = make_intrusive<Foo>(0);
   const size_t kLength = state.range(0);
-  std::vector<intrusive_ptr<Foo> > vararray(kLength);
+  std::vector<intrusive_ptr<Foo>> vararray(kLength);
   while (state.KeepRunning()) {
     for (const auto i : c10::irange(kLength)) {
       vararray[i] = var;
@@ -64,7 +63,7 @@ BENCHMARK(BM_IntrusivePtrArray)->RangeMultiplier(2)->Range(16, 4096);
 static void BM_SharedPtrArray(benchmark::State& state) {
   std::shared_ptr<Bar> var = std::make_shared<Bar>(0);
   const size_t kLength = state.range(0);
-  std::vector<std::shared_ptr<Bar> > vararray(kLength);
+  std::vector<std::shared_ptr<Bar>> vararray(kLength);
   while (state.KeepRunning()) {
     for (const auto i : c10::irange(kLength)) {
       vararray[i] = var;
@@ -78,5 +77,4 @@ static void BM_SharedPtrArray(benchmark::State& state) {
 BENCHMARK(BM_SharedPtrArray)->RangeMultiplier(2)->Range(16, 4096);
 } // namespace
 
-
 BENCHMARK_MAIN();
diff --git a/c10/core/Allocator.cpp b/c10/core/Allocator.cpp
index 406fa1a0cc8..8ee23dc7374 100644
--- a/c10/core/Allocator.cpp
+++ b/c10/core/Allocator.cpp
@@ -12,10 +12,11 @@ at::DataPtr InefficientStdFunctionContext::makeDataPtr(
     void* ptr,
     const std::function<void(void*)>& deleter,
     Device device) {
-  return {ptr,
-          new InefficientStdFunctionContext({ptr, deleter}),
-          &deleteInefficientStdFunctionContext,
-          device};
+  return {
+      ptr,
+      new InefficientStdFunctionContext({ptr, deleter}),
+      &deleteInefficientStdFunctionContext,
+      device};
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
diff --git a/c10/core/Allocator.h b/c10/core/Allocator.h
index 1554f8dbd6a..338c70980fa 100644
--- a/c10/core/Allocator.h
+++ b/c10/core/Allocator.h
@@ -94,7 +94,9 @@ class C10_API DataPtr {
    * be; be sure to read the source code of the Allocator
    * in question to confirm this.
    */
-  C10_NODISCARD bool compare_exchange_deleter(DeleterFnPtr expected_deleter, DeleterFnPtr new_deleter) {
+  C10_NODISCARD bool compare_exchange_deleter(
+      DeleterFnPtr expected_deleter,
+      DeleterFnPtr new_deleter) {
     return ptr_.compare_exchange_deleter(expected_deleter, new_deleter);
   }
   Device device() const {
@@ -215,8 +217,8 @@ struct AllocatorRegisterer {
   }
 };
 
-#define REGISTER_ALLOCATOR(t, f)                    \
-  namespace {                                       \
+#define REGISTER_ALLOCATOR(t, f)                  \
+  namespace {                                     \
   static AllocatorRegisterer<t> g_allocator_d(f); \
   }
 
@@ -227,12 +229,18 @@ struct C10_API MemoryReportingInfoBase : public c10::DebugInfoBase {
   virtual ~MemoryReportingInfoBase() {}
 
   // Negative alloc_size corresponds to freeing of the memory
-  virtual void reportMemoryUsage(void* ptr, int64_t alloc_size, Device device) = 0;
+  virtual void reportMemoryUsage(
+      void* ptr,
+      int64_t alloc_size,
+      Device device) = 0;
 
   virtual bool memoryProfilingEnabled() const = 0;
 };
 
 C10_API bool memoryProfilingEnabled();
-C10_API void reportMemoryUsageToProfiler(void* ptr, int64_t alloc_size, Device device);
+C10_API void reportMemoryUsageToProfiler(
+    void* ptr,
+    int64_t alloc_size,
+    Device device);
 
 } // namespace c10
diff --git a/c10/core/Backend.h b/c10/core/Backend.h
index d4228200d1e..4f8274123b7 100644
--- a/c10/core/Backend.h
+++ b/c10/core/Backend.h
@@ -253,7 +253,7 @@ static inline bool isSparse(Backend b) {
 }
 
 static inline bool isSparseCsr(Backend b) {
-  switch(b) {
+  switch (b) {
     case Backend::SparseCsrCPU:
     case Backend::SparseCsrCUDA:
       return true;
diff --git a/c10/core/CompileTimeFunctionPointer.h b/c10/core/CompileTimeFunctionPointer.h
index d9424329469..6314e3e7708 100644
--- a/c10/core/CompileTimeFunctionPointer.h
+++ b/c10/core/CompileTimeFunctionPointer.h
@@ -29,9 +29,11 @@ namespace c10 {
  *  }
  *  EXPECT_EQ(3, execute(TORCH_FN(add), 1, 2));
  */
-template<class FuncType_, FuncType_* func_ptr_>
+template <class FuncType_, FuncType_* func_ptr_>
 struct CompileTimeFunctionPointer final {
-  static_assert(guts::is_function_type<FuncType_>::value, "TORCH_FN can only wrap function types.");
+  static_assert(
+      guts::is_function_type<FuncType_>::value,
+      "TORCH_FN can only wrap function types.");
   using FuncType = FuncType_;
 
   static constexpr FuncType* func_ptr() {
@@ -39,11 +41,16 @@ struct CompileTimeFunctionPointer final {
   }
 };
 
-template<class T> struct is_compile_time_function_pointer : std::false_type {};
-template<class FuncType, FuncType* func_ptr>
-struct is_compile_time_function_pointer<CompileTimeFunctionPointer<FuncType, func_ptr>> : std::true_type {};
+template <class T>
+struct is_compile_time_function_pointer : std::false_type {};
+template <class FuncType, FuncType* func_ptr>
+struct is_compile_time_function_pointer<
+    CompileTimeFunctionPointer<FuncType, func_ptr>> : std::true_type {};
 
-}
+} // namespace c10
 
-#define TORCH_FN_TYPE(func) ::c10::CompileTimeFunctionPointer<std::remove_pointer_t<std::remove_reference_t<decltype(func)>>, func>
+#define TORCH_FN_TYPE(func)                                           \
+  ::c10::CompileTimeFunctionPointer<                                  \
+      std::remove_pointer_t<std::remove_reference_t<decltype(func)>>, \
+      func>
 #define TORCH_FN(func) TORCH_FN_TYPE(func)()
diff --git a/c10/core/CopyBytes.cpp b/c10/core/CopyBytes.cpp
index 520391c6852..b652c35f4ca 100644
--- a/c10/core/CopyBytes.cpp
+++ b/c10/core/CopyBytes.cpp
@@ -47,4 +47,4 @@ void CopyBytes(
   ptr(nbytes, src, src_device, dst, dst_device);
 }
 
-}
+} // namespace c10
diff --git a/c10/core/DefaultDtype.cpp b/c10/core/DefaultDtype.cpp
index 3cfbf80e82f..ad76a551250 100644
--- a/c10/core/DefaultDtype.cpp
+++ b/c10/core/DefaultDtype.cpp
@@ -1,5 +1,5 @@
-#include <c10/util/typeid.h>
 #include <c10/core/DefaultDtype.h>
+#include <c10/util/typeid.h>
 
 namespace c10 {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -7,7 +7,8 @@ static auto default_dtype = caffe2::TypeMeta::Make<float>();
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto default_dtype_as_scalartype = default_dtype.toScalarType();
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static auto default_complex_dtype = caffe2::TypeMeta::Make<c10::complex<float>>();
+static auto default_complex_dtype =
+    caffe2::TypeMeta::Make<c10::complex<float>>();
 
 void set_default_dtype(caffe2::TypeMeta dtype) {
   default_dtype = dtype;
diff --git a/c10/core/DefaultDtype.h b/c10/core/DefaultDtype.h
index d0a17474bda..f2f95c0da15 100644
--- a/c10/core/DefaultDtype.h
+++ b/c10/core/DefaultDtype.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <c10/macros/Macros.h>
 #include <c10/core/ScalarType.h>
+#include <c10/macros/Macros.h>
 
 namespace caffe2 {
 class TypeMeta;
diff --git a/c10/core/DefaultTensorOptions.h b/c10/core/DefaultTensorOptions.h
index 7bf96525c11..36af2657847 100644
--- a/c10/core/DefaultTensorOptions.h
+++ b/c10/core/DefaultTensorOptions.h
@@ -13,19 +13,27 @@ struct TensorOptions;
 struct DefaultTensorOptions {
   DefaultTensorOptions() = default;
 
-  caffe2::TypeMeta dtype() const noexcept { return dtype_; }
-  Device device()          const noexcept { return device_; }
-  Layout layout()          const noexcept { return layout_; }
-  bool requires_grad()     const noexcept { return requires_grad_; }
+  caffe2::TypeMeta dtype() const noexcept {
+    return dtype_;
+  }
+  Device device() const noexcept {
+    return device_;
+  }
+  Layout layout() const noexcept {
+    return layout_;
+  }
+  bool requires_grad() const noexcept {
+    return requires_grad_;
+  }
 
   // Defined in TensorOptions.h
   inline DefaultTensorOptions& merge(const TensorOptions& options);
 
  private:
   caffe2::TypeMeta dtype_ = caffe2::TypeMeta::Make<float>(); // 64-bit
-  Device device_          = at::kCPU;                        // 32-bit
-  Layout layout_          = at::kStrided;                    // 8-bit
-  bool requires_grad_     = false;                           // 8-bit
+  Device device_ = at::kCPU; // 32-bit
+  Layout layout_ = at::kStrided; // 8-bit
+  bool requires_grad_ = false; // 8-bit
 };
 
 inline const DefaultTensorOptions& getDefaultTensorOptions() {
diff --git a/c10/core/Device.cpp b/c10/core/Device.cpp
index 4ce305aee62..e537be23d32 100644
--- a/c10/core/Device.cpp
+++ b/c10/core/Device.cpp
@@ -6,25 +6,24 @@
 #include <array>
 #include <exception>
 #include <ostream>
+#include <regex>
 #include <string>
 #include <tuple>
 #include <vector>
-#include <regex>
 
 // Check if compiler has working std::regex implementation
 //
 // Test below is adapted from https://stackoverflow.com/a/41186162
 #if defined(_MSVC_LANG) && _MSVC_LANG >= 201103L
-  // Compiler has working regex. MSVC has erroneous __cplusplus.
+// Compiler has working regex. MSVC has erroneous __cplusplus.
 #elif __cplusplus >= 201103L &&                           \
     (!defined(__GLIBCXX__) || (__cplusplus >= 201402L) || \
-        (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) || \
-         defined(_GLIBCXX_REGEX_STATE_LIMIT)           || \
-             (defined(_GLIBCXX_RELEASE)                && \
-             _GLIBCXX_RELEASE > 4)))
-  // Compiler has working regex.
+     (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) ||    \
+      defined(_GLIBCXX_REGEX_STATE_LIMIT) ||              \
+      (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE > 4)))
+// Compiler has working regex.
 #else
-  static_assert(false, "Compiler does not have proper regex support.");
+static_assert(false, "Compiler does not have proper regex support.");
 #endif
 
 namespace c10 {
@@ -58,7 +57,8 @@ DeviceType parse_type(const std::string& device_string) {
   if (device != types.end()) {
     return device->second;
   }
-  TORCH_CHECK(false,
+  TORCH_CHECK(
+      false,
       "Expected one of cpu, cuda, xpu, mkldnn, opengl, opencl, ideep, hip, msnpu, mlc, xla, vulkan, meta device type at start of device string: ",
       device_string);
 }
@@ -71,16 +71,22 @@ Device::Device(const std::string& device_string) : Device(Type::CPU) {
   static const std::regex regex("([a-zA-Z_]+)(?::([1-9]\\d*|0))?");
   std::smatch match;
   TORCH_CHECK(
-    std::regex_match(device_string, match, regex),
-    "Invalid device string: '", device_string, "'");
+      std::regex_match(device_string, match, regex),
+      "Invalid device string: '",
+      device_string,
+      "'");
   type_ = parse_type(match[1].str());
   if (match[2].matched) {
     try {
       index_ = c10::stoi(match[2].str());
-    } catch (const std::exception &) {
-      TORCH_CHECK(false,
-        "Could not parse device index '", match[2].str(),
-        "' in device string '", device_string, "'");
+    } catch (const std::exception&) {
+      TORCH_CHECK(
+          false,
+          "Could not parse device index '",
+          match[2].str(),
+          "' in device string '",
+          device_string,
+          "'");
     }
   }
   validate();
diff --git a/c10/core/Device.h b/c10/core/Device.h
index 3ce6cd0ef88..3f904b389e4 100644
--- a/c10/core/Device.h
+++ b/c10/core/Device.h
@@ -107,16 +107,18 @@ struct C10_API Device final {
     // performance in micro-benchmarks.
     // This is safe to do, because backends that use the DeviceIndex
     // have a later check when we actually try to switch to that device.
-    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(index_ == -1 || index_ >= 0,
-        "Device index must be -1 or non-negative, got ", (int)index_);
-    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(!is_cpu() || index_ <= 0,
-        "CPU device index must be -1 or zero, got ", (int)index_);
+    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+        index_ == -1 || index_ >= 0,
+        "Device index must be -1 or non-negative, got ",
+        (int)index_);
+    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+        !is_cpu() || index_ <= 0,
+        "CPU device index must be -1 or zero, got ",
+        (int)index_);
   }
 };
 
-C10_API std::ostream& operator<<(
-    std::ostream& stream,
-    const Device& device);
+C10_API std::ostream& operator<<(std::ostream& stream, const Device& device);
 
 } // namespace c10
 
@@ -136,10 +138,11 @@ struct hash<c10::Device> {
     // half of the resulting integer.
     //
     // Technically, by C/C++ integer promotion rules, we only need one of the
-    // uint32_t casts to the result type, but we put in both for explicitness's sake.
-    uint32_t bits =
-        static_cast<uint32_t>(static_cast<uint8_t>(d.type())) << 16
-      | static_cast<uint32_t>(static_cast<uint8_t>(d.index()));
+    // uint32_t casts to the result type, but we put in both for explicitness's
+    // sake.
+    uint32_t bits = static_cast<uint32_t>(static_cast<uint8_t>(d.type()))
+            << 16 |
+        static_cast<uint32_t>(static_cast<uint8_t>(d.index()));
     return std::hash<uint32_t>{}(bits);
   }
 };
diff --git a/c10/core/DeviceGuard.h b/c10/core/DeviceGuard.h
index 852d6366ebd..ed627f03171 100644
--- a/c10/core/DeviceGuard.h
+++ b/c10/core/DeviceGuard.h
@@ -17,7 +17,7 @@ namespace c10 {
 /// want to setup a guard (i.e., are looking for the moral equivalent
 /// of optional<DeviceGuard>), see OptionalDeviceGuard.
 class DeviceGuard {
-public:
+ public:
   /// No default constructor; see Note [Omitted default constructor from RAII]
   explicit DeviceGuard() = delete;
 
@@ -25,7 +25,10 @@ public:
   explicit DeviceGuard(Device device) : guard_(device) {}
 
   /// This constructor is for testing only.
-  explicit DeviceGuard(Device device, const impl::DeviceGuardImplInterface* impl) : guard_(device, impl) {}
+  explicit DeviceGuard(
+      Device device,
+      const impl::DeviceGuardImplInterface* impl)
+      : guard_(device, impl) {}
 
   /// Copy is disallowed
   DeviceGuard(const DeviceGuard&) = delete;
@@ -48,7 +51,9 @@ public:
   }
 
   /// This method is for testing only.
-  void reset_device(at::Device device, const impl::DeviceGuardImplInterface* impl) {
+  void reset_device(
+      at::Device device,
+      const impl::DeviceGuardImplInterface* impl) {
     guard_.reset_device(device, impl);
   }
 
@@ -69,7 +74,7 @@ public:
     return guard_.current_device();
   }
 
-private:
+ private:
   impl::InlineDeviceGuard<impl::VirtualGuardImpl> guard_;
 };
 
@@ -79,8 +84,8 @@ private:
  * Morally, a OptionalDeviceGuard is equivalent to optional<DeviceGuard>, but
  * with extra constructors and methods as appropriate.
  *
- * Besides its obvious use (optionally applying a DeviceGuard), OptionalDeviceGuard
- * is often also used for the following idiom:
+ * Besides its obvious use (optionally applying a DeviceGuard),
+ * OptionalDeviceGuard is often also used for the following idiom:
  *
  *    OptionalDeviceGuard g;
  *    for (const auto& t : tensors) {
@@ -117,7 +122,7 @@ private:
  * DeviceGuard will still reset the device to original_device_.
  */
 class OptionalDeviceGuard {
-public:
+ public:
   /// Create an uninitialized guard.  Set the guard later using reset_device.
   explicit OptionalDeviceGuard() : guard_() {}
 
@@ -129,7 +134,10 @@ public:
   explicit OptionalDeviceGuard(optional<Device> device) : guard_(device) {}
 
   /// Constructor for testing only.
-  explicit OptionalDeviceGuard(Device device, const impl::DeviceGuardImplInterface* impl) : guard_(device, impl) {}
+  explicit OptionalDeviceGuard(
+      Device device,
+      const impl::DeviceGuardImplInterface* impl)
+      : guard_(device, impl) {}
 
   /// Copy is disallowed
   OptionalDeviceGuard(const OptionalDeviceGuard&) = delete;
@@ -149,7 +157,9 @@ public:
   }
 
   /// For testing only
-  void reset_device(at::Device device, const impl::DeviceGuardImplInterface* impl) {
+  void reset_device(
+      at::Device device,
+      const impl::DeviceGuardImplInterface* impl) {
     guard_.reset_device(device, impl);
   }
 
@@ -164,7 +174,7 @@ public:
     return guard_.current_device();
   }
 
-private:
+ private:
   impl::InlineOptionalDeviceGuard<impl::VirtualGuardImpl> guard_;
 };
 
@@ -173,7 +183,8 @@ private:
 // Design note: in principle, we could avoid these wrappers using:
 //
 // using DeviceGuard = impl::InlineDeviceGuard<impl::VirtualGuardImpl>;
-// using OptionalDeviceGuard = impl::InlineOptionalDeviceGuard<impl::VirtualGuardImpl>;
+// using OptionalDeviceGuard =
+// impl::InlineOptionalDeviceGuard<impl::VirtualGuardImpl>;
 //
 // But the error messages are worse, and our users can't just look at the
 // header file to find out what's going on.  Furthermore, for specializations
diff --git a/c10/core/DeviceType.cpp b/c10/core/DeviceType.cpp
index 3cdb53e9928..6a38cdb87d9 100644
--- a/c10/core/DeviceType.cpp
+++ b/c10/core/DeviceType.cpp
@@ -38,7 +38,8 @@ std::string DeviceTypeName(DeviceType d, bool lower_case) {
     case DeviceType::Meta:
       return lower_case ? "meta" : "META";
     default:
-      TORCH_CHECK(false,
+      TORCH_CHECK(
+          false,
           "Unknown device: ",
           static_cast<int16_t>(d),
           ". If you have recently updated the caffe2.proto file to add a new "
diff --git a/c10/core/DeviceType.h b/c10/core/DeviceType.h
index 8ba366abda4..df80aff6c99 100644
--- a/c10/core/DeviceType.h
+++ b/c10/core/DeviceType.h
@@ -7,8 +7,8 @@
 
 #include <c10/macros/Macros.h>
 
-#include <ostream>
 #include <functional>
+#include <ostream>
 
 namespace c10 {
 
@@ -51,7 +51,8 @@ constexpr DeviceType kXPU = DeviceType::XPU;
 constexpr int COMPILE_TIME_MAX_DEVICE_TYPES =
     static_cast<int>(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES);
 
-static_assert(COMPILE_TIME_MAX_DEVICE_TYPES <= 16,
+static_assert(
+    COMPILE_TIME_MAX_DEVICE_TYPES <= 16,
     "Hey!  You seem to be adding a lot of new DeviceTypes.  The intent was "
     "for this constant to reflect the actual number of DeviceTypes we support "
     "in PyTorch; it's important that this number is not too large as we "
@@ -61,9 +62,7 @@ static_assert(COMPILE_TIME_MAX_DEVICE_TYPES <= 16,
     "types registration, please be aware that you are affecting code that "
     "this number is small.  Try auditing uses of this constant.");
 
-C10_API std::string DeviceTypeName(
-    DeviceType d,
-    bool lower_case = false);
+C10_API std::string DeviceTypeName(DeviceType d, bool lower_case = false);
 
 C10_API bool isValidDeviceType(DeviceType d);
 
@@ -72,7 +71,8 @@ C10_API std::ostream& operator<<(std::ostream& stream, DeviceType type);
 } // namespace c10
 
 namespace std {
-template <> struct hash<c10::DeviceType> {
+template <>
+struct hash<c10::DeviceType> {
   std::size_t operator()(c10::DeviceType k) const {
     return std::hash<int>()(static_cast<int>(k));
   }
@@ -80,5 +80,5 @@ template <> struct hash<c10::DeviceType> {
 } // namespace std
 
 namespace torch {
-  using c10::DeviceType;
+using c10::DeviceType;
 }
diff --git a/c10/core/DispatchKey.h b/c10/core/DispatchKey.h
index 75b4c36d40b..a82edf1e26e 100644
--- a/c10/core/DispatchKey.h
+++ b/c10/core/DispatchKey.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <vector>
-#include <iostream>
-#include <string>
 #include <c10/macros/Macros.h>
 #include <c10/util/ArrayRef.h>
 #include <c10/util/Exception.h>
+#include <iostream>
+#include <string>
+#include <vector>
 
 namespace c10 {
 
@@ -58,7 +58,7 @@ enum class DispatchKey : uint8_t {
   HIP, // NB: I think this is not actually used, due to Note [Masquerading as
   // CUDA]
   FPGA, // Xilinx support lives out of tree at
-        // https://gitlab.com/pytorch-complex/vitis_kernels
+  // https://gitlab.com/pytorch-complex/vitis_kernels
   MSNPU, // unused externally, but tested at
   // test/cpp_extensions/msnpu_extension.cpp
   XLA, // lives out of tree at https://github.com/pytorch/xla
@@ -177,7 +177,8 @@ enum class DispatchKey : uint8_t {
   // But this work is currently blocked since it adds an extra dispatch
   // for all ops and it's non-trivial overhead at model level(a few percents).
   // Thus our current approach takes advantage of the fact every kernel go
-  // through VariableType kernel first and pulls the `at::AutoDispatchBelowInplaceOrView` guard of functional ops
+  // through VariableType kernel first and pulls the
+  // `at::AutoDispatchBelowInplaceOrView` guard of functional ops
   // up to the `VariableType` kernel. Thus we only add the extra dispatch
   // to view/inplace ops to minimize its perf impact to real models.
   InplaceOrView,
@@ -213,7 +214,8 @@ enum class DispatchKey : uint8_t {
   AutogradXLA,
   AutogradXPU,
   AutogradMLC,
-  AutogradNestedTensor, // lives out of tree at https://github.com/pytorch/nestedtensor
+  AutogradNestedTensor, // lives out of tree at
+  // https://github.com/pytorch/nestedtensor
   // Here are some reserved pre-autograd keys for user-defined backends, see
   // Note [Private use DispatchKey]
   AutogradPrivateUse1,
@@ -224,7 +226,7 @@ enum class DispatchKey : uint8_t {
 
   // Autocasting precedes VariableTypeId, to ensure casts are autograd-exposed
   // and inputs are saved for backward in the post-autocast type.
-  //AutocastCPU,
+  // AutocastCPU,
   AutocastCUDA,
 
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ WRAPPERS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
@@ -278,9 +280,10 @@ enum class DispatchKey : uint8_t {
 
   // See Note [Alias Dispatch Key : Autograd]
   Autograd,
-  CompositeImplicitAutograd, // registered at build/aten/src/ATen/RegisterCompositeImplicitAutograd.cpp
+  CompositeImplicitAutograd, // registered at
+  // build/aten/src/ATen/RegisterCompositeImplicitAutograd.cpp
   CompositeExplicitAutograd, // registered at
-                  // build/aten/src/ATen/RegisterCompositeExplicitAutograd.cpp
+  // build/aten/src/ATen/RegisterCompositeExplicitAutograd.cpp
 
   // Define an alias key to represent end of alias dispatch keys.
   // If you add new alias keys after Autograd, please also update it here.
@@ -316,15 +319,15 @@ enum class DispatchKey : uint8_t {
 // We provide two classes of private user tensor id: regular DispatchKeys
 // and Autograd DispatchKeys.  DispatchKeys serve the role of ordinary "backend"
 // DispatchKeys; if you were adding support for a new type of accelerator, you
-// would use a backend DispatchKey, and ideally automatically reuse AutogradOther
-// definitions already defined in PyTorch.  AutogradPrivateUse DispatchKeys serve
-// as "wrapper" DispatchKeys: they are only necessary for tensors that compose
-// multiple internal tensors, and for cases when the built-in autograd formulas
-// for operators are not appropriate.
+// would use a backend DispatchKey, and ideally automatically reuse
+// AutogradOther definitions already defined in PyTorch.  AutogradPrivateUse
+// DispatchKeys serve as "wrapper" DispatchKeys: they are only necessary for
+// tensors that compose multiple internal tensors, and for cases when the
+// built-in autograd formulas for operators are not appropriate.
 
 static_assert(
-  static_cast<uint8_t>(DispatchKey::NumDispatchKeys) < 64,
-  "DispatchKey is used as index into 64-bit bitmask; you must have less than 64 entries");
+    static_cast<uint8_t>(DispatchKey::NumDispatchKeys) < 64,
+    "DispatchKey is used as index into 64-bit bitmask; you must have less than 64 entries");
 
 C10_API const char* toString(DispatchKey);
 C10_API std::ostream& operator<<(std::ostream&, DispatchKey);
@@ -345,10 +348,10 @@ inline bool isAliasDispatchKey(DispatchKey k) {
 } // namespace c10
 
 namespace torch {
-  // Expose the constant, but not the TYPE (DispatchKey is an implementation
-  // detail!)
-  using c10::kAutograd;
-}
+// Expose the constant, but not the TYPE (DispatchKey is an implementation
+// detail!)
+using c10::kAutograd;
+} // namespace torch
 
 // NB: You really shouldn't use this instance; this enum is guaranteed
 // to be pretty small so a regular array should be acceptable.
@@ -362,4 +365,4 @@ struct hash<c10::DispatchKey> {
     return static_cast<size_t>(x);
   }
 };
-}
+} // namespace std
diff --git a/c10/core/DispatchKeySet.cpp b/c10/core/DispatchKeySet.cpp
index 0ea9c1cfdd0..0799ebaf5a6 100644
--- a/c10/core/DispatchKeySet.cpp
+++ b/c10/core/DispatchKeySet.cpp
@@ -3,9 +3,10 @@
 namespace c10 {
 
 // backend_dispatch_keyset should include all runtime backend keys.
-// Alias key DispatchKey::CompositeExplicitAutograd maps to backend_dispatch_keyset
-// NestedTensor has been explicitly removed due to incompatibility with some
-// kernels, such as structured kernels, that use the DefaultBackend key.
+// Alias key DispatchKey::CompositeExplicitAutograd maps to
+// backend_dispatch_keyset NestedTensor has been explicitly removed due to
+// incompatibility with some kernels, such as structured kernels, that use the
+// DefaultBackend key.
 constexpr DispatchKeySet backend_dispatch_keyset = autogradother_backends |
     DispatchKeySet({
         DispatchKey::CPU,
@@ -23,9 +24,11 @@ bool isBackendDispatchKey(DispatchKey t) {
   return t != DispatchKey::Undefined && backend_dispatch_keyset.has(t);
 }
 
-// math_dispatch_keyset contains all keys in backend_dispatch_keyset and autograd_dispatch_keyset
-// Alias key DispatchKey::CompositeImplicitAutograd maps to math_dispatch_keyset.
-constexpr DispatchKeySet math_dispatch_keyset = backend_dispatch_keyset | autograd_dispatch_keyset;
+// math_dispatch_keyset contains all keys in backend_dispatch_keyset and
+// autograd_dispatch_keyset Alias key DispatchKey::CompositeImplicitAutograd
+// maps to math_dispatch_keyset.
+constexpr DispatchKeySet math_dispatch_keyset =
+    backend_dispatch_keyset | autograd_dispatch_keyset;
 
 DispatchKeySet getRuntimeDispatchKeySet(DispatchKey t) {
   TORCH_INTERNAL_ASSERT(t != DispatchKey::Undefined);
@@ -41,8 +44,8 @@ DispatchKeySet getRuntimeDispatchKeySet(DispatchKey t) {
   }
 }
 
-// for a given autograd key, return the (guaranteed nonempty) set of associated backend keys.
-// for a non-autograd key, return the empty keyset.
+// for a given autograd key, return the (guaranteed nonempty) set of associated
+// backend keys. for a non-autograd key, return the empty keyset.
 DispatchKeySet getBackendKeySetFromAutograd(DispatchKey t) {
   switch (t) {
     case DispatchKey::AutogradCPU:
@@ -72,7 +75,7 @@ DispatchKeySet getBackendKeySetFromAutograd(DispatchKey t) {
 
 DispatchKeySet getAutocastRelatedKeySetFromBackend(DispatchKey t) {
   switch (t) {
-    //case DispatchKey::CPU:
+    // case DispatchKey::CPU:
     //  return DispatchKeySet(DispatchKey::AutocastCPU);
     case DispatchKey::CUDA:
       return DispatchKeySet(DispatchKey::AutocastCUDA);
@@ -82,8 +85,8 @@ DispatchKeySet getAutocastRelatedKeySetFromBackend(DispatchKey t) {
 }
 
 DispatchKeySet getAutogradRelatedKeySetFromBackend(DispatchKey t) {
-  return DispatchKeySet({
-    DispatchKey::InplaceOrView, getAutogradKeyFromBackend(t)});
+  return DispatchKeySet(
+      {DispatchKey::InplaceOrView, getAutogradKeyFromBackend(t)});
 }
 
 bool isIncludedInAlias(DispatchKey k, DispatchKey alias) {
@@ -116,4 +119,4 @@ std::ostream& operator<<(std::ostream& os, DispatchKeySet ts) {
   return os;
 }
 
-}
+} // namespace c10
diff --git a/c10/core/DispatchKeySet.h b/c10/core/DispatchKeySet.h
index ec80e5d61e2..e78ce18aa76 100644
--- a/c10/core/DispatchKeySet.h
+++ b/c10/core/DispatchKeySet.h
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <c10/core/DispatchKey.h>
-#include <c10/util/llvmMathExtras.h>
 #include <c10/util/Exception.h>
 #include <c10/util/Metaprogramming.h>
+#include <c10/util/llvmMathExtras.h>
 #include <ostream>
 
 namespace c10 {
@@ -33,30 +33,29 @@ namespace c10 {
 //
 // An undefined tensor is one with an empty tensor type set.
 class DispatchKeySet final {
-public:
+ public:
   enum Full { FULL };
   enum FullAfter { FULL_AFTER };
   enum Raw { RAW };
 
   // NB: default constructor representation as zero is MANDATORY as
   // use of DispatchKeySet in TLS requires this.
-  constexpr DispatchKeySet()
-    : repr_(0) {}
+  constexpr DispatchKeySet() : repr_(0) {}
   constexpr DispatchKeySet(Full)
-    : repr_(std::numeric_limits<decltype(repr_)>::max()) {}
+      : repr_(std::numeric_limits<decltype(repr_)>::max()) {}
   constexpr DispatchKeySet(FullAfter, DispatchKey t)
-    // LSB after t are OK, but not t itself.
-    : repr_((1ULL << (static_cast<uint8_t>(t) - 1)) - 1) {}
+      // LSB after t are OK, but not t itself.
+      : repr_((1ULL << (static_cast<uint8_t>(t) - 1)) - 1) {}
   // Public version of DispatchKeySet(uint64_t) API; external users
   // must be explicit when they do this!
-  constexpr DispatchKeySet(Raw, uint64_t x)
-    : repr_(x) {}
+  constexpr DispatchKeySet(Raw, uint64_t x) : repr_(x) {}
   explicit constexpr DispatchKeySet(DispatchKey t)
-    : repr_(t == DispatchKey::Undefined
-              ? 0
-              : 1ULL << (static_cast<uint8_t>(t) - 1)) {}
+      : repr_(
+            t == DispatchKey::Undefined
+                ? 0
+                : 1ULL << (static_cast<uint8_t>(t) - 1)) {}
   explicit constexpr DispatchKeySet(std::initializer_list<DispatchKey> ks)
-  : repr_(0) {
+      : repr_(0) {
     for (auto k : ks) {
       repr_ |= DispatchKeySet(k).repr_;
     }
@@ -105,7 +104,9 @@ public:
   bool empty() const {
     return repr_ == 0;
   }
-  uint64_t raw_repr() { return repr_; }
+  uint64_t raw_repr() {
+    return repr_;
+  }
   // Return the type id in this set with the highest priority (i.e.,
   // is the largest in the DispatchKey enum).  Intuitively, this
   // type id is the one that should handle dispatch (assuming there
@@ -119,18 +120,20 @@ public:
   }
 
   DispatchKey highestPriorityBackendTypeId() const {
-    return (*this & ((1ULL << static_cast<uint8_t>(DispatchKey::EndOfBackendKeys)) - 1))
-      .highestPriorityTypeId();
+    return (*this &
+            ((1ULL << static_cast<uint8_t>(DispatchKey::EndOfBackendKeys)) - 1))
+        .highestPriorityTypeId();
   }
-private:
+
+ private:
   constexpr DispatchKeySet(uint64_t repr) : repr_(repr) {}
   uint64_t repr_ = 0;
 
-public:
+ public:
   // STL iterator for DispatchKeySet. Iterates through all DispatchKeys in the
   // set. The iterator is only invalidated by the destruction of the underlying
-  // DispatchKeySet as the iterator stores a pointer to the raw representation of
-  // the DispatchKeySet.
+  // DispatchKeySet as the iterator stores a pointer to the raw representation
+  // of the DispatchKeySet.
   class iterator {
    public:
     using self_type = iterator;
@@ -138,13 +141,15 @@ public:
     using value_type = DispatchKey;
     using difference_type = ptrdiff_t;
 
-    explicit iterator(const uint64_t *data_ptr, uint8_t i=0) : data_ptr_(data_ptr), i_(i) {
+    explicit iterator(const uint64_t* data_ptr, uint8_t i = 0)
+        : data_ptr_(data_ptr), i_(i) {
       // Go to the first key in the set
       ++(*this);
     }
 
     self_type& operator++() {
-      TORCH_INTERNAL_ASSERT(i_ <= static_cast<uint8_t>(DispatchKey::NumDispatchKeys));
+      TORCH_INTERNAL_ASSERT(
+          i_ <= static_cast<uint8_t>(DispatchKey::NumDispatchKeys));
 
       // Create a masked version of the set representation to ignore previous
       // keys that we've iterated through.
@@ -153,7 +158,7 @@ public:
 
       // If there are no keys, set to end iterator value
       if (firstKeyIndex == std::numeric_limits<uint64_t>::max() ||
-         i_ == static_cast<uint8_t>(DispatchKey::NumDispatchKeys)) {
+          i_ == static_cast<uint8_t>(DispatchKey::NumDispatchKeys)) {
         i_ = static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
         return *this;
       }
@@ -163,29 +168,38 @@ public:
     }
 
     self_type operator++(int) {
-      self_type previous_iterator =  *this;
+      self_type previous_iterator = *this;
       ++(*this);
       return previous_iterator;
     }
 
-    bool operator==(const self_type& rhs) const { return i_ == rhs.i_; }
-    bool operator!=(const self_type& rhs) const { return i_ != rhs.i_; }
-    DispatchKey operator*() const { return static_cast<DispatchKey> (i_); }
+    bool operator==(const self_type& rhs) const {
+      return i_ == rhs.i_;
+    }
+    bool operator!=(const self_type& rhs) const {
+      return i_ != rhs.i_;
+    }
+    DispatchKey operator*() const {
+      return static_cast<DispatchKey>(i_);
+    }
 
    private:
-    const uint64_t *data_ptr_;
+    const uint64_t* data_ptr_;
     uint8_t i_;
   };
 
  public:
   // Returns iterator to the first key in the set. If no keys are in the
   // set, then will return the end iterator.
-  iterator begin() const { return iterator(&repr_); }
+  iterator begin() const {
+    return iterator(&repr_);
+  }
 
   // We do not need to iterate beyond NumDispatchKeys so we will treat this as
   // the end iterator. NumDispatchKeys will always be strictly less than 64.
-  iterator end() const { return iterator(&repr_, static_cast<uint8_t>(DispatchKey::NumDispatchKeys)); }
-
+  iterator end() const {
+    return iterator(&repr_, static_cast<uint8_t>(DispatchKey::NumDispatchKeys));
+  }
 };
 
 C10_API std::string toString(DispatchKeySet);
@@ -208,7 +222,7 @@ constexpr DispatchKeySet autograd_dispatch_keyset = DispatchKeySet({
 });
 
 constexpr DispatchKeySet autocast_dispatch_keyset = DispatchKeySet({
-    //DispatchKey::AutocastCPU,
+    // DispatchKey::AutocastCPU,
     DispatchKey::AutocastCUDA,
 });
 
@@ -224,40 +238,36 @@ constexpr DispatchKeySet default_excluded_set = DispatchKeySet({
 });
 
 constexpr DispatchKeySet autograd_dispatch_keyset_with_InplaceOrView =
-  autograd_dispatch_keyset | DispatchKeySet(DispatchKey::InplaceOrView);
+    autograd_dispatch_keyset | DispatchKeySet(DispatchKey::InplaceOrView);
 
 // backend dispatch keys that map to DispatchKey::AutogradOther
 // NB: keys in this set also get associated with CompositeImplicitAutograd
-constexpr DispatchKeySet autogradother_backends = DispatchKeySet({
-  DispatchKey::HIP,
-  DispatchKey::FPGA,
-  DispatchKey::MSNPU,
-  DispatchKey::Vulkan,
-  DispatchKey::Metal,
-  DispatchKey::QuantizedCPU,
-  DispatchKey::QuantizedCUDA,
-  DispatchKey::CustomRNGKeyId,
-  DispatchKey::MkldnnCPU,
-  DispatchKey::SparseCPU,
-  DispatchKey::SparseCUDA,
-  DispatchKey::SparseHIP,
-  DispatchKey::SparseCsrCPU,
-  DispatchKey::SparseCsrCUDA,
-  DispatchKey::Meta
-});
+constexpr DispatchKeySet autogradother_backends = DispatchKeySet(
+    {DispatchKey::HIP,
+     DispatchKey::FPGA,
+     DispatchKey::MSNPU,
+     DispatchKey::Vulkan,
+     DispatchKey::Metal,
+     DispatchKey::QuantizedCPU,
+     DispatchKey::QuantizedCUDA,
+     DispatchKey::CustomRNGKeyId,
+     DispatchKey::MkldnnCPU,
+     DispatchKey::SparseCPU,
+     DispatchKey::SparseCUDA,
+     DispatchKey::SparseHIP,
+     DispatchKey::SparseCsrCPU,
+     DispatchKey::SparseCsrCUDA,
+     DispatchKey::Meta});
 
 // The set of dispatch keys that come after autograd
-// n.b. this relies on the fact that AutogradOther is currently the lowest Autograd key
-constexpr DispatchKeySet after_autograd_keyset = DispatchKeySet(
-        DispatchKeySet::FULL_AFTER,
-        c10::DispatchKey::AutogradOther
-);
+// n.b. this relies on the fact that AutogradOther is currently the lowest
+// Autograd key
+constexpr DispatchKeySet after_autograd_keyset =
+    DispatchKeySet(DispatchKeySet::FULL_AFTER, c10::DispatchKey::AutogradOther);
 
 // The set of dispatch keys that come after InplaceOrView
-constexpr DispatchKeySet after_InplaceOrView_keyset = DispatchKeySet(
-        DispatchKeySet::FULL_AFTER,
-        c10::DispatchKey::InplaceOrView
-);
+constexpr DispatchKeySet after_InplaceOrView_keyset =
+    DispatchKeySet(DispatchKeySet::FULL_AFTER, c10::DispatchKey::InplaceOrView);
 
 // true if t is a backend dispatch key
 C10_API bool isBackendDispatchKey(DispatchKey t);
@@ -265,8 +275,8 @@ C10_API bool isBackendDispatchKey(DispatchKey t);
 // Resolve alias dispatch key to DispatchKeySet if applicable
 C10_API DispatchKeySet getRuntimeDispatchKeySet(DispatchKey t);
 
-// Returns a DispatchKeySet of all backend keys mapped to Autograd dispatch key t,
-// DispatchKeySet is empty if t is not alias of DispatchKey::Autograd.
+// Returns a DispatchKeySet of all backend keys mapped to Autograd dispatch key
+// t, DispatchKeySet is empty if t is not alias of DispatchKey::Autograd.
 C10_API DispatchKeySet getBackendKeySetFromAutograd(DispatchKey t);
 
 // Returns a DispatchKeySet of autograd related keys mapped to backend.
@@ -291,27 +301,32 @@ static inline DispatchKey legacyExtractDispatchKey(DispatchKeySet s) {
   // top of existing "backend" keys like CPU/CUDA, you need to add it
   // here.  At the moment, autograd keys and InplaceOrView key need this
   // treatment;
-  return (s - autograd_dispatch_keyset_with_InplaceOrView - autocast_dispatch_keyset).highestPriorityTypeId();
+  return (s - autograd_dispatch_keyset_with_InplaceOrView -
+          autocast_dispatch_keyset)
+      .highestPriorityTypeId();
 }
 
-template<class T>
+template <class T>
 using is_not_DispatchKeySet = guts::negation<std::is_same<DispatchKeySet, T>>;
 
-// Given a function type, constructs a function_traits type that drops the first parameter
-// type if the first parameter is of type DispatchKeySet.
-// NB: DispatchKeySet is currently explicitly hidden from JIT (mainly to avoid pushing unnecessary
-// arguments on the stack - see Note [ Plumbing Keys Through the Dispatcher] for details).
-// If at any point in the future we need to expose this type to JIT, revisit the usage of this type alias.
+// Given a function type, constructs a function_traits type that drops the first
+// parameter type if the first parameter is of type DispatchKeySet. NB:
+// DispatchKeySet is currently explicitly hidden from JIT (mainly to avoid
+// pushing unnecessary arguments on the stack - see Note [ Plumbing Keys Through
+// the Dispatcher] for details). If at any point in the future we need to expose
+// this type to JIT, revisit the usage of this type alias.
 template <class FuncType>
 using remove_DispatchKeySet_arg_from_func = guts::make_function_traits_t<
-  typename guts::infer_function_traits_t<FuncType>::return_type,
-  typename std::conditional_t<
-    std::is_same<
-      DispatchKeySet,
-      typename guts::typelist::head_with_default_t<void, typename guts::infer_function_traits_t<FuncType>::parameter_types>
-    >::value,
-    guts::typelist::drop_if_nonempty_t<typename guts::infer_function_traits_t<FuncType>::parameter_types, 1>,
-    typename guts::infer_function_traits_t<FuncType>::parameter_types
-  >
->;
-}
+    typename guts::infer_function_traits_t<FuncType>::return_type,
+    typename std::conditional_t<
+        std::is_same<
+            DispatchKeySet,
+            typename guts::typelist::head_with_default_t<
+                void,
+                typename guts::infer_function_traits_t<
+                    FuncType>::parameter_types>>::value,
+        guts::typelist::drop_if_nonempty_t<
+            typename guts::infer_function_traits_t<FuncType>::parameter_types,
+            1>,
+        typename guts::infer_function_traits_t<FuncType>::parameter_types>>;
+} // namespace c10
diff --git a/c10/core/Event.h b/c10/core/Event.h
index 70d03f91bb5..eb10b8ab2ba 100644
--- a/c10/core/Event.h
+++ b/c10/core/Event.h
@@ -41,18 +41,18 @@ struct Event final {
   // Constructors
   Event() = delete;
   Event(
-    const DeviceType _device_type,
-    const EventFlag _flag = EventFlag::PYTORCH_DEFAULT)
-  : impl_{_device_type, _flag} { }
+      const DeviceType _device_type,
+      const EventFlag _flag = EventFlag::PYTORCH_DEFAULT)
+      : impl_{_device_type, _flag} {}
 
   // Copy constructor and copy assignment operator (deleted)
   Event(const Event&) = delete;
   Event& operator=(const Event&) = delete;
 
   // Move constructor and move assignment operator
-  Event(Event&& other) : impl_{std::move(other.impl_)} { }
+  Event(Event&& other) : impl_{std::move(other.impl_)} {}
   Event& operator=(Event&& other) {
-  impl_.swap(std::move(other.impl_));
+    impl_.swap(std::move(other.impl_));
     return *this;
   }
 
@@ -60,54 +60,62 @@ struct Event final {
   ~Event() = default;
 
   // Getters
-  DeviceType device_type() const noexcept { return impl_.device_type(); }
-  DeviceIndex device_index() const noexcept { return impl_.device_index(); }
-  EventFlag flag() const noexcept { return impl_.flag(); }
-  bool was_marked_for_recording() const noexcept { return impl_.was_marked_for_recording(); }
+  DeviceType device_type() const noexcept {
+    return impl_.device_type();
+  }
+  DeviceIndex device_index() const noexcept {
+    return impl_.device_index();
+  }
+  EventFlag flag() const noexcept {
+    return impl_.flag();
+  }
+  bool was_marked_for_recording() const noexcept {
+    return impl_.was_marked_for_recording();
+  }
 
-/**
- * Calls record() if and only if record() has never been called for this event.
- * Note: because Event is not thread-safe recordOnce() may call record()
- * multiple times if called from multiple threads.
- */
+  /**
+   * Calls record() if and only if record() has never been called for this
+   * event. Note: because Event is not thread-safe recordOnce() may call
+   * record() multiple times if called from multiple threads.
+   */
   void recordOnce(const Stream& stream) {
     impl_.recordOnce(stream);
   }
 
-/**
- * Increments the event's version and enqueues a job with this version
- * in the stream's work queue. When the stream process that job
- * it nofifies all streams waiting on / blocked by that version of the
- * event to continue and marks that version as recorded.
- * */
+  /**
+   * Increments the event's version and enqueues a job with this version
+   * in the stream's work queue. When the stream process that job
+   * it nofifies all streams waiting on / blocked by that version of the
+   * event to continue and marks that version as recorded.
+   * */
   void record(const Stream& stream) {
     impl_.record(stream);
   }
 
-/**
- * Does nothing if the event has not been scheduled to be recorded.
- * If the event was previously enqueued to be recorded, a command
- * to wait for the version of the event that exists at the time of this call
- * is inserted in the stream's work queue.
- * When the stream reaches this command it will stop processing
- * additional commands until that version of the event is marked as recorded.
- */
+  /**
+   * Does nothing if the event has not been scheduled to be recorded.
+   * If the event was previously enqueued to be recorded, a command
+   * to wait for the version of the event that exists at the time of this call
+   * is inserted in the stream's work queue.
+   * When the stream reaches this command it will stop processing
+   * additional commands until that version of the event is marked as recorded.
+   */
   void block(const Stream& stream) const {
     impl_.block(stream);
   }
 
-/**
- * Returns true if (and only if)
- *  (1) the event has never been scheduled to be recorded
- *  (2) the current version is marked as recorded.
- * Returns false otherwise.
- */
+  /**
+   * Returns true if (and only if)
+   *  (1) the event has never been scheduled to be recorded
+   *  (2) the current version is marked as recorded.
+   * Returns false otherwise.
+   */
   bool query() const {
     return impl_.query();
   }
 
-private:
+ private:
   impl::InlineEvent<impl::VirtualGuardImpl> impl_;
 };
 
-} // c10
+} // namespace c10
diff --git a/c10/core/GeneratorImpl.cpp b/c10/core/GeneratorImpl.cpp
index 68ae9bc8012..78d30da67e3 100644
--- a/c10/core/GeneratorImpl.cpp
+++ b/c10/core/GeneratorImpl.cpp
@@ -13,7 +13,7 @@ namespace c10 {
  * GeneratorImpl class implementation
  */
 GeneratorImpl::GeneratorImpl(Device device_in, DispatchKeySet key_set)
- : device_{device_in}, key_set_(key_set) {}
+    : device_{device_in}, key_set_(key_set) {}
 
 /**
  * Clone this generator. Note that clone() is the only
@@ -40,14 +40,15 @@ namespace detail {
  * FIXME: use std::random_device with entropy information
  */
 #ifndef _WIN32
-static uint64_t readURandomLong()
-{
+static uint64_t readURandomLong() {
   int randDev = open("/dev/urandom", O_RDONLY);
   // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
   uint64_t randValue;
   TORCH_CHECK(randDev >= 0, "Unable to open /dev/urandom");
   ssize_t readBytes = read(randDev, &randValue, sizeof(randValue));
-  TORCH_CHECK(readBytes >= (ssize_t) sizeof(randValue), "Unable to read from /dev/urandom");
+  TORCH_CHECK(
+      readBytes >= (ssize_t)sizeof(randValue),
+      "Unable to read from /dev/urandom");
   close(randDev);
   return randValue;
 }
@@ -58,11 +59,11 @@ static uint64_t readURandomLong()
  * /dev/urandom or the current time. For CUDA, gets random from
  * std::random_device and adds a transformation on it.
  *
- * FIXME: The behavior in this function is from legacy code (THRandom_seed/THCRandom_seed)
- * and is probably not the right thing to do, even though our tests pass.
- * Figure out if tests get perturbed
- * - when the same algorithm is used for all backends. Note that the current behavior is
- *   different for CPU, CUDA and Windows CPU.
+ * FIXME: The behavior in this function is from legacy code
+ * (THRandom_seed/THCRandom_seed) and is probably not the right thing to do,
+ * even though our tests pass. Figure out if tests get perturbed
+ * - when the same algorithm is used for all backends. Note that the current
+ * behavior is different for CPU, CUDA and Windows CPU.
  * - when using C++11 std objects, such as std::random_device
  * - when constructing a 64 bit seed properly, rather than static casting
  *   a 32 bit number to 64 bit.
@@ -71,11 +72,13 @@ uint64_t getNonDeterministicRandom(bool is_cuda) {
   // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
   uint64_t s;
   if (!is_cuda) {
-    #ifdef _WIN32
-      s = (uint64_t)std::chrono::high_resolution_clock::now().time_since_epoch().count();
-    #else
-      s = readURandomLong();
-    #endif
+#ifdef _WIN32
+    s = (uint64_t)std::chrono::high_resolution_clock::now()
+            .time_since_epoch()
+            .count();
+#else
+    s = readURandomLong();
+#endif
   } else {
     std::random_device rd;
     // limit to 53 bits to ensure unique representation in double
diff --git a/c10/core/GeneratorImpl.h b/c10/core/GeneratorImpl.h
index 84e620e93a7..389bd627140 100644
--- a/c10/core/GeneratorImpl.h
+++ b/c10/core/GeneratorImpl.h
@@ -1,52 +1,54 @@
 #pragma once
 
 #include <stdint.h>
-#include <mutex>
-#include <deque>
 #include <atomic>
+#include <deque>
+#include <mutex>
 #include <typeinfo>
 #include <utility>
 
-#include <c10/util/Exception.h>
-#include <c10/util/C++17.h>
-#include <c10/util/intrusive_ptr.h>
 #include <c10/core/Device.h>
 #include <c10/core/DispatchKeySet.h>
-#include <c10/util/python_stub.h>
 #include <c10/core/TensorImpl.h>
+#include <c10/util/C++17.h>
+#include <c10/util/Exception.h>
+#include <c10/util/intrusive_ptr.h>
+#include <c10/util/python_stub.h>
 
 /**
  * Note [Generator]
  * ~~~~~~~~~~~~~~~~
- * A Pseudo Random Number Generator (PRNG) is an engine that uses an algorithm to
- * generate a seemingly random sequence of numbers, that may be later be used in creating
- * a random distribution. Such an engine almost always maintains a state and requires a
- * seed to start off the creation of random numbers. Often times, users have
- * found it beneficial to be able to explicitly create, retain, and destroy
- * PRNG states and also be able to have control over the seed value.
+ * A Pseudo Random Number Generator (PRNG) is an engine that uses an algorithm
+ * to generate a seemingly random sequence of numbers, that may be later be used
+ * in creating a random distribution. Such an engine almost always maintains a
+ * state and requires a seed to start off the creation of random numbers. Often
+ * times, users have found it beneficial to be able to explicitly create,
+ * retain, and destroy PRNG states and also be able to have control over the
+ * seed value.
  *
- * A Generator in ATen gives users the ability to read, write and modify a PRNG engine.
- * For instance, it does so by letting users seed a PRNG engine, fork the state of the
- * engine, etc.
+ * A Generator in ATen gives users the ability to read, write and modify a PRNG
+ * engine. For instance, it does so by letting users seed a PRNG engine, fork
+ * the state of the engine, etc.
  *
  * By default, there is one generator per device, and a device's generator is
- * lazily created. A user can use the torch.Generator() api to create their own generator.
- * Currently torch.Generator() can only create a CPUGeneratorImpl.
+ * lazily created. A user can use the torch.Generator() api to create their own
+ * generator. Currently torch.Generator() can only create a CPUGeneratorImpl.
  */
 
 /**
  * Note [Acquire lock when using random generators]
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * Generator and its derived classes are NOT thread-safe. Please note that most of the
- * places where we have inserted locking for generators are historically based, and we
- * haven't actually checked that everything is truly thread safe (and it probably isn't).
- * Please use the public mutex_ when using any methods from these classes, except for the
- * read-only methods. You can learn about the usage by looking into the unittests
- * (aten/src/ATen/cpu_generator_test.cpp) and other places where we have used lock_guard.
+ * Generator and its derived classes are NOT thread-safe. Please note that most
+ * of the places where we have inserted locking for generators are historically
+ * based, and we haven't actually checked that everything is truly thread safe
+ * (and it probably isn't). Please use the public mutex_ when using any methods
+ * from these classes, except for the read-only methods. You can learn about the
+ * usage by looking into the unittests (aten/src/ATen/cpu_generator_test.cpp)
+ * and other places where we have used lock_guard.
  *
- * TODO: Look into changing the threading semantics of Generators in ATen (e.g., making
- * them non-thread safe and instead making the generator state splittable, to accommodate
- * forks into other threads).
+ * TODO: Look into changing the threading semantics of Generators in ATen (e.g.,
+ * making them non-thread safe and instead making the generator state
+ * splittable, to accommodate forks into other threads).
  */
 
 namespace c10 {
@@ -79,7 +81,9 @@ struct C10_API GeneratorImpl : public c10::intrusive_ptr_target {
   // See Note [Acquire lock when using random generators]
   std::mutex mutex_;
 
-  DispatchKeySet key_set() const { return key_set_; }
+  DispatchKeySet key_set() const {
+    return key_set_;
+  }
 
   inline void set_pyobj(PyObject* pyobj) noexcept {
     pyobj_ = pyobj;
@@ -89,12 +93,12 @@ struct C10_API GeneratorImpl : public c10::intrusive_ptr_target {
     return pyobj_;
   }
 
-  protected:
-    Device device_;
-    DispatchKeySet key_set_;
-    PyObject* pyobj_ = nullptr;
+ protected:
+  Device device_;
+  DispatchKeySet key_set_;
+  PyObject* pyobj_ = nullptr;
 
-    virtual GeneratorImpl* clone_impl() const = 0;
+  virtual GeneratorImpl* clone_impl() const = 0;
 };
 
 namespace detail {
diff --git a/c10/core/GradMode.h b/c10/core/GradMode.h
index 1773db201d6..1168bb1ae67 100644
--- a/c10/core/GradMode.h
+++ b/c10/core/GradMode.h
@@ -27,4 +27,4 @@ struct TORCH_API NoGradGuard : public AutoGradMode {
   NoGradGuard() : AutoGradMode(/*enabled=*/false) {}
 };
 
-}
+} // namespace c10
diff --git a/c10/core/InferenceMode.cpp b/c10/core/InferenceMode.cpp
index 3f55c6a6d1f..c4292859920 100644
--- a/c10/core/InferenceMode.cpp
+++ b/c10/core/InferenceMode.cpp
@@ -6,7 +6,8 @@ namespace c10 {
 thread_local bool InferenceMode_enabled = false;
 
 // Invariant:
-//   is_enabled() == !c10::impl::tls_is_dispatch_key_included(DispatchKey::InplaceOrView);
+//   is_enabled() ==
+//   !c10::impl::tls_is_dispatch_key_included(DispatchKey::InplaceOrView);
 // InferenceMode::is_enabled() is in perf critical path (TensorImpl constructor)
 // so it worths a separate TLS to skip the DispatchKeySet check.
 bool InferenceMode::is_enabled() {
diff --git a/c10/core/InferenceMode.h b/c10/core/InferenceMode.h
index 1df2dde8dcd..685f2e82461 100644
--- a/c10/core/InferenceMode.h
+++ b/c10/core/InferenceMode.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <c10/core/GradMode.h>
-#include <c10/macros/Macros.h>
 #include <c10/core/impl/LocalDispatchKeySet.h>
+#include <c10/macros/Macros.h>
 
 namespace c10 {
 
@@ -10,13 +10,14 @@ namespace c10 {
 // construction, and sets it back to the original value upon destruction.
 struct TORCH_API InferenceMode {
   // Note [Expected TLS state in InferenceMode]:
-  //   InferenceMode: InplaceOrView not in raw_local_dispatch_key_set.included(),
+  //   InferenceMode: InplaceOrView not in
+  //   raw_local_dispatch_key_set.included(),
   //                  Autograd in raw_local_dispatch_key_set.excluded()
   //                  GradMode is disabled.
   //   NormalMode: InplaceOrView in raw_local_dispatch_key_set.included(),
   //               Autograd not in raw_local_dispatch_key_set.excluded()
-  //               GradMode is enabled by default unless toggled manually through
-  //               other APIs, e.g. NoGradGuard.
+  //               GradMode is enabled by default unless toggled manually
+  //               through other APIs, e.g. NoGradGuard.
   //
   // Invariant:
   // - InplaceOrView is never in the excluded set
@@ -25,8 +26,8 @@ struct TORCH_API InferenceMode {
   //
   //  1. Why do we put InplaceOrView in included set outside InferenceMode?
   //
-  //     Inplace update to inference tensor outside InferenceMode is not allowed.
-  //     See Note [Inplace update inference tensor] for more details.
+  //     Inplace update to inference tensor outside InferenceMode is not
+  //     allowed. See Note [Inplace update inference tensor] for more details.
   //     Without going through InplaceOrView kernel, we cannot throw error
   //     for `inference_tensor.add_(1)` case.
   //
@@ -48,14 +49,17 @@ struct TORCH_API InferenceMode {
   //    version of NoGradGuard. All runtime checks using GradMode::is_enabled()
   //    are applicable to InferenceMode as well, e.g.
   //    `tensorTypeInCurrentExecutionContext` in interpreter.cpp.
-  InferenceMode(bool enabled=true): prev_mode(InferenceMode::is_enabled()),
-      prev_keyset(c10::impl::tls_local_dispatch_key_set()),
-      grad_mode(at::AutoGradMode(!enabled)) {
+  InferenceMode(bool enabled = true)
+      : prev_mode(InferenceMode::is_enabled()),
+        prev_keyset(c10::impl::tls_local_dispatch_key_set()),
+        grad_mode(at::AutoGradMode(!enabled)) {
     set_enabled(enabled);
-    DispatchKeySet included = enabled ? prev_keyset.included_.remove(c10::DispatchKey::InplaceOrView)
-         : prev_keyset.included_.add(c10::DispatchKey::InplaceOrView);
-    DispatchKeySet excluded = enabled ? (prev_keyset.excluded_ | c10::autograd_dispatch_keyset)
-         : (prev_keyset.excluded_ - c10::autograd_dispatch_keyset);
+    DispatchKeySet included = enabled
+        ? prev_keyset.included_.remove(c10::DispatchKey::InplaceOrView)
+        : prev_keyset.included_.add(c10::DispatchKey::InplaceOrView);
+    DispatchKeySet excluded = enabled
+        ? (prev_keyset.excluded_ | c10::autograd_dispatch_keyset)
+        : (prev_keyset.excluded_ - c10::autograd_dispatch_keyset);
     c10::impl::PODLocalDispatchKeySet cur_keyset;
     cur_keyset.set_included(included);
     cur_keyset.set_excluded(excluded);
@@ -71,9 +75,9 @@ struct TORCH_API InferenceMode {
   // ThreadLocalState.cpp.
   static void set_enabled(bool enabled);
 
-  private:
-    bool prev_mode;
-    c10::impl::LocalDispatchKeySet prev_keyset;
-    at::AutoGradMode grad_mode;
+ private:
+  bool prev_mode;
+  c10::impl::LocalDispatchKeySet prev_keyset;
+  at::AutoGradMode grad_mode;
 };
 } // namespace c10
diff --git a/c10/core/MemoryFormat.h b/c10/core/MemoryFormat.h
index 19b93b9f590..ba4e056e1e6 100644
--- a/c10/core/MemoryFormat.h
+++ b/c10/core/MemoryFormat.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <c10/core/Backend.h>
-#include <c10/util/Exception.h>
 #include <c10/util/ArrayRef.h>
+#include <c10/util/Exception.h>
 
 #include <iostream>
 
@@ -17,14 +17,20 @@
 //    should be in channels_last format
 //
 //  Contiguous:
-//    Regardless of input tensors format, the output should be contiguous Tensor.
+//    Regardless of input tensors format, the output should be contiguous
+//    Tensor.
 //
 //  ChannelsLast:
-//    Regardless of input tensors format, the output should be in channels_last format.
-
+//    Regardless of input tensors format, the output should be in channels_last
+//    format.
 
 namespace c10 {
-enum class MemoryFormat : int8_t { Contiguous, Preserve, ChannelsLast, ChannelsLast3d };
+enum class MemoryFormat : int8_t {
+  Contiguous,
+  Preserve,
+  ChannelsLast,
+  ChannelsLast3d
+};
 
 // If you are seeing this, it means that this call site was not checked if
 // the memory format could be preserved, and it was switched to old default
@@ -52,7 +58,8 @@ inline std::ostream& operator<<(
   }
 }
 
-// Note: Hardcoded the channel last stride indices here to get better performance
+// Note: Hardcoded the channel last stride indices here to get better
+// performance
 inline std::vector<int64_t> get_channels_last_strides_2d(IntArrayRef sizes) {
   std::vector<int64_t> strides(sizes.size());
   switch (sizes.size()) {
@@ -68,7 +75,8 @@ inline std::vector<int64_t> get_channels_last_strides_2d(IntArrayRef sizes) {
       strides[1] = strides[2] * sizes[2];
       return strides;
     default:
-      TORCH_INTERNAL_ASSERT(false, "ChannelsLast2d doesn't support size ", sizes.size());
+      TORCH_INTERNAL_ASSERT(
+          false, "ChannelsLast2d doesn't support size ", sizes.size());
   }
 }
 
@@ -89,7 +97,8 @@ inline std::vector<int64_t> get_channels_last_strides_3d(IntArrayRef sizes) {
       strides[1] = strides[2] * sizes[2];
       return strides;
     default:
-      TORCH_INTERNAL_ASSERT(false, "ChannelsLast3d doesn't support size ", sizes.size());
+      TORCH_INTERNAL_ASSERT(
+          false, "ChannelsLast3d doesn't support size ", sizes.size());
   }
 }
 
@@ -100,12 +109,16 @@ inline std::vector<int64_t> get_channels_last_strides_3d(IntArrayRef sizes) {
 // will be a constant array and we can access it using constant index number,
 // the compiler will fully unroll the loop on strides indices to gain a better
 // performance.
-// 2. No error check in helper function, caller ensures the correctness of the input
-// 3. All helper functions have similar comments, only 1st helper function is commented here.
-inline bool is_channels_last_strides_2d_s4(const IntArrayRef sizes, const IntArrayRef strides) {
+// 2. No error check in helper function, caller ensures the correctness of the
+// input
+// 3. All helper functions have similar comments, only 1st helper function is
+// commented here.
+inline bool is_channels_last_strides_2d_s4(
+    const IntArrayRef sizes,
+    const IntArrayRef strides) {
   int64_t min = 0;
   // special case for trivial C dimension. default to NCHW
-  if (strides[1]==0) {
+  if (strides[1] == 0) {
     return false;
   }
   // loop strides indices
@@ -121,8 +134,9 @@ inline bool is_channels_last_strides_2d_s4(const IntArrayRef sizes, const IntArr
     // N111 tensor with identical strides for size 1 dimension;
     // Two cases could lead us here:
     // a. N111 contiguous Tensor ([N,1,1,1]@[1,1,1,1])
-    // b. N11W contiguous Tensor sliced on the W-dimension. ([N,1,1,1]@[W,W,W,W])
-    if (d==0 && min==strides[1]) {
+    // b. N11W contiguous Tensor sliced on the W-dimension.
+    // ([N,1,1,1]@[W,W,W,W])
+    if (d == 0 && min == strides[1]) {
       return false;
     }
     // This is necessary to:
@@ -140,7 +154,9 @@ inline bool is_channels_last_strides_2d_s4(const IntArrayRef sizes, const IntArr
   return true;
 }
 
-inline bool is_channels_last_strides_3d_s5(const IntArrayRef sizes, const IntArrayRef strides) {
+inline bool is_channels_last_strides_3d_s5(
+    const IntArrayRef sizes,
+    const IntArrayRef strides) {
   int64_t min = 0;
   if (strides[1] == 0) {
     return false;
@@ -209,10 +225,13 @@ inline bool is_channels_last_strides_3d_s5(const IntArrayRef sizes, const IntArr
 // issues in our tests.
 //
 // We use Channels Last 2d as an example above.
-// This is a general problem for all the is_channels_last_strides_xd implementation.
-// Please check the helper functions (is_channels_last_strides_*d_s*) for more details.
+// This is a general problem for all the is_channels_last_strides_xd
+// implementation. Please check the helper functions
+// (is_channels_last_strides_*d_s*) for more details.
 
-inline bool is_channels_last_strides_2d(const IntArrayRef sizes, const IntArrayRef strides) {
+inline bool is_channels_last_strides_2d(
+    const IntArrayRef sizes,
+    const IntArrayRef strides) {
   switch (sizes.size()) {
     case 4:
       return is_channels_last_strides_2d_s4(sizes, strides);
@@ -224,7 +243,9 @@ inline bool is_channels_last_strides_2d(const IntArrayRef sizes, const IntArrayR
   }
 }
 
-inline bool is_channels_last_strides_3d(const IntArrayRef sizes, const IntArrayRef strides) {
+inline bool is_channels_last_strides_3d(
+    const IntArrayRef sizes,
+    const IntArrayRef strides) {
   switch (sizes.size()) {
     case 5:
       return is_channels_last_strides_3d_s5(sizes, strides);
diff --git a/c10/core/QEngine.h b/c10/core/QEngine.h
index e69e24ed0ca..ac092193d92 100644
--- a/c10/core/QEngine.h
+++ b/c10/core/QEngine.h
@@ -31,9 +31,7 @@ inline std::string toString(QEngine qengine) {
       return "QNNPACK";
     default:
       TORCH_CHECK(
-          false,
-          "Unrecognized Quantized Engine: ",
-          static_cast<int>(qengine));
+          false, "Unrecognized Quantized Engine: ", static_cast<int>(qengine));
   }
 }
 
diff --git a/c10/core/QScheme.h b/c10/core/QScheme.h
index 0a1246830e1..957618d74fc 100644
--- a/c10/core/QScheme.h
+++ b/c10/core/QScheme.h
@@ -24,12 +24,13 @@ constexpr auto kPerTensorAffine = QScheme::PER_TENSOR_AFFINE;
 constexpr auto kPerChannelAffine = QScheme::PER_CHANNEL_AFFINE;
 constexpr auto kPerTensorSymmetric = QScheme::PER_TENSOR_SYMMETRIC;
 constexpr auto kPerChannelSymmetric = QScheme::PER_CHANNEL_SYMMETRIC;
-constexpr auto kPerChannelAffineFloatQParams = QScheme::PER_CHANNEL_AFFINE_FLOAT_QPARAMS;
+constexpr auto kPerChannelAffineFloatQParams =
+    QScheme::PER_CHANNEL_AFFINE_FLOAT_QPARAMS;
 constexpr int COMPILE_TIME_NUM_QSCHEMES =
-  static_cast<int>(QScheme::COMPILE_TIME_NUM_QSCHEMES);
+    static_cast<int>(QScheme::COMPILE_TIME_NUM_QSCHEMES);
 
 inline std::string toString(QScheme qscheme) {
-  switch(qscheme) {
+  switch (qscheme) {
     case kPerTensorAffine:
       return "per_tensor_affine";
     case kPerChannelAffine:
diff --git a/c10/core/Scalar.cpp b/c10/core/Scalar.cpp
index 203b544924e..dd1f95813c3 100644
--- a/c10/core/Scalar.cpp
+++ b/c10/core/Scalar.cpp
@@ -3,7 +3,9 @@
 namespace c10 {
 
 Scalar Scalar::operator-() const {
-  TORCH_CHECK(!isBoolean(), "torch boolean negative, the `-` operator, is not supported.");
+  TORCH_CHECK(
+      !isBoolean(),
+      "torch boolean negative, the `-` operator, is not supported.");
   if (isFloatingPoint()) {
     return Scalar(-v.d);
   } else if (isComplex()) {
@@ -31,4 +33,4 @@ Scalar Scalar::log() const {
   }
 }
 
-}  // namespace c10
+} // namespace c10
diff --git a/c10/core/Scalar.h b/c10/core/Scalar.h
index 368228e8202..802bf17e041 100644
--- a/c10/core/Scalar.h
+++ b/c10/core/Scalar.h
@@ -4,8 +4,8 @@
 #include <stdint.h>
 #include <stdexcept>
 #include <string>
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 #include <c10/core/ScalarType.h>
 #include <c10/macros/Macros.h>
@@ -26,8 +26,8 @@ class C10_API Scalar {
  public:
   Scalar() : Scalar(int64_t(0)) {}
 
-#define DEFINE_IMPLICIT_CTOR(type, name)      \
-  Scalar(type vv) : Scalar(vv, true) { }
+#define DEFINE_IMPLICIT_CTOR(type, name) \
+  Scalar(type vv) : Scalar(vv, true) {}
 
   AT_FORALL_SCALAR_TYPES_AND2(Half, BFloat16, DEFINE_IMPLICIT_CTOR)
   AT_FORALL_COMPLEX_TYPES(DEFINE_IMPLICIT_CTOR)
@@ -45,18 +45,18 @@ class C10_API Scalar {
     v.i = convert<int64_t, bool>(vv);
   }
 
-#define DEFINE_ACCESSOR(type, name)                       \
-  type to##name() const {                                 \
-    if (Tag::HAS_d == tag) {                              \
-      return checked_convert<type, double>(v.d, #type);   \
-    } else if (Tag::HAS_z == tag) {                       \
-      return checked_convert<type, c10::complex<double>>( \
-          v.z, #type);                                    \
-    } if (Tag::HAS_b == tag) {                            \
-      return checked_convert<type, bool>(v.i, #type);     \
-    } else {                                              \
-      return checked_convert<type, int64_t>(v.i, #type);  \
-    }                                                     \
+#define DEFINE_ACCESSOR(type, name)                                   \
+  type to##name() const {                                             \
+    if (Tag::HAS_d == tag) {                                          \
+      return checked_convert<type, double>(v.d, #type);               \
+    } else if (Tag::HAS_z == tag) {                                   \
+      return checked_convert<type, c10::complex<double>>(v.z, #type); \
+    }                                                                 \
+    if (Tag::HAS_b == tag) {                                          \
+      return checked_convert<type, bool>(v.i, #type);                 \
+    } else {                                                          \
+      return checked_convert<type, int64_t>(v.i, #type);              \
+    }                                                                 \
   }
 
   // TODO: Support ComplexHalf accessor
@@ -71,7 +71,8 @@ class C10_API Scalar {
     return Tag::HAS_d == tag;
   }
 
-  C10_DEPRECATED_MESSAGE("isIntegral is deprecated. Please use the overload with 'includeBool' parameter instead.")
+  C10_DEPRECATED_MESSAGE(
+      "isIntegral is deprecated. Please use the overload with 'includeBool' parameter instead.")
   bool isIntegral() const {
     return Tag::HAS_i == tag;
   }
@@ -90,7 +91,9 @@ class C10_API Scalar {
   Scalar conj() const;
   Scalar log() const;
 
-  template<typename T, typename std::enable_if<!c10::is_complex<T>::value, int>::type = 0>
+  template <
+      typename T,
+      typename std::enable_if<!c10::is_complex<T>::value, int>::type = 0>
   bool equal(T num) const {
     if (isComplex()) {
       auto val = v.z;
@@ -105,7 +108,9 @@ class C10_API Scalar {
     }
   }
 
-  template<typename T, typename std::enable_if<c10::is_complex<T>::value, int>::type = 0>
+  template <
+      typename T,
+      typename std::enable_if<c10::is_complex<T>::value, int>::type = 0>
   bool equal(T num) const {
     if (isComplex()) {
       return v.z == num;
@@ -142,26 +147,30 @@ class C10_API Scalar {
   }
 
  private:
-    template<typename T,
-             typename std::enable_if<std::is_integral<T>::value && ! std::is_same<T, bool>::value, bool>::type* =
-                 nullptr>
-    Scalar(T vv, bool) : tag(Tag::HAS_i) {
-      v.i = convert<decltype(v.i), T>(vv);
-    }
+  template <
+      typename T,
+      typename std::enable_if<
+          std::is_integral<T>::value && !std::is_same<T, bool>::value,
+          bool>::type* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_i) {
+    v.i = convert<decltype(v.i), T>(vv);
+  }
 
-    template<typename T,
-             typename std::enable_if<!std::is_integral<T>::value && !c10::is_complex<T>::value, bool>::type* =
-                 nullptr>
-    Scalar(T vv, bool) : tag(Tag::HAS_d) {
-      v.d = convert<decltype(v.d), T>(vv);
-    }
+  template <
+      typename T,
+      typename std::enable_if<
+          !std::is_integral<T>::value && !c10::is_complex<T>::value,
+          bool>::type* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_d) {
+    v.d = convert<decltype(v.d), T>(vv);
+  }
 
-    template<typename T,
-             typename std::enable_if<c10::is_complex<T>::value, bool>::type* =
-                 nullptr>
-    Scalar(T vv, bool) : tag(Tag::HAS_z) {
-      v.z = convert<decltype(v.z), T>(vv);
-    }
+  template <
+      typename T,
+      typename std::enable_if<c10::is_complex<T>::value, bool>::type* = nullptr>
+  Scalar(T vv, bool) : tag(Tag::HAS_z) {
+    v.z = convert<decltype(v.z), T>(vv);
+  }
 
   // We can't set v in the initializer list using the
   // syntax v{ .member = ... } because it doesn't work on MSVC
@@ -172,7 +181,7 @@ class C10_API Scalar {
     double d;
     int64_t i;
     c10::complex<double> z;
-    v_t(){}  // default constructor
+    v_t() {} // default constructor
   } v;
 };
 
@@ -182,10 +191,10 @@ inline T Scalar::to() const {
   throw std::runtime_error("to() cast to unexpected type.");
 }
 
-#define DEFINE_TO(T, name)    \
-  template <>                 \
-  inline T Scalar::to<T>() const {  \
-    return to##name();        \
+#define DEFINE_TO(T, name)         \
+  template <>                      \
+  inline T Scalar::to<T>() const { \
+    return to##name();             \
   }
 AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(DEFINE_TO)
 #undef DEFINE_TO
diff --git a/c10/core/ScalarType.h b/c10/core/ScalarType.h
index 76af2eb0f46..3cabbbeed5b 100644
--- a/c10/core/ScalarType.h
+++ b/c10/core/ScalarType.h
@@ -1,14 +1,14 @@
 #pragma once
 
 #include <c10/util/ArrayRef.h>
-#include <c10/util/complex.h>
+#include <c10/util/BFloat16.h>
 #include <c10/util/Half.h>
+#include <c10/util/Optional.h>
+#include <c10/util/complex.h>
 #include <c10/util/qint32.h>
 #include <c10/util/qint8.h>
-#include <c10/util/quint8.h>
-#include <c10/util/BFloat16.h>
 #include <c10/util/quint4x2.h>
-#include <c10/util/Optional.h>
+#include <c10/util/quint8.h>
 
 #include <complex>
 #include <cstdint>
@@ -44,7 +44,6 @@ namespace c10 {
   _(at::BFloat16, BFloat16) /* 15 */                     \
   _(c10::quint4x2, QUInt4x2) /* 16 */
 
-
 // If you want to support ComplexHalf for real, add ComplexHalf
 // into this macro (and change the name).  But beware: convert()
 // doesn't work for all the conversions you need...
@@ -62,7 +61,6 @@ namespace c10 {
   _(bool, Bool)                                                    \
   _(at::BFloat16, BFloat16)
 
-
 enum class ScalarType : int8_t {
 #define DEFINE_ENUM(_1, n) n,
   AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(DEFINE_ENUM)
@@ -71,7 +69,8 @@ enum class ScalarType : int8_t {
   NumOptions
 };
 
-constexpr uint16_t NumScalarTypes = static_cast<uint16_t>(ScalarType::NumOptions);
+constexpr uint16_t NumScalarTypes =
+    static_cast<uint16_t>(ScalarType::NumOptions);
 
 namespace impl {
 
@@ -80,20 +79,20 @@ namespace impl {
 template <c10::ScalarType N>
 struct ScalarTypeToCPPType;
 
-#define SPECIALIZE_ScalarTypeToCPPType(cpp_type, scalar_type)                  \
-template<>                                                                     \
-struct ScalarTypeToCPPType<c10::ScalarType::scalar_type> {                     \
-  using type = cpp_type;                                                       \
-                                                                               \
-  /* This is a workaround for the CUDA bug which prevents */                   \
-  /* ::detail::ScalarTypeToCType<T>::type being used directly due to */        \
-  /* ambiguous reference which can't to be resolved. For some reason it */     \
-  /* cant pick between at::detail and at::cuda::detail. */                     \
-  /* For repro example, please see: */                                         \
-  /* https://gist.github.com/izdeby/952ae7cf256ddb740a73776d39a7e7ba */        \
-  /* TODO: remove once the bug is fixed. */                                    \
-  static type t;                                                               \
-};
+#define SPECIALIZE_ScalarTypeToCPPType(cpp_type, scalar_type)                \
+  template <>                                                                \
+  struct ScalarTypeToCPPType<c10::ScalarType::scalar_type> {                 \
+    using type = cpp_type;                                                   \
+                                                                             \
+    /* This is a workaround for the CUDA bug which prevents */               \
+    /* ::detail::ScalarTypeToCType<T>::type being used directly due to */    \
+    /* ambiguous reference which can't to be resolved. For some reason it */ \
+    /* cant pick between at::detail and at::cuda::detail. */                 \
+    /* For repro example, please see: */                                     \
+    /* https://gist.github.com/izdeby/952ae7cf256ddb740a73776d39a7e7ba */    \
+    /* TODO: remove once the bug is fixed. */                                \
+    static type t;                                                           \
+  };
 
 AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SPECIALIZE_ScalarTypeToCPPType)
 
@@ -104,12 +103,12 @@ AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SPECIALIZE_ScalarTypeToCPPType)
 template <typename T>
 struct CppTypeToScalarType;
 
-#define SPECIALIZE_CppTypeToScalarType(cpp_type, scalar_type) \
-  template<>                                                  \
-  struct CppTypeToScalarType<cpp_type>:                       \
-    std::integral_constant<c10::ScalarType,                   \
-                           c10::ScalarType::scalar_type>      \
-  {};
+#define SPECIALIZE_CppTypeToScalarType(cpp_type, scalar_type)                  \
+  template <>                                                                  \
+  struct CppTypeToScalarType<cpp_type>                                         \
+      : std::                                                                  \
+            integral_constant<c10::ScalarType, c10::ScalarType::scalar_type> { \
+  };
 
 AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SPECIALIZE_CppTypeToScalarType)
 
@@ -131,47 +130,59 @@ AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SPECIALIZE_CppTypeToScalarType)
   _(float, Float)                 \
   _(double, Double)
 
-#define AT_FORALL_SCALAR_TYPES_AND(SCALARTYPE, _)                          \
-  _(uint8_t, Byte)                                                         \
-  _(int8_t, Char)                                                          \
-  _(int16_t, Short)                                                        \
-  _(int, Int)                                                              \
-  _(int64_t, Long)                                                         \
-  _(float, Float)                                                          \
-  _(double, Double)                                                        \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE>::t), SCALARTYPE)
+#define AT_FORALL_SCALAR_TYPES_AND(SCALARTYPE, _)                            \
+  _(uint8_t, Byte)                                                           \
+  _(int8_t, Char)                                                            \
+  _(int16_t, Short)                                                          \
+  _(int, Int)                                                                \
+  _(int64_t, Long)                                                           \
+  _(float, Float)                                                            \
+  _(double, Double)                                                          \
+  _(decltype(                                                                \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE>::t), \
+    SCALARTYPE)
 
-#define AT_FORALL_SCALAR_TYPES_AND2(SCALARTYPE1, SCALARTYPE2, _)                                \
-  _(uint8_t, Byte)                                                                              \
-  _(int8_t, Char)                                                                               \
-  _(int16_t, Short)                                                                             \
-  _(int, Int)                                                                                   \
-  _(int64_t, Long)                                                                              \
-  _(float, Float)                                                                               \
-  _(double, Double)                                                                             \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE1>::t), SCALARTYPE1) \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE2>::t), SCALARTYPE2)
+#define AT_FORALL_SCALAR_TYPES_AND2(SCALARTYPE1, SCALARTYPE2, _)              \
+  _(uint8_t, Byte)                                                            \
+  _(int8_t, Char)                                                             \
+  _(int16_t, Short)                                                           \
+  _(int, Int)                                                                 \
+  _(int64_t, Long)                                                            \
+  _(float, Float)                                                             \
+  _(double, Double)                                                           \
+  _(decltype(                                                                 \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE1>::t), \
+    SCALARTYPE1)                                                              \
+  _(decltype(                                                                 \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE2>::t), \
+    SCALARTYPE2)
 
-#define AT_FORALL_SCALAR_TYPES_AND3(SCALARTYPE1, SCALARTYPE2, SCALARTYPE3, _)                   \
-  _(uint8_t, Byte)                                                                              \
-  _(int8_t, Char)                                                                               \
-  _(int16_t, Short)                                                                             \
-  _(int, Int)                                                                                   \
-  _(int64_t, Long)                                                                              \
-  _(float, Float)                                                                               \
-  _(double, Double)                                                                             \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE1>::t), SCALARTYPE1) \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE2>::t), SCALARTYPE2) \
-  _(decltype(::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE3>::t), SCALARTYPE3)
+#define AT_FORALL_SCALAR_TYPES_AND3(SCALARTYPE1, SCALARTYPE2, SCALARTYPE3, _) \
+  _(uint8_t, Byte)                                                            \
+  _(int8_t, Char)                                                             \
+  _(int16_t, Short)                                                           \
+  _(int, Int)                                                                 \
+  _(int64_t, Long)                                                            \
+  _(float, Float)                                                             \
+  _(double, Double)                                                           \
+  _(decltype(                                                                 \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE1>::t), \
+    SCALARTYPE1)                                                              \
+  _(decltype(                                                                 \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE2>::t), \
+    SCALARTYPE2)                                                              \
+  _(decltype(                                                                 \
+        ::c10::impl::ScalarTypeToCPPType<::c10::ScalarType::SCALARTYPE3>::t), \
+    SCALARTYPE3)
 
-#define AT_FORALL_QINT_TYPES(_)  \
-  _(c10::qint8, QInt8)           \
-  _(c10::quint8, QUInt8)         \
-  _(c10::qint32, QInt32)         \
+#define AT_FORALL_QINT_TYPES(_) \
+  _(c10::qint8, QInt8)          \
+  _(c10::quint8, QUInt8)        \
+  _(c10::qint32, QInt32)        \
   _(c10::quint4x2, QUInt4x2)
 
-#define AT_FORALL_COMPLEX_TYPES(_)             \
-  _(c10::complex<float>, ComplexFloat)         \
+#define AT_FORALL_COMPLEX_TYPES(_)     \
+  _(c10::complex<float>, ComplexFloat) \
   _(c10::complex<double>, ComplexDouble)
 
 #define DEFINE_CONSTANT(_, name) \
@@ -206,7 +217,8 @@ static inline size_t elementSize(ScalarType t) {
 #undef CASE_ELEMENTSIZE_CASE
 }
 
-C10_DEPRECATED_MESSAGE("isIntegralType is deprecated. Please use the overload with 'includeBool' parameter instead.")
+C10_DEPRECATED_MESSAGE(
+    "isIntegralType is deprecated. Please use the overload with 'includeBool' parameter instead.")
 static inline bool isIntegralType(ScalarType t) {
   return (
       t == ScalarType::Byte || t == ScalarType::Char || t == ScalarType::Int ||
@@ -214,9 +226,9 @@ static inline bool isIntegralType(ScalarType t) {
 }
 
 static inline bool isIntegralType(ScalarType t, bool includeBool) {
-  bool isIntegral = (
-      t == ScalarType::Byte || t == ScalarType::Char || t == ScalarType::Int ||
-      t == ScalarType::Long || t == ScalarType::Short);
+  bool isIntegral =
+      (t == ScalarType::Byte || t == ScalarType::Char || t == ScalarType::Int ||
+       t == ScalarType::Long || t == ScalarType::Short);
 
   return includeBool ? isIntegral || (t == ScalarType::Bool) : isIntegral;
 }
@@ -235,7 +247,8 @@ static inline bool isComplexType(ScalarType t) {
 
 static inline bool isQIntType(ScalarType t) {
   // Don't forget to extend this when adding new QInt types
-  return t == ScalarType:: QInt8 || t == ScalarType::QUInt8 || t == ScalarType::QInt32 || t == ScalarType::QUInt4x2;
+  return t == ScalarType::QInt8 || t == ScalarType::QUInt8 ||
+      t == ScalarType::QInt32 || t == ScalarType::QUInt4x2;
 }
 
 static inline ScalarType toQIntType(ScalarType t) {
@@ -268,20 +281,20 @@ static inline ScalarType toUnderlying(ScalarType t) {
 
 static inline bool isSignedType(ScalarType t) {
   TORCH_CHECK(!isQIntType(t), "isSignedType not supported for quantized types");
-  #define CASE_SIGNED(ctype, name) \
-    case ScalarType::name: \
-      return std::numeric_limits<ctype>::is_signed;
+#define CASE_SIGNED(ctype, name) \
+  case ScalarType::name:         \
+    return std::numeric_limits<ctype>::is_signed;
 
   switch (t) {
     case ScalarType::ComplexHalf:
     case ScalarType::ComplexFloat:
     case ScalarType::ComplexDouble:
       return true;
-    AT_FORALL_SCALAR_TYPES_AND3(Half, Bool, BFloat16, CASE_SIGNED)
+      AT_FORALL_SCALAR_TYPES_AND3(Half, Bool, BFloat16, CASE_SIGNED)
     default:
       TORCH_CHECK(false, "Unknown ScalarType");
   }
-  #undef CASE_SIGNED
+#undef CASE_SIGNED
 }
 
 static inline bool isUnderlying(ScalarType type, ScalarType qtype) {
@@ -323,7 +336,8 @@ static inline ScalarType toComplexType(ScalarType t) {
 // see tensor_attributes.rst for detailed explanation and examples
 // of casting rules.
 static inline bool canCast(const ScalarType from, const ScalarType to) {
-  // We disallow complex -> non complex, e.g., float_tensor *= complex is disallowed.
+  // We disallow complex -> non complex, e.g., float_tensor *= complex is
+  // disallowed.
   if (isComplexType(from) && !isComplexType(to)) {
     return false;
   }
@@ -333,13 +347,14 @@ static inline bool canCast(const ScalarType from, const ScalarType to) {
   }
 
   // Treat bool as a distinct "category," to be consistent with type promotion
-  // rules (e.g. `bool_tensor + 5 -> int64_tensor`). If `5` was in the same category
-  // as `bool_tensor`, we would not promote.
-  // Differing categories implies `bool_tensor += 5` is disallowed.
+  // rules (e.g. `bool_tensor + 5 -> int64_tensor`). If `5` was in the same
+  // category as `bool_tensor`, we would not promote. Differing categories
+  // implies `bool_tensor += 5` is disallowed.
   //
   // NB: numpy distinguishes "unsigned" as a category to get the desired
   // `bool_tensor + 5 -> int64_tensor` behavior. We don't, because:
-  // * We don't want the performance hit of checking the runtime sign of Scalars.
+  // * We don't want the performance hit of checking the runtime sign of
+  // Scalars.
   // * `uint8_tensor + 5 -> int64_tensor` would be undesirable.
   if (from != ScalarType::Bool && to == ScalarType::Bool) {
     return false;
@@ -373,7 +388,8 @@ static inline ScalarType promoteTypes(ScalarType a, ScalarType b) {
   }
 
   if (isQIntType(a) || isQIntType(b)) {
-    TORCH_CHECK(false,
+    TORCH_CHECK(
+        false,
         "promoteTypes with quantized numbers is not handled yet; figure out what the correct rules should be, offending types: ",
         toString(a),
         " ",
@@ -385,23 +401,23 @@ static inline ScalarType promoteTypes(ScalarType a, ScalarType b) {
   // corrent values for the type promotions in complex type cases.
   static constexpr ScalarType _promoteTypesLookup[static_cast<int>(
       ScalarType::NumOptions)][static_cast<int>(ScalarType::NumOptions)] = {
-        /*        u1  i1  i2  i4  i8  f2  f4  f8  c2  c4  c8  b1  q1  q2  q3  bf*/
-        /* u1 */ {u1, i2, i2, i4, i8, f2, f4, f8, ud, c4, c8, u1, ud, ud, ud, bf},
-        /* i1 */ {i2, i1, i2, i4, i8, f2, f4, f8, ud, c4, c8, i1, ud, ud, ud, bf},
-        /* i2 */ {i2, i2, i2, i4, i8, f2, f4, f8, ud, c4, c8, i2, ud, ud, ud, bf},
-        /* i4 */ {i4, i4, i4, i4, i8, f2, f4, f8, ud, c4, c8, i4, ud, ud, ud, bf},
-        /* i8 */ {i8, i8, i8, i8, i8, f2, f4, f8, ud, c4, c8, i8, ud, ud, ud, bf},
-        /* f2 */ {f2, f2, f2, f2, f2, f2, f4, f8, ud, c4, c8, f2, ud, ud, ud, f4},
-        /* f4 */ {f4, f4, f4, f4, f4, f4, f4, f8, ud, c4, c8, f4, ud, ud, ud, f4},
-        /* f8 */ {f8, f8, f8, f8, f8, f8, f8, f8, ud, c8, c8, f8, ud, ud, ud, f8},
-        /* c2 */ {ud, ud, ud, ud, ud, ud, ud, ud, c2, c4, c8, ud, ud, ud, ud, ud},
-        /* c4 */ {c4, c4, c4, c4, c4, c4, c4, c8, c4, c4, c8, c4, ud, ud, ud, c4},
-        /* c8 */ {c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, ud, ud, ud, c8},
-        /* b1 */ {u1, i1, i2, i4, i8, f2, f4, f8, ud, c4, c8, b1, ud, ud, ud, bf},
-        /* q1 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
-        /* q2 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
-        /* q3 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
-        /* bf */ {bf, bf, bf, bf, bf, f4, f4, f8, ud, c4, c8, bf, ud, ud, ud, bf},
+      /*        u1  i1  i2  i4  i8  f2  f4  f8  c2  c4  c8  b1  q1  q2  q3  bf*/
+      /* u1 */ {u1, i2, i2, i4, i8, f2, f4, f8, ud, c4, c8, u1, ud, ud, ud, bf},
+      /* i1 */ {i2, i1, i2, i4, i8, f2, f4, f8, ud, c4, c8, i1, ud, ud, ud, bf},
+      /* i2 */ {i2, i2, i2, i4, i8, f2, f4, f8, ud, c4, c8, i2, ud, ud, ud, bf},
+      /* i4 */ {i4, i4, i4, i4, i8, f2, f4, f8, ud, c4, c8, i4, ud, ud, ud, bf},
+      /* i8 */ {i8, i8, i8, i8, i8, f2, f4, f8, ud, c4, c8, i8, ud, ud, ud, bf},
+      /* f2 */ {f2, f2, f2, f2, f2, f2, f4, f8, ud, c4, c8, f2, ud, ud, ud, f4},
+      /* f4 */ {f4, f4, f4, f4, f4, f4, f4, f8, ud, c4, c8, f4, ud, ud, ud, f4},
+      /* f8 */ {f8, f8, f8, f8, f8, f8, f8, f8, ud, c8, c8, f8, ud, ud, ud, f8},
+      /* c2 */ {ud, ud, ud, ud, ud, ud, ud, ud, c2, c4, c8, ud, ud, ud, ud, ud},
+      /* c4 */ {c4, c4, c4, c4, c4, c4, c4, c8, c4, c4, c8, c4, ud, ud, ud, c4},
+      /* c8 */ {c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, c8, ud, ud, ud, c8},
+      /* b1 */ {u1, i1, i2, i4, i8, f2, f4, f8, ud, c4, c8, b1, ud, ud, ud, bf},
+      /* q1 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
+      /* q2 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
+      /* q3 */ {ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud, ud},
+      /* bf */ {bf, bf, bf, bf, bf, f4, f4, f8, ud, c4, c8, bf, ud, ud, ud, bf},
   };
   return _promoteTypesLookup[static_cast<int>(a)][static_cast<int>(b)];
 }
diff --git a/c10/core/ScalarTypeToTypeMeta.h b/c10/core/ScalarTypeToTypeMeta.h
index b6e7f6cf199..6d4946b29bc 100644
--- a/c10/core/ScalarTypeToTypeMeta.h
+++ b/c10/core/ScalarTypeToTypeMeta.h
@@ -26,7 +26,8 @@ static inline ScalarType typeMetaToScalarType(caffe2::TypeMeta dtype) {
 /**
  * typeMetaToScalarType(), lifted to optional
  */
-static inline optional<at::ScalarType> optTypeMetaToScalarType(optional<caffe2::TypeMeta> type_meta) {
+static inline optional<at::ScalarType> optTypeMetaToScalarType(
+    optional<caffe2::TypeMeta> type_meta) {
   if (!type_meta.has_value()) {
     return c10::nullopt;
   }
diff --git a/c10/core/Storage.cpp b/c10/core/Storage.cpp
index 9ba79a92372..1361c8186fa 100644
--- a/c10/core/Storage.cpp
+++ b/c10/core/Storage.cpp
@@ -1,5 +1,3 @@
 #include <c10/core/Storage.h>
 
-namespace c10 {
-
-} // namespace c10
+namespace c10 {} // namespace c10
diff --git a/c10/core/Storage.h b/c10/core/Storage.h
index e2c36713cf2..f8df22b55e6 100644
--- a/c10/core/Storage.h
+++ b/c10/core/Storage.h
@@ -9,7 +9,8 @@ struct C10_API Storage {
   struct use_byte_size_t {};
 
   Storage() {}
-  Storage(c10::intrusive_ptr<StorageImpl> ptr) : storage_impl_(std::move(ptr)) {}
+  Storage(c10::intrusive_ptr<StorageImpl> ptr)
+      : storage_impl_(std::move(ptr)) {}
 
   // Allocates memory buffer using given allocator and creates a storage with it
   Storage(
@@ -53,10 +54,14 @@ struct C10_API Storage {
   }
 
   template <typename T>
-  T* data() const { return storage_impl_->data<T>(); }
+  T* data() const {
+    return storage_impl_->data<T>();
+  }
 
   template <typename T>
-  T* unsafe_data() const { return storage_impl_->unsafe_data<T>(); }
+  T* unsafe_data() const {
+    return storage_impl_->unsafe_data<T>();
+  }
 
   // TODO: remove later
   void set_nbytes(size_t size_bytes) const {
@@ -134,7 +139,8 @@ struct C10_API Storage {
       size_t capacity,
       DeleterFnPtr d = nullptr) {
     if (!storage_impl_.unique()) {
-      TORCH_CHECK(false,
+      TORCH_CHECK(
+          false,
           "UniqueStorageShareExternalPointer can only be called when use_count == 1");
     }
     storage_impl_->UniqueStorageShareExternalPointer(src, capacity, d);
@@ -144,7 +150,8 @@ struct C10_API Storage {
       at::DataPtr&& data_ptr,
       size_t capacity) {
     if (!storage_impl_.unique()) {
-      TORCH_CHECK(false,
+      TORCH_CHECK(
+          false,
           "UniqueStorageShareExternalPointer can only be called when use_count == 1");
     }
     storage_impl_->UniqueStorageShareExternalPointer(
diff --git a/c10/core/StorageImpl.h b/c10/core/StorageImpl.h
index 96897e57513..ff29b68dc4d 100644
--- a/c10/core/StorageImpl.h
+++ b/c10/core/StorageImpl.h
@@ -20,13 +20,13 @@ namespace c10 {
 // but a lot of things won't work correctly, including:
 //
 // - An ordinary deleter on such a storage is wrong, because normal deleters
-//   assume unique ownership, but if you have two storages at the same data, that
-//   implies there is some sort of shared ownership. So your deleter would have to
-//   actually be internally doing some sort of refcount thing
+//   assume unique ownership, but if you have two storages at the same data,
+//   that implies there is some sort of shared ownership. So your deleter would
+//   have to actually be internally doing some sort of refcount thing
 // - Deepcopy in Python side relies on storage equality and not data pointer
 //   equality; so if there are two separate storages pointing to the same data,
-//   the data will actually get duplicated in that case (one data ptr before, two
-//   data ptrs after)
+//   the data will actually get duplicated in that case (one data ptr before,
+//   two data ptrs after)
 // - Version counts won't work correctly, because we do all VC tracking at the
 //   level of storages (unless you explicitly disconnect the VC with detach);
 //   mutation because data pointers are the same are totally untracked
diff --git a/c10/core/Stream.h b/c10/core/Stream.h
index 62d5261534e..c149dc260e0 100644
--- a/c10/core/Stream.h
+++ b/c10/core/Stream.h
@@ -55,10 +55,11 @@ using StreamId = int32_t;
  * wrapper classes which provide this functionality, e.g., CUDAStream.
  */
 class Stream final {
-private:
+ private:
   Device device_;
   StreamId id_;
-public:
+
+ public:
   enum Unsafe { UNSAFE };
   enum Default { DEFAULT };
 
@@ -69,16 +70,13 @@ public:
   /// we don't require backends to give any guarantees about non-zero
   /// StreamIds; they are welcome to allocate in whatever way they like.
   explicit Stream(Unsafe, Device device, StreamId id)
-    : device_(device)
-    , id_(id) {}
+      : device_(device), id_(id) {}
 
   /// Construct the default stream of a Device.  The default stream is
   /// NOT the same as the current stream; default stream is a fixed stream
   /// that never changes, whereas the current stream may be changed by
   /// StreamGuard.
-  explicit Stream(Default, Device device)
-    : device_(device)
-    , id_(0) {}
+  explicit Stream(Default, Device device) : device_(device), id_(0) {}
 
   bool operator==(const Stream& other) const noexcept {
     return this->device_ == other.device_ && this->id_ == other.id_;
@@ -87,10 +85,18 @@ public:
     return !(*this == other);
   }
 
-  Device device() const noexcept { return device_; }
-  DeviceType device_type() const noexcept { return device_.type(); }
-  DeviceIndex device_index() const noexcept { return device_.index(); }
-  StreamId id() const noexcept { return id_; }
+  Device device() const noexcept {
+    return device_;
+  }
+  DeviceType device_type() const noexcept {
+    return device_.type();
+  }
+  DeviceIndex device_index() const noexcept {
+    return device_.index();
+  }
+  StreamId id() const noexcept {
+    return id_;
+  }
 
   // Enqueues a wait instruction in the stream's work queue.
   // This instruction is a no-op unless the event is marked
@@ -116,10 +122,10 @@ public:
     static_assert(sizeof(StreamId) == 4, "DeviceIndex is not 32-bit");
     // Concat these together into a 64-bit integer
     // See Note [Hazard when concatenating signed integers]
-    uint64_t bits =
-        static_cast<uint64_t>(static_cast<uint8_t>(device_type())) << 48
-      | static_cast<uint64_t>(static_cast<uint8_t>(device_index())) << 32
-      | static_cast<uint64_t>(static_cast<uint32_t>(id()));
+    uint64_t bits = static_cast<uint64_t>(static_cast<uint8_t>(device_type()))
+            << 48 |
+        static_cast<uint64_t>(static_cast<uint8_t>(device_index())) << 32 |
+        static_cast<uint64_t>(static_cast<uint32_t>(id()));
     return bits;
   }
 
@@ -145,10 +151,10 @@ C10_API std::ostream& operator<<(std::ostream& stream, const Stream& s);
 } // namespace c10
 
 namespace std {
-  template <>
-  struct hash<c10::Stream> {
-    size_t operator()(c10::Stream s) const noexcept {
-      return std::hash<uint64_t>{}(s.pack());
-    }
-  };
+template <>
+struct hash<c10::Stream> {
+  size_t operator()(c10::Stream s) const noexcept {
+    return std::hash<uint64_t>{}(s.pack());
+  }
+};
 } // namespace std
diff --git a/c10/core/StreamGuard.h b/c10/core/StreamGuard.h
index c47925cd552..8a4116f80f0 100644
--- a/c10/core/StreamGuard.h
+++ b/c10/core/StreamGuard.h
@@ -47,7 +47,9 @@ struct StreamGuard {
   /// WARNING: reset_stream does NOT preserve previously set streams on
   /// different devices.  If you need to set streams on multiple devices
   /// on , use MultiStreamGuard instead.
-  void reset_stream(Stream stream) { guard_.reset_stream(stream); }
+  void reset_stream(Stream stream) {
+    guard_.reset_stream(stream);
+  }
 
   /// Returns the stream that was set at the time the guard was constructed.
   Stream original_stream() const {
@@ -62,13 +64,17 @@ struct StreamGuard {
 
   /// Returns the most recent device that was set using this device guard,
   /// either from construction, or via set_device/reset_device/set_index.
-  Device current_device() const { return guard_.current_device(); }
+  Device current_device() const {
+    return guard_.current_device();
+  }
 
   /// Returns the device that was set at the most recent reset_stream(),
   /// or otherwise the device at construction time.
-  Device original_device() const { return guard_.original_device(); }
+  Device original_device() const {
+    return guard_.original_device();
+  }
 
-private:
+ private:
   c10::impl::InlineStreamGuard<impl::VirtualGuardImpl> guard_;
 };
 
@@ -88,7 +94,8 @@ struct OptionalStreamGuard {
   /// Set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream,
   /// if the passed stream is not nullopt.
-  explicit OptionalStreamGuard(optional<Stream> stream_opt) : guard_(stream_opt) {}
+  explicit OptionalStreamGuard(optional<Stream> stream_opt)
+      : guard_(stream_opt) {}
 
   /// Copy is disallowed
   OptionalStreamGuard(const OptionalStreamGuard&) = delete;
@@ -105,21 +112,30 @@ struct OptionalStreamGuard {
   /// set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream.
   /// Initializes the guard if it was not previously initialized.
-  void reset_stream(Stream stream) { guard_.reset_stream(stream); }
+  void reset_stream(Stream stream) {
+    guard_.reset_stream(stream);
+  }
 
   /// Returns the stream that was set at the time the guard was most recently
   /// initialized, or nullopt if the guard is uninitialized.
-  optional<Stream> original_stream() const { return guard_.original_stream(); }
+  optional<Stream> original_stream() const {
+    return guard_.original_stream();
+  }
 
   /// Returns the most recent  stream that was set using this stream guard,
-  /// either from construction, or via reset_stream, if the guard is initialized,
-  /// or nullopt if the guard is uninitialized.
-  optional<Stream> current_stream() const { return guard_.current_stream(); }
+  /// either from construction, or via reset_stream, if the guard is
+  /// initialized, or nullopt if the guard is uninitialized.
+  optional<Stream> current_stream() const {
+    return guard_.current_stream();
+  }
 
-  /// Restore the original  device and stream, resetting this guard to uninitialized state.
-  void reset() { guard_.reset(); }
+  /// Restore the original  device and stream, resetting this guard to
+  /// uninitialized state.
+  void reset() {
+    guard_.reset();
+  }
 
-private:
+ private:
   c10::impl::InlineOptionalStreamGuard<impl::VirtualGuardImpl> guard_;
 };
 
@@ -142,7 +158,7 @@ struct MultiStreamGuard {
   // See Note [Move assignment for RAII guards is tricky]
   MultiStreamGuard& operator=(MultiStreamGuard&& other) = delete;
 
-private:
+ private:
   c10::impl::InlineMultiStreamGuard<impl::VirtualGuardImpl> guard_;
 };
 
diff --git a/c10/core/TensorImpl.cpp b/c10/core/TensorImpl.cpp
index 0e746b13706..98a264f5b4b 100644
--- a/c10/core/TensorImpl.cpp
+++ b/c10/core/TensorImpl.cpp
@@ -1,10 +1,10 @@
 #include <c10/core/TensorImpl.h>
 
 #include <c10/core/Backend.h>
+#include <c10/core/InferenceMode.h>
 #include <c10/core/WrapDimMinimal.h>
 #include <c10/core/impl/LocalDispatchKeySet.h>
 #include <c10/util/Optional.h>
-#include <c10/core/InferenceMode.h>
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 C10_DEFINE_bool(
@@ -21,7 +21,7 @@ C10_DEFINE_int64(
 
 namespace c10 {
 
-const char * const TensorImpl::err_msg_tensor_metadata_change_not_allowed =
+const char* const TensorImpl::err_msg_tensor_metadata_change_not_allowed =
     "is not allowed on a Tensor created from .data or .detach().\n"
     "If your intent is to change the metadata of a Tensor (such as sizes / strides / storage / storage_offset)\n"
     "without autograd tracking the change, remove the .data / .detach() call and wrap the change in a `with torch.no_grad():` block.\n"
@@ -32,7 +32,8 @@ const char * const TensorImpl::err_msg_tensor_metadata_change_not_allowed =
     "        x.set_(y)";
 
 at::Tensor& TensorImpl::mutable_grad() {
-  if (!autograd_meta_) autograd_meta_ = impl::GetAutogradMetaFactory()->make();
+  if (!autograd_meta_)
+    autograd_meta_ = impl::GetAutogradMetaFactory()->make();
   return autograd_meta_->mutable_grad();
 }
 
@@ -43,18 +44,26 @@ const at::Tensor& TensorImpl::grad() const {
   // is not so easy to fix right now because the mutable counterpart of
   // this function must keep working so that "x.grad() = ..." keeps working
   // (part of public API).
-  if (!autograd_meta_) return impl::GetAutogradMetaFactory()->undefined_tensor();
+  if (!autograd_meta_)
+    return impl::GetAutogradMetaFactory()->undefined_tensor();
   return autograd_meta_->grad();
 }
 
-const at::Tensor& TensorImpl::_fw_grad(uint64_t level, const at::Tensor& self) const {
+const at::Tensor& TensorImpl::_fw_grad(uint64_t level, const at::Tensor& self)
+    const {
   // See TensorImpl::grad() above for explanation about the line below
-  if (!autograd_meta_) return impl::GetAutogradMetaFactory()->undefined_tensor();
+  if (!autograd_meta_)
+    return impl::GetAutogradMetaFactory()->undefined_tensor();
   return autograd_meta_->fw_grad(level, self);
 }
 
-void TensorImpl::_set_fw_grad(const at::Tensor& new_grad, const at::Tensor& self, uint64_t level, bool is_inplace_op) {
-  if (!autograd_meta_) autograd_meta_ = impl::GetAutogradMetaFactory()->make();
+void TensorImpl::_set_fw_grad(
+    const at::Tensor& new_grad,
+    const at::Tensor& self,
+    uint64_t level,
+    bool is_inplace_op) {
+  if (!autograd_meta_)
+    autograd_meta_ = impl::GetAutogradMetaFactory()->make();
   autograd_meta_->set_fw_grad(new_grad, self, level, is_inplace_op);
 }
 
@@ -63,7 +72,11 @@ TensorImpl::TensorImpl(
     DispatchKeySet key_set,
     const caffe2::TypeMeta data_type)
     // Use std::forward to suppress static analyzer false positive.
-    : TensorImpl(std::forward<Storage>(storage), key_set, data_type, storage.device()) {}
+    : TensorImpl(
+          std::forward<Storage>(storage),
+          key_set,
+          data_type,
+          storage.device()) {}
 
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 TensorImpl::TensorImpl(
@@ -84,23 +97,29 @@ TensorImpl::TensorImpl(
   }
 }
 
-TensorImpl::TensorImpl(DispatchKeySet key_set, const caffe2::TypeMeta data_type, c10::optional<c10::Device> device_opt)
+TensorImpl::TensorImpl(
+    DispatchKeySet key_set,
+    const caffe2::TypeMeta data_type,
+    c10::optional<c10::Device> device_opt)
     // NOLINTNEXTLINE(performance-move-const-arg)
     : TensorImpl({}, key_set, data_type, std::move(device_opt)) {}
 
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-TensorImpl::TensorImpl(Storage&& storage, DispatchKeySet key_set, const caffe2::TypeMeta data_type,
-                       c10::optional<c10::Device> device_opt)
+TensorImpl::TensorImpl(
+    Storage&& storage,
+    DispatchKeySet key_set,
+    const caffe2::TypeMeta data_type,
+    c10::optional<c10::Device> device_opt)
     : storage_(std::move(storage)),
       storage_offset_(0),
       numel_(0),
       data_type_(data_type),
       device_opt_(device_opt) {
-
   init_bitfields();
 
   if (!key_set.empty()) {
-    TORCH_INTERNAL_ASSERT(data_type == ScalarType::Undefined || device_opt_.has_value());
+    TORCH_INTERNAL_ASSERT(
+        data_type == ScalarType::Undefined || device_opt_.has_value());
     // UndefinedTensorImpl is a singleton, so we skip logging it
     C10_LOG_API_USAGE_ONCE("tensor.create");
   }
@@ -115,12 +134,13 @@ TensorImpl::TensorImpl(Storage&& storage, DispatchKeySet key_set, const caffe2::
 
   // Inference tensor doesn't have autograd related keys.
   if (inference_mode) {
-    // See Note [Expected TLS state in InferenceMode] for why we exclude Autograd & InplaceOrView keys.
-    // Normally key_set only contains backend keys but we do the substraction
-    // here to make sure.
+    // See Note [Expected TLS state in InferenceMode] for why we exclude
+    // Autograd & InplaceOrView keys. Normally key_set only contains backend
+    // keys but we do the substraction here to make sure.
     key_set_ = key_set - c10::autograd_dispatch_keyset_with_InplaceOrView;
   } else {
-    // TODO: Ideally we only add AutogradBackend key when the tensor requires grad.
+    // TODO: Ideally we only add AutogradBackend key when the tensor requires
+    // grad.
     //       See Note [Dream: skip VariableType kernel when requires_grad=false]
     key_set_ = key_set | getAutogradRelatedKeySetFromBackend(k);
   }
@@ -130,8 +150,8 @@ TensorImpl::TensorImpl(Storage&& storage, DispatchKeySet key_set, const caffe2::
     version_counter_ = VariableVersion(/*version=*/0);
   }
 
-  // we would also like to check that non-cpu devices have an index, but some Caffe2 operators create
-  // Storages with default devices.
+  // we would also like to check that non-cpu devices have an index, but some
+  // Caffe2 operators create Storages with default devices.
 }
 
 #ifndef C10_DISABLE_TENSORIMPL_EXTENSIBILITY
@@ -151,15 +171,14 @@ void TensorImpl::HandleResize() {
   if (reserved_) {
     // If tensor is reserved then don't claim its memeory unless nbytes()
     // is smaller than new size
-    reset_tensor = storage_.nbytes() <
-      (storage_offset_ + numel_) * data_type_.itemsize();
+    reset_tensor =
+        storage_.nbytes() < (storage_offset_ + numel_) * data_type_.itemsize();
   } else {
     reset_tensor = storage_.nbytes() <
-      (storage_offset_ + numel_) * data_type_.itemsize() ||
-      !FLAGS_caffe2_keep_on_shrink ||
-      storage_.nbytes() -
-      (storage_offset_ + numel_) * data_type_.itemsize() >
-      static_cast<size_t>(FLAGS_caffe2_max_keep_on_shrink_memory);
+            (storage_offset_ + numel_) * data_type_.itemsize() ||
+        !FLAGS_caffe2_keep_on_shrink ||
+        storage_.nbytes() - (storage_offset_ + numel_) * data_type_.itemsize() >
+            static_cast<size_t>(FLAGS_caffe2_max_keep_on_shrink_memory);
   }
 
   if (reset_tensor && storage_initialized()) {
@@ -190,20 +209,19 @@ bool TensorImpl::compute_channels_last_contiguous_2d() const {
   // Please don't combine these code, constant array is used here to let
   // compiler fully unroll the loop to get better performance
   switch (sizes_and_strides_.size()) {
-    case 4:
-      {
-        int64_t expected = 1;
-        for (auto& d : {1, 3, 2, 0}) {
-          const auto size_d = sizes_and_strides_.size_at_unchecked(d);
-          if (size_d != 1) {
-            if (sizes_and_strides_.stride_at_unchecked(d) != expected) {
-              return false;
-            }
-            expected *= size_d;
+    case 4: {
+      int64_t expected = 1;
+      for (auto& d : {1, 3, 2, 0}) {
+        const auto size_d = sizes_and_strides_.size_at_unchecked(d);
+        if (size_d != 1) {
+          if (sizes_and_strides_.stride_at_unchecked(d) != expected) {
+            return false;
           }
+          expected *= size_d;
         }
-        return true;
       }
+      return true;
+    }
     // NOLINTNEXTLINE(bugprone-branch-clone)
     case 3:
       // TODO dim == 3 case will be enabled once it is fully tested
@@ -218,20 +236,19 @@ bool TensorImpl::compute_channels_last_contiguous_3d() const {
   // compiler fully unroll the loop to get better performance
   switch (sizes_and_strides_.size()) {
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    case 5:
-      {
-        int64_t expected = 1;
-        for (auto& d : {1, 4, 3, 2, 0}) {
-          const auto size_d = sizes_and_strides_.size_at_unchecked(d);
-          if (size_d != 1) {
-            if (sizes_and_strides_.stride_at_unchecked(d) != expected) {
-              return false;
-            }
-            expected *= size_d;
+    case 5: {
+      int64_t expected = 1;
+      for (auto& d : {1, 4, 3, 2, 0}) {
+        const auto size_d = sizes_and_strides_.size_at_unchecked(d);
+        if (size_d != 1) {
+          if (sizes_and_strides_.stride_at_unchecked(d) != expected) {
+            return false;
           }
+          expected *= size_d;
         }
-        return true;
       }
+      return true;
+    }
     // NOLINTNEXTLINE(bugprone-branch-clone)
     case 4:
       // TODO dim == 4 case will be enabled once it is fully tested
@@ -242,34 +259,38 @@ bool TensorImpl::compute_channels_last_contiguous_3d() const {
 }
 
 bool TensorImpl::compute_strides_like_channels_last_2d() const {
-  return is_channels_last_strides_2d(TensorImpl::sizes(), TensorImpl::strides());
+  return is_channels_last_strides_2d(
+      TensorImpl::sizes(), TensorImpl::strides());
 }
 
 bool TensorImpl::compute_strides_like_channels_last_3d() const {
-  return is_channels_last_strides_3d(TensorImpl::sizes(), TensorImpl::strides());
+  return is_channels_last_strides_3d(
+      TensorImpl::sizes(), TensorImpl::strides());
 }
 
 bool TensorImpl::compute_non_overlapping_and_dense() const {
   if (dim() == 1) {
-    return sizes_and_strides_.size_at_unchecked(0) < 2 || sizes_and_strides_.stride_at_unchecked(0) == 1;
+    return sizes_and_strides_.size_at_unchecked(0) < 2 ||
+        sizes_and_strides_.stride_at_unchecked(0) == 1;
   }
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-  SmallVector<int64_t,5> perm;
+  SmallVector<int64_t, 5> perm;
   perm.resize(dim());
-  for (int64_t i = 0; i < dim(); i ++) {
+  for (int64_t i = 0; i < dim(); i++) {
     perm[i] = i;
   }
   // Sort by strides, leaving 0 and 1 sized dims at the end of the array
   std::sort(perm.begin(), perm.end(), [&](int64_t a, int64_t b) {
-      if (sizes_and_strides_.size_at_unchecked(a) < 2) {
-        return false;
-      } else if (sizes_and_strides_.size_at_unchecked(b) < 2) {
-        return true;
-      }
-      return sizes_and_strides_.stride_at_unchecked(a) < sizes_and_strides_.stride_at_unchecked(b);
+    if (sizes_and_strides_.size_at_unchecked(a) < 2) {
+      return false;
+    } else if (sizes_and_strides_.size_at_unchecked(b) < 2) {
+      return true;
+    }
+    return sizes_and_strides_.stride_at_unchecked(a) <
+        sizes_and_strides_.stride_at_unchecked(b);
   });
   auto require_stride = 1;
-  for (int64_t i = 0; i < dim(); i ++) {
+  for (int64_t i = 0; i < dim(); i++) {
     const auto size_perm_i = sizes_and_strides_.size_at_unchecked(perm[i]);
     if (size_perm_i < 2) {
       return true;
@@ -312,16 +333,23 @@ bool TensorImpl::has_storage() const {
 #endif
 
 void TensorImpl::throw_storage_access_error() const {
-  TORCH_CHECK_NOT_IMPLEMENTED(false, "Cannot access storage of ", tensorimpl_type_name());
+  TORCH_CHECK_NOT_IMPLEMENTED(
+      false, "Cannot access storage of ", tensorimpl_type_name());
 }
 
-bool TensorImpl::is_contiguous_nondefault_policy_impl(at::MemoryFormat memory_format) const {
-  if (has_contiguity_ == static_cast<uint8_t>(HasContiguityPolicy::ContiguityNotSupported)) {
+bool TensorImpl::is_contiguous_nondefault_policy_impl(
+    at::MemoryFormat memory_format) const {
+  if (has_contiguity_ ==
+      static_cast<uint8_t>(HasContiguityPolicy::ContiguityNotSupported)) {
     TORCH_CHECK_NOT_IMPLEMENTED(
-        false, "Tensors of type ", tensorimpl_type_name(),
+        false,
+        "Tensors of type ",
+        tensorimpl_type_name(),
         " do not have is_contiguous");
   } else {
-    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(has_contiguity_ == static_cast<uint8_t>(HasContiguityPolicy::CustomBehavior));
+    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+        has_contiguity_ ==
+        static_cast<uint8_t>(HasContiguityPolicy::CustomBehavior));
     return is_contiguous_custom(memory_format);
   }
 }
@@ -343,10 +371,11 @@ at::DataPtr PlacementDeleteContext::makeDataPtr(
     size_t size,
     at::Device device) {
   auto* ptr = data_ptr.get();
-  return {ptr,
-          new PlacementDeleteContext(std::move(data_ptr), placement_dtor, size),
-          &deletePlacementDeleteContext,
-          device};
+  return {
+      ptr,
+      new PlacementDeleteContext(std::move(data_ptr), placement_dtor, size),
+      &deletePlacementDeleteContext,
+      device};
 }
 
 // NOLINTNEXTLINE(modernize-use-equals-default)
@@ -359,10 +388,14 @@ AutogradMetaInterface::~AutogradMetaInterface() {}
 // used in C++ frontend. Forbidding it inside InferenceMode will force users
 // to delete these setter code in their code which is not ideal.
 void TensorImpl::set_requires_grad(bool requires_grad) {
-  TORCH_CHECK(!(requires_grad && is_inference_tensor() && !c10::InferenceMode::is_enabled()),
-    "Setting requires_grad=True on inference tensor outside InferenceMode is not allowed.");
-  if (!requires_grad && !autograd_meta_) return;
-  if (!autograd_meta_) autograd_meta_ = impl::GetAutogradMetaFactory()->make();
+  TORCH_CHECK(
+      !(requires_grad && is_inference_tensor() &&
+        !c10::InferenceMode::is_enabled()),
+      "Setting requires_grad=True on inference tensor outside InferenceMode is not allowed.");
+  if (!requires_grad && !autograd_meta_)
+    return;
+  if (!autograd_meta_)
+    autograd_meta_ = impl::GetAutogradMetaFactory()->make();
   // NB: In principle, setting requires_grad to false could result in
   // the AutogradMeta becoming equal to a default constructed state,
   // in which case we could apply the nullptr AutogradMeta optimization
@@ -376,11 +409,13 @@ void TensorImpl::set_requires_grad(bool requires_grad) {
 }
 
 bool TensorImpl::requires_grad() const {
-  if (!autograd_meta_) return false;
+  if (!autograd_meta_)
+    return false;
   return autograd_meta_->requires_grad();
 }
 
-void TensorImpl::set_autograd_meta(std::unique_ptr<c10::AutogradMetaInterface> autograd_meta) {
+void TensorImpl::set_autograd_meta(
+    std::unique_ptr<c10::AutogradMetaInterface> autograd_meta) {
   // NB: autograd_meta may be null!  That just means it's the default
   // constructor
   autograd_meta_ = std::move(autograd_meta);
@@ -396,7 +431,9 @@ c10::intrusive_ptr<TensorImpl> TensorImpl::shallow_copy_and_detach(
     bool allow_tensor_metadata_change) const {
   auto impl = c10::make_intrusive<TensorImpl>(
       // No need to populate Storage; copy_tensor_metadata will do it for us.
-      key_set_, data_type_, device_opt_);
+      key_set_,
+      data_type_,
+      device_opt_);
   copy_tensor_metadata(
       /*src_impl=*/this,
       /*dest_impl=*/impl.get(),
@@ -412,7 +449,9 @@ c10::intrusive_ptr<TensorImpl> TensorImpl::shallow_copy_and_detach(
     bool allow_tensor_metadata_change) const {
   auto impl = c10::make_intrusive<TensorImpl>(
       // No need to populate Storage; copy_tensor_metadata will do it for us.
-      key_set_, data_type_, device_opt_);
+      key_set_,
+      data_type_,
+      device_opt_);
   copy_tensor_metadata(
       /*src_impl=*/this,
       /*dest_impl=*/impl.get(),
@@ -435,15 +474,19 @@ void TensorImpl::copy_tensor_metadata_except_version_counter(
   dest_impl->key_set_ = src_impl->key_set_;
   dest_impl->is_contiguous_ = src_impl->is_contiguous_;
   dest_impl->has_contiguity_ = src_impl->has_contiguity_;
-  dest_impl->is_channels_last_contiguous_ = src_impl->is_channels_last_contiguous_;
-  dest_impl->is_channels_last_3d_contiguous_ = src_impl->is_channels_last_3d_contiguous_;
+  dest_impl->is_channels_last_contiguous_ =
+      src_impl->is_channels_last_contiguous_;
+  dest_impl->is_channels_last_3d_contiguous_ =
+      src_impl->is_channels_last_3d_contiguous_;
   dest_impl->is_channels_last_ = src_impl->is_channels_last_;
   dest_impl->is_channels_last_3d_ = src_impl->is_channels_last_3d_;
-  dest_impl->is_non_overlapping_and_dense_ = src_impl->is_non_overlapping_and_dense_;
+  dest_impl->is_non_overlapping_and_dense_ =
+      src_impl->is_non_overlapping_and_dense_;
   dest_impl->is_wrapped_number_ = src_impl->is_wrapped_number_;
   dest_impl->reserved_ = src_impl->reserved_;
   dest_impl->set_allow_tensor_metadata_change(allow_tensor_metadata_change);
-  dest_impl->storage_access_should_throw_ = src_impl->storage_access_should_throw_;
+  dest_impl->storage_access_should_throw_ =
+      src_impl->storage_access_should_throw_;
   if (src_impl->named_tensor_meta_ != nullptr) {
     dest_impl->named_tensor_meta_ = src_impl->named_tensor_meta_->clone();
   }
@@ -454,9 +497,11 @@ void TensorImpl::copy_tensor_metadata(
     TensorImpl* dest_impl,
     const c10::VariableVersion& version_counter,
     bool allow_tensor_metadata_change) {
-  copy_tensor_metadata_except_version_counter(src_impl, dest_impl, allow_tensor_metadata_change);
+  copy_tensor_metadata_except_version_counter(
+      src_impl, dest_impl, allow_tensor_metadata_change);
   // TODO: In the ideal end state, it's okay to set disabled version_counter
-  // on inference tensor since it's a no-op. This requires refactor on call sites.
+  // on inference tensor since it's a no-op. This requires refactor on call
+  // sites.
   if (!dest_impl->is_inference_tensor()) {
     dest_impl->set_version_counter(version_counter);
   }
@@ -467,7 +512,8 @@ void TensorImpl::copy_tensor_metadata(
     TensorImpl* dest_impl,
     c10::VariableVersion&& version_counter,
     bool allow_tensor_metadata_change) {
-  copy_tensor_metadata_except_version_counter(src_impl, dest_impl, allow_tensor_metadata_change);
+  copy_tensor_metadata_except_version_counter(
+      src_impl, dest_impl, allow_tensor_metadata_change);
   if (!dest_impl->is_inference_tensor()) {
     dest_impl->set_version_counter(std::move(version_counter));
   }
@@ -478,13 +524,15 @@ namespace impl {
 namespace {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 AutogradMetaFactory* meta_factory = nullptr;
-}
+} // namespace
 
 void SetAutogradMetaFactory(AutogradMetaFactory* factory) {
   meta_factory = factory;
 }
 AutogradMetaFactory* GetAutogradMetaFactory() {
-  TORCH_CHECK(meta_factory, "Support for autograd has not been loaded; have you linked against libtorch.so?")
+  TORCH_CHECK(
+      meta_factory,
+      "Support for autograd has not been loaded; have you linked against libtorch.so?")
   return meta_factory;
 }
 
diff --git a/c10/core/TensorImpl.h b/c10/core/TensorImpl.h
index 3eeb1efcb1e..b9e704d85ab 100644
--- a/c10/core/TensorImpl.h
+++ b/c10/core/TensorImpl.h
@@ -8,17 +8,17 @@
 #include <c10/core/Backend.h>
 #include <c10/core/CopyBytes.h>
 #include <c10/core/DispatchKeySet.h>
-#include <c10/core/impl/LocalDispatchKeySet.h>
-#include <c10/core/impl/SizesAndStrides.h>
 #include <c10/core/InferenceMode.h>
 #include <c10/core/MemoryFormat.h>
 #include <c10/core/Storage.h>
 #include <c10/core/TensorOptions.h>
-#include <c10/util/accumulate.h>
+#include <c10/core/impl/LocalDispatchKeySet.h>
+#include <c10/core/impl/SizesAndStrides.h>
 #include <c10/util/Exception.h>
 #include <c10/util/Flags.h>
 #include <c10/util/Logging.h>
 #include <c10/util/Optional.h>
+#include <c10/util/accumulate.h>
 #include <c10/util/python_stub.h>
 
 // A global boolean variable to control whether we free memory when a Tensor
@@ -36,7 +36,6 @@ C10_DECLARE_bool(caffe2_keep_on_shrink);
 // respect caffe2_keep_on_shrink.
 C10_DECLARE_int64(caffe2_max_keep_on_shrink_memory);
 
-
 namespace at {
 class Tensor;
 }
@@ -135,12 +134,19 @@ struct C10_API PlacementDeleteContext {
 struct TensorImpl;
 
 struct C10_API AutogradMetaInterface {
-  virtual void set_requires_grad(bool requires_grad, at::TensorImpl* self_impl) = 0;
+  virtual void set_requires_grad(
+      bool requires_grad,
+      at::TensorImpl* self_impl) = 0;
   virtual bool requires_grad() const = 0;
   virtual at::Tensor& mutable_grad() = 0;
   virtual const at::Tensor& grad() const = 0;
-  virtual const at::Tensor& fw_grad(uint64_t level, const at::Tensor& self) const = 0;
-  virtual void set_fw_grad(const at::Tensor& new_grad, const at::Tensor& self, uint64_t level, bool is_inplace_op) = 0;
+  virtual const at::Tensor& fw_grad(uint64_t level, const at::Tensor& self)
+      const = 0;
+  virtual void set_fw_grad(
+      const at::Tensor& new_grad,
+      const at::Tensor& self,
+      uint64_t level,
+      bool is_inplace_op) = 0;
   virtual ~AutogradMetaInterface();
 };
 
@@ -172,25 +178,24 @@ struct C10_API AutogradMetaFactoryRegisterer {
 } // namespace impl
 
 struct C10_API NamedTensorMetaInterface {
-  virtual ~NamedTensorMetaInterface() {};
+  virtual ~NamedTensorMetaInterface(){};
   virtual std::unique_ptr<NamedTensorMetaInterface> clone() const {
     TORCH_INTERNAL_ASSERT(
-      false,
-      "Not implemented: NamedTensorMetaInterface::clone");
+        false, "Not implemented: NamedTensorMetaInterface::clone");
   };
   virtual int64_t slow_dim() const {
     TORCH_INTERNAL_ASSERT(
-      false,
-      "Not implemented: NamedTensorMetaInterface::slow_dim");
+        false, "Not implemented: NamedTensorMetaInterface::slow_dim");
   };
 };
 
 // NOTE [ Version Counter Sharing ]
 //
-// Every Tensor has a version counter. Version counters are incremented whenever the
-// data or size of a tensor changes through in-place Variable operations. Version
-// counters are used to detect modifications to saved variables which would result in
-// incorrect gradient calculations. Version counters may be shared between Variables:
+// Every Tensor has a version counter. Version counters are incremented whenever
+// the data or size of a tensor changes through in-place Variable operations.
+// Version counters are used to detect modifications to saved variables which
+// would result in incorrect gradient calculations. Version counters may be
+// shared between Variables:
 //
 // 1. A view shares the version counter of the base Variable,
 // 2. `x.detach()` shares the version counter of `x`,
@@ -198,27 +203,32 @@ struct C10_API NamedTensorMetaInterface {
 //
 // Version counters are not shared in these scenarios:
 //
-// 1. When we replace a `Variable`'s underlying `Tensor` by calling `set_data(...)`,
+// 1. When we replace a `Variable`'s underlying `Tensor` by calling
+// `set_data(...)`,
 // 2. `x.data` does not share the version counter of `x`. (See discussion at
 // https://github.com/pytorch/pytorch/issues/5396)
 //
-// Question: Why do we put the version counter in TensorImpl instead of AutogradMeta?
+// Question: Why do we put the version counter in TensorImpl instead of
+// AutogradMeta?
 //
-// Answer: After the Variable/Tensor merge, a tensor will not have AutogradMeta when
-// its `requires_grad_` is false, but when we use this tensor in the forward pass of
-// a function that requires saving this tensor for backward, we need to keep track of
-// this tensor's version to make sure it's always valid in the autograd graph.
+// Answer: After the Variable/Tensor merge, a tensor will not have AutogradMeta
+// when its `requires_grad_` is false, but when we use this tensor in the
+// forward pass of a function that requires saving this tensor for backward, we
+// need to keep track of this tensor's version to make sure it's always valid in
+// the autograd graph.
 //
-// To achieve this goal, we put the version counter in TensorImpl instead of AutogradMeta,
-// and have it always be available. This allows us to have the optimization of not
-// carrying AutogradMeta when a tensor doesn't require gradient.
+// To achieve this goal, we put the version counter in TensorImpl instead of
+// AutogradMeta, and have it always be available. This allows us to have the
+// optimization of not carrying AutogradMeta when a tensor doesn't require
+// gradient.
 //
-// A hypothetical alternative way to achieve this goal is to initialize AutogradMeta and
-// create the version counter for the non-requires-grad tensor only when it's saved for
-// backward. However, since saving a tensor for backward happens in the forward pass, and
-// our invariant is that forward pass needs to be thread-safe, lazy-initializing AutogradMeta
-// when saving a tensor can introduce race conditions when we are running the forward
-// pass in multi-thread scenarios, thus making the forward pass not thread-safe anymore,
+// A hypothetical alternative way to achieve this goal is to initialize
+// AutogradMeta and create the version counter for the non-requires-grad tensor
+// only when it's saved for backward. However, since saving a tensor for
+// backward happens in the forward pass, and our invariant is that forward pass
+// needs to be thread-safe, lazy-initializing AutogradMeta when saving a tensor
+// can introduce race conditions when we are running the forward pass in
+// multi-thread scenarios, thus making the forward pass not thread-safe anymore,
 // which breaks the invariant.
 struct C10_API VariableVersion {
  private:
@@ -238,7 +248,8 @@ struct C10_API VariableVersion {
   // Example use cases are:
   //  - Inference tensors don't track version counter, so they'll just always
   //    have disbaled VariableVersion.
-  //  - In SavedVariable class we override version_counter_ inside its construtor
+  //  - In SavedVariable class we override version_counter_ inside its
+  //  construtor
   //    so that we can use the cheap constructor there.
   enum Disabled { DISABLED };
   // It's okay to return true even for inference tensor which
@@ -254,7 +265,7 @@ struct C10_API VariableVersion {
   // https://cplusplus.github.io/LWG/issue2334.
   VariableVersion(uint32_t version)
       : version_counter_(c10::make_intrusive<VersionCounter>(version)) {}
-  VariableVersion(Disabled=DISABLED) {}
+  VariableVersion(Disabled = DISABLED) {}
 
   bool enabled() const {
     return version_counter_;
@@ -283,10 +294,11 @@ struct C10_API VariableVersion {
   //      - e.g. inference_tensor.add_(normal_tensor)
   void bump() {
     // TODO: Replace the link to the documentation once it's available.
-    TORCH_CHECK(version_counter_ || InferenceMode::is_enabled(),
-      "Inplace update to inference tensor outside InferenceMode is not allowed."
-      "You can make a clone to get a normal tensor before doing inplace update."
-      "See https://github.com/pytorch/rfcs/pull/17 for more details.");
+    TORCH_CHECK(
+        version_counter_ || InferenceMode::is_enabled(),
+        "Inplace update to inference tensor outside InferenceMode is not allowed."
+        "You can make a clone to get a normal tensor before doing inplace update."
+        "See https://github.com/pytorch/rfcs/pull/17 for more details.");
     if (version_counter_) {
       ++version_counter_->version_;
     }
@@ -295,7 +307,8 @@ struct C10_API VariableVersion {
   // Inference tensor doesn't have version counter so it shouldn't be
   // accessed.
   uint32_t current_version() const {
-    TORCH_CHECK(version_counter_, "Inference tensor do not track version counter.");
+    TORCH_CHECK(
+        version_counter_, "Inference tensor do not track version counter.");
     return version_counter_->version_;
   }
 };
@@ -414,7 +427,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   /**
    * Construct a 1-dim 0 size tensor that doesn't have a storage.
    */
-  TensorImpl(DispatchKeySet, const caffe2::TypeMeta data_type, c10::optional<c10::Device> device_opt);
+  TensorImpl(
+      DispatchKeySet,
+      const caffe2::TypeMeta data_type,
+      c10::optional<c10::Device> device_opt);
 
   // Legacy constructors so I don't have to go update call sites.
   // TODO: When Variable is added, delete these constructors
@@ -426,15 +442,22 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
             std::move(storage),
             DispatchKeySet(dispatch_key),
             data_type) {}
-  TensorImpl(DispatchKey dispatch_key, const caffe2::TypeMeta data_type, c10::optional<c10::Device> device_opt)
-    : TensorImpl(DispatchKeySet(dispatch_key), data_type, device_opt) {}
+  TensorImpl(
+      DispatchKey dispatch_key,
+      const caffe2::TypeMeta data_type,
+      c10::optional<c10::Device> device_opt)
+      : TensorImpl(DispatchKeySet(dispatch_key), data_type, device_opt) {}
 
  private:
   // This constructor is private, because the data_type is redundant with
   // storage.  Still, we pass it in separately because it's easier to write
   // the initializer list if we're not worried about storage being moved out
   // from under us.
-  TensorImpl(Storage&& storage, DispatchKeySet, const caffe2::TypeMeta data_type, c10::optional<c10::Device>);
+  TensorImpl(
+      Storage&& storage,
+      DispatchKeySet,
+      const caffe2::TypeMeta data_type,
+      c10::optional<c10::Device>);
 
  public:
   TensorImpl(const TensorImpl&) = delete;
@@ -454,7 +477,9 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * all of the DispatchKeys that this Tensor identifies as.  This is the
    * information used to dispatch operations on this tensor.
    */
-  DispatchKeySet key_set() const { return key_set_; }
+  DispatchKeySet key_set() const {
+    return key_set_;
+  }
 
   /**
    * Return a reference to the sizes of this tensor.  This reference remains
@@ -466,7 +491,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return sizes_and_strides_.sizes_arrayref();
   }
 #else
-  ;
+      ;
 #endif
 
   /**
@@ -485,19 +510,21 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return sizes_and_strides_.size();
   }
 #else
-  ;
+      ;
 #endif
 
   /**
    * True if this tensor has storage. See storage() for details.
    */
 #ifdef DEBUG
-// Allow subclasses to check that their storage_ is never getting set in debug builds.
+  // Allow subclasses to check that their storage_ is never getting set in debug
+  // builds.
   virtual
 #else
   TENSORIMPL_MAYBE_VIRTUAL
 #endif
-  bool has_storage() const
+      bool
+      has_storage() const
   // NOTE: we devirtualize this because it arguably shouldn't be an
   // error just to ask subclasses if they have storage.
   // This used to throw for most subclasses, but OpaqueTensorImpl
@@ -508,7 +535,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return storage_;
   }
 #else
-  ;
+      ;
 #endif
 
   /**
@@ -556,15 +583,17 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * backward compatibility. See `set_has_contiguity_policy` and
    * `is_contiguous_custom` for the encouraged customization point.
    */
-  TENSORIMPL_MAYBE_VIRTUAL bool is_contiguous(at::MemoryFormat memory_format=at::MemoryFormat::Contiguous) const {
-    if (C10_UNLIKELY(has_contiguity_ != static_cast<uint8_t>(HasContiguityPolicy::Default))) {
+  TENSORIMPL_MAYBE_VIRTUAL bool is_contiguous(
+      at::MemoryFormat memory_format = at::MemoryFormat::Contiguous) const {
+    if (C10_UNLIKELY(
+            has_contiguity_ !=
+            static_cast<uint8_t>(HasContiguityPolicy::Default))) {
       return is_contiguous_nondefault_policy_impl(memory_format);
     }
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(compute_contiguous() == is_contiguous_);
     if (memory_format == at::MemoryFormat::ChannelsLast) {
       return is_channels_last_contiguous_;
-    }
-    else if (memory_format == at::MemoryFormat::ChannelsLast3d) {
+    } else if (memory_format == at::MemoryFormat::ChannelsLast3d) {
       return is_channels_last_3d_contiguous_;
     }
     return is_contiguous_;
@@ -583,33 +612,38 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
 
  public:
   bool is_sparse() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::SparseCPU) ||
         key_set_.has(DispatchKey::SparseCUDA) ||
         key_set_.has(DispatchKey::SparseHIP) ||
         key_set_.has(DispatchKey::SparseXPU);
   }
 
-  // Whether a tensor is sparse COO or not. Use is_sparse_csr for checking CSR format.
+  // Whether a tensor is sparse COO or not. Use is_sparse_csr for checking CSR
+  // format.
   bool is_sparse_csr() const {
     return key_set_.has(DispatchKey::SparseCsrCPU) ||
-           key_set_.has(DispatchKey::SparseCsrCUDA);
+        key_set_.has(DispatchKey::SparseCsrCUDA);
   }
 
   bool is_quantized() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::QuantizedCPU) ||
         key_set_.has(DispatchKey::QuantizedCUDA) ||
         key_set_.has(DispatchKey::QuantizedXPU);
   }
 
   bool is_meta() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::Meta);
   }
 
   bool is_cpu() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::CPU) ||
         key_set_.has(DispatchKey::SparseCPU) ||
         key_set_.has(DispatchKey::SparseCsrCPU) ||
@@ -618,7 +652,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   }
 
   bool is_cuda() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::CUDA) ||
         key_set_.has(DispatchKey::SparseCUDA) ||
         key_set_.has(DispatchKey::SparseCsrCUDA) ||
@@ -638,9 +673,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   }
 
   bool is_hip() const {
-    // NB: This method is not virtual and avoid dispatches for performance reasons.
+    // NB: This method is not virtual and avoid dispatches for performance
+    // reasons.
     return key_set_.has(DispatchKey::HIP) ||
-           key_set_.has(DispatchKey::SparseHIP);
+        key_set_.has(DispatchKey::SparseHIP);
   }
 
   bool is_mkldnn() const {
@@ -659,7 +695,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return key_set_.has(DispatchKey::MLC);
   }
 
-  // TODO: remove this once we don't automatically enabled Autograd dispatch keys
+  // TODO: remove this once we don't automatically enabled Autograd dispatch
+  // keys
   //       in TensorImpl constructor.
   // DON'T USE THIS API!! It's only created for testing purpose in
   // file aten/src/ATen/core/boxing/impl/test_helpers.h
@@ -673,23 +710,20 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   bool is_inference_tensor() {
     bool no_InplaceOrView = !key_set_.has(c10::DispatchKey::InplaceOrView);
     bool no_Autograd = (key_set_ & c10::autograd_dispatch_keyset).empty();
-    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(no_InplaceOrView == no_Autograd,
-      "InplaceOrView and Autograd keys must be on/off at the same time.");
+    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+        no_InplaceOrView == no_Autograd,
+        "InplaceOrView and Autograd keys must be on/off at the same time.");
     return no_InplaceOrView && no_Autograd;
   }
 
   int64_t get_device() const {
-    TORCH_CHECK(
-        device_opt_.has_value(),
-        "tensor does not have a device");
+    TORCH_CHECK(device_opt_.has_value(), "tensor does not have a device");
     // See NOTE [c10::optional operator usage in CUDA]
     return (*device_opt_).index();
   }
 
   Device device() const {
-    TORCH_CHECK(
-        device_opt_.has_value(),
-        "tensor does not have a device");
+    TORCH_CHECK(device_opt_.has_value(), "tensor does not have a device");
     // See NOTE [c10::optional operator usage in CUDA]
     return *device_opt_;
   }
@@ -795,9 +829,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    *   - "level" allows to specify the level of forward AD nesting for which the
    *     gradient should be returned. Note that since levels are not fully
    *     supported yet, this argument should be 0. See documentation for
-   *     torch::autograd::enter_dual_level for more details about forward AD nesting.
-   *   - "self" should represent the Tensor whose forward grad is accessed. It is
-   *     required when dealing with view.
+   *     torch::autograd::enter_dual_level for more details about forward AD
+   * nesting.
+   *   - "self" should represent the Tensor whose forward grad is accessed. It
+   * is required when dealing with view.
    */
   const at::Tensor& _fw_grad(uint64_t level, const at::Tensor& self) const;
 
@@ -808,18 +843,24 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * This is an internal API that should never be used by end users.
    *
    * The API is as follows:
-   *   - "new_grad" is a Tensor containing the new value of the gradient that should
-   *     be set
-   *   - "self" should represent the Tensor whose forward grad is accessed. It is
-   *     required when dealing with view.
+   *   - "new_grad" is a Tensor containing the new value of the gradient that
+   * should be set
+   *   - "self" should represent the Tensor whose forward grad is accessed. It
+   * is required when dealing with view.
    *   - "level" allows to specify the level of forward AD nesting for which the
    *     gradient should be set. Note that since levels are not fully supported
-   *     yet, this argument should be 0. See documentation for torch::autograd::enter_dual_level
-   *     for more details about forward AD nesting.
-   *   - "is_inplace_op" is a boolean flag that tells if this gradient was generated
-   *     by an inplace operation or an out of place one. This allows better error checking.
+   *     yet, this argument should be 0. See documentation for
+   * torch::autograd::enter_dual_level for more details about forward AD
+   * nesting.
+   *   - "is_inplace_op" is a boolean flag that tells if this gradient was
+   * generated by an inplace operation or an out of place one. This allows
+   * better error checking.
    */
-  void _set_fw_grad(const at::Tensor& new_grad, const at::Tensor& self, uint64_t level, bool is_inplace_op);
+  void _set_fw_grad(
+      const at::Tensor& new_grad,
+      const at::Tensor& self,
+      uint64_t level,
+      bool is_inplace_op);
 
   /**
    * Return a typed data pointer to the actual data which this tensor refers to.
@@ -835,7 +876,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * for you; this class is available from 'Tensor'.
    */
   template <typename T>
-  inline T * data() const {
+  inline T* data() const {
     TORCH_CHECK(
         data_type_.Match<T>(),
         "Tensor type mismatch, caller expects elements to be ",
@@ -852,8 +893,9 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * check has_storage() and storage_initialized().
    */
   template <typename T>
-  inline T * data_ptr_impl() const {
-    TORCH_CHECK(has_storage(),
+  inline T* data_ptr_impl() const {
+    TORCH_CHECK(
+        has_storage(),
         "Cannot access data pointer of Tensor that doesn't have storage");
     TORCH_CHECK(
         storage_initialized(),
@@ -875,9 +917,11 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * can be validly read from this tensor.
    */
   inline void* data() const {
-    TORCH_CHECK(has_storage(),
+    TORCH_CHECK(
+        has_storage(),
         "Cannot access data pointer of Tensor that doesn't have storage");
-    TORCH_CHECK(dtype_initialized(),
+    TORCH_CHECK(
+        dtype_initialized(),
         "Cannot access data pointer of Tensor that doesn't have initialized dtype "
         "(e.g., caffe2::Tensor x(CPU), prior to calling mutable_data<T>() on x)");
     return static_cast<void*>(
@@ -890,7 +934,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * that all invariants required by data() are upheld here.
    */
   template <typename T>
-  inline T * unsafe_data() const {
+  inline T* unsafe_data() const {
     return storage_.unsafe_data<T>() + storage_offset_;
   }
 
@@ -906,7 +950,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * Return the size of a single element of this tensor in bytes.
    */
   size_t itemsize() const {
-    TORCH_CHECK(dtype_initialized(),
+    TORCH_CHECK(
+        dtype_initialized(),
         "Cannot report itemsize of Tensor that doesn't have initialized dtype "
         "(e.g., caffe2::Tensor x(CPU), prior to calling mutable_data<T>() on x)");
     return data_type_.itemsize();
@@ -952,7 +997,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * which is harder to misuse.
    */
   virtual void set_size(int64_t dim, int64_t new_size) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_size ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_size ",
+        err_msg_tensor_metadata_change_not_allowed);
     sizes_and_strides_.size_at(dim) = new_size;
     refresh_numel();
     refresh_contiguous();
@@ -965,7 +1013,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * which is harder to misuse.
    */
   virtual void set_stride(int64_t dim, int64_t new_stride) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_stride ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_stride ",
+        err_msg_tensor_metadata_change_not_allowed);
     sizes_and_strides_.stride_at_unchecked(dim) = new_stride;
     refresh_contiguous();
   }
@@ -978,7 +1029,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * (and resizing if necessary.)
    */
   virtual void set_storage_offset(int64_t storage_offset) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_storage_offset ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_storage_offset ",
+        err_msg_tensor_metadata_change_not_allowed);
     storage_offset_ = storage_offset;
   }
 
@@ -990,7 +1044,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * this is the responsibility of the caller
    */
   void set_sizes_contiguous(IntArrayRef new_size) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_sizes_contiguous ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_sizes_contiguous ",
+        err_msg_tensor_metadata_change_not_allowed);
 
     sizes_and_strides_.set_sizes(new_size);
 
@@ -1006,7 +1063,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * this is the responsibility of the caller
    */
   void set_sizes_and_strides(IntArrayRef new_size, IntArrayRef new_stride) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_sizes_and_strides ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_sizes_and_strides ",
+        err_msg_tensor_metadata_change_not_allowed);
     TORCH_CHECK(
         new_size.size() == new_stride.size(),
         "dimensionality of sizes (",
@@ -1019,7 +1079,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     sizes_and_strides_.set_sizes(new_size);
 
     if (new_dim > 0) {
-      for (size_t dim = new_dim - 1; ; dim--) {
+      for (size_t dim = new_dim - 1;; dim--) {
         if (new_stride[dim] >= 0) {
           sizes_and_strides_.stride_at_unchecked(dim) = new_stride[dim];
         } else {
@@ -1031,11 +1091,13 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
           } else {
             // Keep stride monotonically increasing to match NumPy.
             sizes_and_strides_.stride_at_unchecked(dim) =
-              std::max<int64_t>(sizes_and_strides_.size_at_unchecked(dim + 1), 1) *
-              sizes_and_strides_.stride_at_unchecked(dim + 1);
+                std::max<int64_t>(
+                    sizes_and_strides_.size_at_unchecked(dim + 1), 1) *
+                sizes_and_strides_.stride_at_unchecked(dim + 1);
           }
         }
-        if (dim == 0) break;
+        if (dim == 0)
+          break;
       }
     }
 
@@ -1054,16 +1116,18 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   virtual int64_t stride(int64_t d) const;
 
   /**
-   * Set whether a tensor allows changes to its metadata (e.g. sizes / strides / storage / storage_offset).
-   * See NOTE [ Metadata Change for a Detached Tensor ] for details.
+   * Set whether a tensor allows changes to its metadata (e.g. sizes / strides /
+   * storage / storage_offset). See NOTE [ Metadata Change for a Detached Tensor
+   * ] for details.
    */
   void set_allow_tensor_metadata_change(bool value) {
     allow_tensor_metadata_change_ = value;
   }
 
   /**
-   * True if a tensor allows changes to its metadata (e.g. sizes / strides / storage / storage_offset).
-   * See NOTE [ Metadata Change for a Detached Tensor ] for details.
+   * True if a tensor allows changes to its metadata (e.g. sizes / strides /
+   * storage / storage_offset). See NOTE [ Metadata Change for a Detached Tensor
+   * ] for details.
    */
   bool allow_tensor_metadata_change() const {
     return allow_tensor_metadata_change_;
@@ -1072,7 +1136,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   /**
    * Set the pointer to autograd metadata.
    */
-  void set_autograd_meta(std::unique_ptr<c10::AutogradMetaInterface> autograd_meta);
+  void set_autograd_meta(
+      std::unique_ptr<c10::AutogradMetaInterface> autograd_meta);
 
   /**
    * Return the pointer to autograd metadata.  May return nullptr if the
@@ -1083,7 +1148,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   /**
    * Set the pointer to named tensor metadata.
    */
-  void set_named_tensor_meta(std::unique_ptr<c10::NamedTensorMetaInterface> named_tensor_meta) {
+  void set_named_tensor_meta(
+      std::unique_ptr<c10::NamedTensorMetaInterface> named_tensor_meta) {
     TORCH_WARN_ONCE(
         "Named tensors and all their associated APIs are an experimental feature ",
         "and subject to change. Please do not use them for anything important ",
@@ -1116,34 +1182,44 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return named_tensor_meta_ != nullptr;
   }
 
-
   // NOTE [ TensorImpl Shallow-Copying ]
   //
-  // TensorImpl shallow-copying is used when we want to have two Variables share the same tensor metadata
-  // (e.g. sizes / strides / storage pointer / storage_offset), but each with a different autograd history.
-  // Example call sites:
+  // TensorImpl shallow-copying is used when we want to have two Variables share
+  // the same tensor metadata (e.g. sizes / strides / storage pointer /
+  // storage_offset), but each with a different autograd history. Example call
+  // sites:
   //
-  // 1. `var_detached = var.detach()` uses `shallow_copy_and_detach()` to create `var_detached` that shares
-  // the same tensor metadata with `var`, but with a completely new autograd history.
-  // 2. `var.set_data(tensor)` uses `shallow_copy_from()` to copy tensor metadata from
-  // `tensor` into `var`, while keeping `var`'s original AutogradMeta.
+  // 1. `var_detached = var.detach()` uses `shallow_copy_and_detach()` to create
+  // `var_detached` that shares the same tensor metadata with `var`, but with a
+  // completely new autograd history.
+  // 2. `var.set_data(tensor)` uses `shallow_copy_from()` to copy tensor
+  // metadata from `tensor` into `var`, while keeping `var`'s original
+  // AutogradMeta.
   //
-  // Functions that shallow-copy a TensorImpl (such as `shallow_copy_and_detach()` / `shallow_copy_from()` /
-  // `copy_tensor_metadata()`) copy the tensor metadata fields (e.g. sizes / strides / storage pointer /
-  // storage_offset) by value. However, the following fields are not copied:
+  // Functions that shallow-copy a TensorImpl (such as
+  // `shallow_copy_and_detach()` / `shallow_copy_from()` /
+  // `copy_tensor_metadata()`) copy the tensor metadata fields (e.g. sizes /
+  // strides / storage pointer / storage_offset) by value. However, the
+  // following fields are not copied:
   //
   // 1. the AutogradMeta pointer, because it is unique for each Variable.
-  // 2. the version counter, because the destination TensorImpl's version counter is either set to the
-  // passed-in `version_counter` (in `shallow_copy_and_detach()` and `copy_tensor_metadata()`), or it is kept
-  // intact (in `shallow_copy_from()`). See NOTE [ Version Counter Sharing ] for details.
+  // 2. the version counter, because the destination TensorImpl's version
+  // counter is either set to the passed-in `version_counter` (in
+  // `shallow_copy_and_detach()` and `copy_tensor_metadata()`), or it is kept
+  // intact (in `shallow_copy_from()`). See NOTE [ Version Counter Sharing ] for
+  // details.
   //
-  // In `shallow_copy_and_detach()` and `copy_tensor_metadata()`, the passed-in `allow_tensor_metadata_change`
-  // determines whether the TensorImpl shallow-copy allows changes to its metadata (e.g. sizes / strides /
-  // storage / storage_offset). See NOTE [ Metadata Change for a Detached Tensor ] for details.
+  // In `shallow_copy_and_detach()` and `copy_tensor_metadata()`, the passed-in
+  // `allow_tensor_metadata_change` determines whether the TensorImpl
+  // shallow-copy allows changes to its metadata (e.g. sizes / strides / storage
+  // / storage_offset). See NOTE [ Metadata Change for a Detached Tensor ] for
+  // details.
   //
-  // In `shallow_copy_from()`, we don't check the destination TensorImpl's `allow_tensor_metadata_change_`,
-  // because `shallow_copy_from()` is used for implementing functions such as `var.set_data(tensor)`, which
-  // changes `var`'s tensor metadata and expects its `allow_tensor_metadata_change_` to be ignored.
+  // In `shallow_copy_from()`, we don't check the destination TensorImpl's
+  // `allow_tensor_metadata_change_`, because `shallow_copy_from()` is used for
+  // implementing functions such as `var.set_data(tensor)`, which changes
+  // `var`'s tensor metadata and expects its `allow_tensor_metadata_change_` to
+  // be ignored.
 
   /**
    * One TensorImpl can be copied to another TensorImpl if they have the same
@@ -1161,7 +1237,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
           ts.has(DispatchKey::SparseCUDA) || ts.has(DispatchKey::SparseHIP) ||
           ts.has(DispatchKey::SparseXPU);
     };
-    return (key_set_ == from) || (is_dense(key_set_) && is_dense(from)) || (is_sparse(key_set_) && is_sparse(from));
+    return (key_set_ == from) || (is_dense(key_set_) && is_dense(from)) ||
+        (is_sparse(key_set_) && is_sparse(from));
   }
 
   /**
@@ -1187,32 +1264,32 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   /**
    * Shallow-copies data from another TensorImpl into this TensorImpl.
    *
-   * For why this function doesn't check this TensorImpl's `allow_tensor_metadata_change_`,
-   * see NOTE [ TensorImpl Shallow-Copying ].
+   * For why this function doesn't check this TensorImpl's
+   * `allow_tensor_metadata_change_`, see NOTE [ TensorImpl Shallow-Copying ].
    */
   virtual void shallow_copy_from(const c10::intrusive_ptr<TensorImpl>& impl) {
     copy_tensor_metadata(
-      /*src_impl=*/impl.get(),
-      /*dest_impl=*/this,
-      /*version_counter=*/version_counter(),
-      /*allow_tensor_metadata_change=*/allow_tensor_metadata_change());
+        /*src_impl=*/impl.get(),
+        /*dest_impl=*/this,
+        /*version_counter=*/version_counter(),
+        /*allow_tensor_metadata_change=*/allow_tensor_metadata_change());
     refresh_numel();
     refresh_contiguous();
   }
 
   // Inference tensor doesn't have version counter,
   // set_version_counter is no-op for them.
-  void set_version_counter(
-    const c10::VariableVersion& version_counter) {
-    TORCH_CHECK(!(is_inference_tensor() && version_counter.enabled()),
-      "Cannot set version_counter for inference tensor");
+  void set_version_counter(const c10::VariableVersion& version_counter) {
+    TORCH_CHECK(
+        !(is_inference_tensor() && version_counter.enabled()),
+        "Cannot set version_counter for inference tensor");
     version_counter_ = version_counter;
   }
 
-  void set_version_counter(
-    c10::VariableVersion&& version_counter) {
-    TORCH_CHECK(!(is_inference_tensor() && version_counter.enabled()),
-      "Cannot set version_counter for inference tensor");
+  void set_version_counter(c10::VariableVersion&& version_counter) {
+    TORCH_CHECK(
+        !(is_inference_tensor() && version_counter.enabled()),
+        "Cannot set version_counter for inference tensor");
     version_counter_ = std::move(version_counter);
   }
 
@@ -1241,14 +1318,15 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   }
 
  public:
-
   /**
    * The device type of a Tensor, e.g., DeviceType::CPU or DeviceType::CUDA.
    */
   DeviceType device_type() const {
     // TODO: A useful internal assert would be to show that device_opt_ is null
     // only if you are an undefined tensor
-    TORCH_CHECK(device_opt_.has_value(), "device_type cannot be run on undefined Tensor");
+    TORCH_CHECK(
+        device_opt_.has_value(),
+        "device_type cannot be run on undefined Tensor");
     // See NOTE [c10::optional operator usage in CUDA]
     return (*device_opt_).type();
   }
@@ -1271,29 +1349,33 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
         is_contiguous_,
         "Right now Extend is only supported for contiguous Tensor.");
     using SizesVector = SmallVector<int64_t, 5>;
-    SizesVector newDims(sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
+    SizesVector newDims(
+        sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
     newDims[0] += num;
     if (!storage_.data()) {
       Resize(newDims);
       return;
     }
-    const auto newNumel = c10::multiply_integers(newDims.begin(), newDims.end());
+    const auto newNumel =
+        c10::multiply_integers(newDims.begin(), newDims.end());
     if (newNumel * data_type_.itemsize() <= storage_.nbytes()) {
       sizes_and_strides_.set_sizes(newDims);
       numel_ = newNumel;
       return;
     }
-    SizesVector newCapacity(sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
+    SizesVector newCapacity(
+        sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
     newCapacity[0] = std::max(
-        newDims[0], static_cast<int64_t>(std::ceil(sizes_and_strides_.size_at_unchecked(0) * (1 + growthPct / 100))));
+        newDims[0],
+        static_cast<int64_t>(std::ceil(
+            sizes_and_strides_.size_at_unchecked(0) * (1 + growthPct / 100))));
     auto oldData = std::move(storage_.data_ptr());
     auto oldSize = numel_;
     Resize(newCapacity);
     auto* newData = raw_mutable_data(data_type_);
     if (data_type_.copy()) {
       TORCH_CHECK(
-          device_type() == DeviceType::CPU,
-          "non-POD types work only on CPU");
+          device_type() == DeviceType::CPU, "non-POD types work only on CPU");
       data_type_.copy()(oldData.get(), newData, oldSize);
     } else {
       // The following copy uses the current (thread local) stream for copying
@@ -1332,7 +1414,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     TORCH_CHECK(
         storage_.unique(), "Can't call ReserveSpace on shared storage.");
     // TODO: eliminate newCapacity.
-    SmallVector<int64_t, 5> newCapacity(sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
+    SmallVector<int64_t, 5> newCapacity(
+        sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
     newCapacity[0] = outer_dim;
     auto newNumel = c10::multiply_integers(newCapacity);
     if (newNumel * data_type_.itemsize() <= storage_.nbytes()) {
@@ -1341,7 +1424,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     // Old data is discarded
     storage_.data_ptr().clear();
     auto oldSize = numel_;
-    SmallVector<int64_t, 5> oldDims(sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
+    SmallVector<int64_t, 5> oldDims(
+        sizes_and_strides_.sizes_begin(), sizes_and_strides_.sizes_end());
     Resize(newCapacity);
     // Allocate new memory but don't copy over the data
     raw_mutable_data(data_type_);
@@ -1416,7 +1500,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     storage_offset_ = 0;
   }
 
-   /**
+  /**
    * @brief Shares the data with another tensor.
    *
    * To share data between two tensors, the sizes of the two tensors must be
@@ -1441,10 +1525,11 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     // know what to share yet.
     // TODO: Add the assert after all uninitialized states are eliminated
     // TORCH_CHECK(src.dtype_initialized(),
-    //            "Source tensor don't have a data type (did you call mutable_data<T> on the tensor?)");
+    //            "Source tensor don't have a data type (did you call
+    //            mutable_data<T> on the tensor?)");
     if (!src.dtype_initialized()) {
-      C10_LOG_EVERY_MS(WARNING, 1000) <<
-                   "Source tensor don't have a data type (did you call mutable_data<T> on the tensor?)";
+      C10_LOG_EVERY_MS(WARNING, 1000)
+          << "Source tensor don't have a data type (did you call mutable_data<T> on the tensor?)";
     }
     TORCH_CHECK(
         src.storage_initialized(),
@@ -1504,7 +1589,9 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   inline void* raw_mutable_data(const caffe2::TypeMeta meta) {
     // For 0-size tensors it's fine to return any pointer (including nullptr)
     if (data_type_ == meta && storage_initialized()) {
-      return static_cast<void*>(static_cast<char*>(storage_.data()) + storage_offset_ * meta.itemsize());
+      return static_cast<void*>(
+          static_cast<char*>(storage_.data()) +
+          storage_offset_ * meta.itemsize());
     } else {
       bool had_special_dtor = data_type_.placementDelete() != nullptr;
       storage_offset_ = 0;
@@ -1517,7 +1604,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
       if (numel_ == 0 ||
           (meta.placementNew() == nullptr && !had_special_dtor &&
            (storage_.nbytes() >= (numel_ * data_type_.itemsize())))) {
-        TORCH_INTERNAL_ASSERT(storage_offset_ == 0); // because we just reallocated
+        TORCH_INTERNAL_ASSERT(
+            storage_offset_ == 0); // because we just reallocated
         return storage_.data();
       }
       const Allocator* allocator = storage_.allocator();
@@ -1544,7 +1632,8 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
             allocator->allocate(numel_ * data_type_.itemsize()));
       }
       storage_.set_nbytes(numel_ * data_type_.itemsize());
-      TORCH_INTERNAL_ASSERT(storage_offset_ == 0); // because we just reallocated
+      TORCH_INTERNAL_ASSERT(
+          storage_offset_ == 0); // because we just reallocated
       device_opt_ = storage_.device();
       return storage_.data();
     }
@@ -1574,7 +1663,9 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
    * storage UNINITIALIZED after a Resize() or FreeMemory()
    */
   bool storage_initialized() const {
-    TORCH_CHECK(has_storage(), "cannot call storage_initialized on tensor that does not have storage");
+    TORCH_CHECK(
+        has_storage(),
+        "cannot call storage_initialized on tensor that does not have storage");
     return storage_.data() || numel_ == 0;
   }
 
@@ -1588,7 +1679,10 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   }
 
   void set_storage_keep_dtype(at::Storage storage) {
-    TORCH_CHECK(allow_tensor_metadata_change(), "set_storage ", err_msg_tensor_metadata_change_not_allowed);
+    TORCH_CHECK(
+        allow_tensor_metadata_change(),
+        "set_storage ",
+        err_msg_tensor_metadata_change_not_allowed);
     storage_ = std::move(storage);
     device_opt_ = storage_.device();
   }
@@ -1603,15 +1697,16 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
   /**
    * Set the strides of the tensor to match memory_format
    *
-   * WARNING: This function doesn't rearrange data and assumes tensor is a memory
-   * contiguous
+   * WARNING: This function doesn't rearrange data and assumes tensor is a
+   * memory contiguous
    */
   void empty_tensor_restride(MemoryFormat memory_format) {
-    #ifdef DEBUG
-        TORCH_INTERNAL_ASSERT(compute_numel() == numel_,
+#ifdef DEBUG
+    TORCH_INTERNAL_ASSERT(
+        compute_numel() == numel_,
         "If you are seeing this error, that means empty_tensor_restride was "
         "called before setting correct numel");
-    #endif
+#endif
     switch (memory_format) {
       case MemoryFormat::Contiguous: {
         // dim_ is a virtual call, don't repeat it
@@ -1621,15 +1716,17 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
           const auto last_idx = dim_ - 1;
           sizes_and_strides_.stride_at_unchecked(last_idx) = 1;
           for (auto i = last_idx - 1; i >= 0; --i) {
-            sizes_and_strides_.stride_at_unchecked(i) = sizes_and_strides_.stride_at_unchecked(i + 1) * std::max<int64_t>(sizes_and_strides_.size_at_unchecked(i + 1), 1);
+            sizes_and_strides_.stride_at_unchecked(i) =
+                sizes_and_strides_.stride_at_unchecked(i + 1) *
+                std::max<int64_t>(
+                    sizes_and_strides_.size_at_unchecked(i + 1), 1);
           }
         }
         break;
       }
       case MemoryFormat::ChannelsLast: {
         TORCH_CHECK(
-            dim() == 4,
-            "required rank 4 tensor to use channels_last format");
+            dim() == 4, "required rank 4 tensor to use channels_last format");
         set_sizes_and_strides(sizes(), get_channels_last_strides_2d(sizes()));
         break;
       }
@@ -1663,7 +1760,7 @@ struct C10_API TensorImpl : public c10::intrusive_ptr_target {
     return is_non_overlapping_and_dense_;
   }
 
-private:
+ private:
   void HandleResize();
 
   // The Caffe2 Resize() method supports being called both as Resize({2,2}) as
@@ -1719,7 +1816,11 @@ private:
     return SetDims(IntArrayRef{d0, d1, d2});
   }
 
-  bool SetDims(const int64_t d0, const int64_t d1, const int64_t d2, const int64_t d3) {
+  bool SetDims(
+      const int64_t d0,
+      const int64_t d1,
+      const int64_t d2,
+      const int64_t d3) {
     return SetDims(IntArrayRef{d0, d1, d2, d3});
   }
 
@@ -1750,7 +1851,7 @@ private:
 
   bool compute_non_overlapping_and_dense() const;
 
-protected:
+ protected:
   /**
    * Recompute the cached numel of a tensor.  Call this if you modify sizes.
    */
@@ -1766,41 +1867,51 @@ protected:
     is_contiguous_ = compute_contiguous();
     // Note:
     // Dim 0, 1, 2 will never be a channels last 2d/3d format
-    // Dim 3+ is possibly be a channels last 2d format (Dim 4 only at this point)
-    // Dim 4+ is possibly be a channels last 3d format (Dim 5 only at this point)
+    // Dim 3+ is possibly be a channels last 2d format (Dim 4 only at this
+    // point) Dim 4+ is possibly be a channels last 3d format (Dim 5 only at
+    // this point)
     switch (dim()) {
       case 4:
         is_channels_last_contiguous_ = compute_channels_last_contiguous_2d();
         is_channels_last_3d_contiguous_ = false;
         is_channels_last_ = compute_strides_like_channels_last_2d();
         is_channels_last_3d_ = false;
-        is_non_overlapping_and_dense_ = is_contiguous_ || is_channels_last_contiguous_ || compute_non_overlapping_and_dense();
+        is_non_overlapping_and_dense_ = is_contiguous_ ||
+            is_channels_last_contiguous_ || compute_non_overlapping_and_dense();
         break;
       case 5:
         is_channels_last_contiguous_ = compute_channels_last_contiguous_2d();
-        is_channels_last_3d_contiguous_ = !is_channels_last_contiguous_ && compute_channels_last_contiguous_3d();
-        is_channels_last_ = !is_channels_last_3d_contiguous_ && compute_strides_like_channels_last_2d();
-        is_channels_last_3d_ = !is_channels_last_ && compute_strides_like_channels_last_3d();
-        is_non_overlapping_and_dense_ = is_contiguous_ || is_channels_last_contiguous_ || is_channels_last_3d_contiguous_|| compute_non_overlapping_and_dense();
+        is_channels_last_3d_contiguous_ = !is_channels_last_contiguous_ &&
+            compute_channels_last_contiguous_3d();
+        is_channels_last_ = !is_channels_last_3d_contiguous_ &&
+            compute_strides_like_channels_last_2d();
+        is_channels_last_3d_ =
+            !is_channels_last_ && compute_strides_like_channels_last_3d();
+        is_non_overlapping_and_dense_ = is_contiguous_ ||
+            is_channels_last_contiguous_ || is_channels_last_3d_contiguous_ ||
+            compute_non_overlapping_and_dense();
         break;
       default:
         is_channels_last_contiguous_ = false;
         is_channels_last_3d_contiguous_ = false;
-        // is_channels_last_ and is_channels_last_3d_ are suggested memory_format.
-        // Being channels_last_contiguous doesn't necessarily mean the tensor is
-        // strided like channels_last: for strides on channel dimension could suggest
-        // desired memory_layout, but it doesn't affect memory storage
+        // is_channels_last_ and is_channels_last_3d_ are suggested
+        // memory_format. Being channels_last_contiguous doesn't necessarily
+        // mean the tensor is strided like channels_last: for strides on channel
+        // dimension could suggest desired memory_layout, but it doesn't affect
+        // memory storage
         is_channels_last_ = false;
         is_channels_last_3d_ = false;
-        is_non_overlapping_and_dense_ = is_contiguous_ || compute_non_overlapping_and_dense();
+        is_non_overlapping_and_dense_ =
+            is_contiguous_ || compute_non_overlapping_and_dense();
     }
   }
 
   /**
-   * Copy the tensor metadata fields (e.g. sizes / strides / storage pointer / storage_offset)
-   * from one TensorImpl to another TensorImpl.
+   * Copy the tensor metadata fields (e.g. sizes / strides / storage pointer /
+   * storage_offset) from one TensorImpl to another TensorImpl.
    *
-   * For usage of `version_counter` and `allow_tensor_metadata_change`, see NOTE [ TensorImpl Shallow-Copying ].
+   * For usage of `version_counter` and `allow_tensor_metadata_change`, see NOTE
+   * [ TensorImpl Shallow-Copying ].
    */
   static void copy_tensor_metadata(
       const TensorImpl* src_impl,
@@ -1809,10 +1920,11 @@ protected:
       bool allow_tensor_metadata_change);
 
   /**
-   * Copy the tensor metadata fields (e.g. sizes / strides / storage pointer / storage_offset)
-   * from one TensorImpl to another TensorImpl.
+   * Copy the tensor metadata fields (e.g. sizes / strides / storage pointer /
+   * storage_offset) from one TensorImpl to another TensorImpl.
    *
-   * For usage of `version_counter` and `allow_tensor_metadata_change`, see NOTE [ TensorImpl Shallow-Copying ].
+   * For usage of `version_counter` and `allow_tensor_metadata_change`, see NOTE
+   * [ TensorImpl Shallow-Copying ].
    */
   static void copy_tensor_metadata(
       const TensorImpl* src_impl,
@@ -1820,25 +1932,25 @@ protected:
       c10::VariableVersion&& version_counter,
       bool allow_tensor_metadata_change);
 
-private:
+ private:
   static void copy_tensor_metadata_except_version_counter(
       const TensorImpl* src_impl,
       TensorImpl* dest_impl,
       bool allow_tensor_metadata_change);
 
-protected:
+ protected:
   // Error message to show when the user tries to change tensor metadata on
   // Tensor created from .data or .detach().
   //
   // See NOTE [ Metadata Change for a Detached Tensor ] for details.
-  static const char * const err_msg_tensor_metadata_change_not_allowed;
+  static const char* const err_msg_tensor_metadata_change_not_allowed;
 
-public:
+ public:
   void set_storage_access_should_throw() {
     storage_access_should_throw_ = true;
   }
 
-protected:
+ protected:
   // Policy for adjusting the behavior of is_contiguous(). Allows
   // subclass customization while still being able to inline
   // is_contiguous() in the common case.
@@ -1859,11 +1971,10 @@ protected:
 
   Storage storage_;
 
-private:
-  // This pointer points to an AutogradMeta struct that stores autograd-specific fields
-  // (such as grad_ / grad_fn_ / grad_accumulator_).
-  // This pointer always has unique ownership (meaning only one TensorImpl can own it
-  // at a time).
+ private:
+  // This pointer points to an AutogradMeta struct that stores autograd-specific
+  // fields (such as grad_ / grad_fn_ / grad_accumulator_). This pointer always
+  // has unique ownership (meaning only one TensorImpl can own it at a time).
   //
   // autograd_meta_ can be nullptr, as an optimization.  When this occurs, it is
   // equivalent to having an autograd_meta_ pointing to a default constructed
@@ -1886,7 +1997,7 @@ private:
   //
   std::unique_ptr<c10::AutogradMetaInterface> autograd_meta_ = nullptr;
 
-protected:
+ protected:
   std::unique_ptr<c10::NamedTensorMetaInterface> named_tensor_meta_ = nullptr;
 
   c10::VariableVersion version_counter_;
@@ -1941,7 +2052,8 @@ protected:
   // Tensor is a subclass that does not permit storage access.
   bool storage_access_should_throw_ = false;
 
-  // default member initializers for bit-fields only available with -std=c++2a or -std=gnu++2a
+  // default member initializers for bit-fields only available with -std=c++2a
+  // or -std=gnu++2a
   inline void init_bitfields() {
     is_contiguous_ = true;
     has_contiguity_ = static_cast<uint8_t>(HasContiguityPolicy::Default);
@@ -1967,18 +2079,18 @@ protected:
   bool is_channels_last_contiguous_ : 1;
 
   // Tensor is stored in the channels last 3d memory format, when dimensions
-  // order is (N)CDHW and C-strides < W-strides < H-strides < D - strides (< N-strides)
-  // (If size of any dimension is equal to 1, this dimension strides value
-  // is not taken into account).
+  // order is (N)CDHW and C-strides < W-strides < H-strides < D - strides (<
+  // N-strides) (If size of any dimension is equal to 1, this dimension strides
+  // value is not taken into account).
   bool is_channels_last_3d_ : 1;
 
   // Channels last 3d contiguous tensor is channel last 3d tensor which occupies
   // contiguous memory block.
   bool is_channels_last_3d_contiguous_ : 1;
 
-  // Dense tensor is the tensor that store values in a contiguous block of memory.
-  // Non-overlapping tensor is the tensor in which elements occupy individual
-  // non-repetitive memory.
+  // Dense tensor is the tensor that store values in a contiguous block of
+  // memory. Non-overlapping tensor is the tensor in which elements occupy
+  // individual non-repetitive memory.
   bool is_non_overlapping_and_dense_ : 1;
 
   bool is_wrapped_number_ : 1;
@@ -2010,7 +2122,8 @@ protected:
   // does NOT include Autograd (historically, it did, but
   // not anymore!)
   //
-  // INVARIANT: named_tensor_meta_ != nullptr  <==>  key_set_.has(DispatchKey::Named)
+  // INVARIANT: named_tensor_meta_ != nullptr  <==>
+  // key_set_.has(DispatchKey::Named)
   DispatchKeySet key_set_;
 };
 
@@ -2063,8 +2176,9 @@ protected:
 //    data type, device, is_contiguous, storage_access_should_throw_, bitfields
 //    DispatchKeySet
 //
-static_assert(sizeof(void*) != sizeof(int64_t) || // if 64-bit...
-              sizeof(TensorImpl) == sizeof(int64_t) * 23,
-              "You changed the size of TensorImpl on 64-bit arch."
-              "See Note [TensorImpl size constraints] on how to proceed.");
+static_assert(
+    sizeof(void*) != sizeof(int64_t) || // if 64-bit...
+        sizeof(TensorImpl) == sizeof(int64_t) * 23,
+    "You changed the size of TensorImpl on 64-bit arch."
+    "See Note [TensorImpl size constraints] on how to proceed.");
 } // namespace c10
diff --git a/c10/core/TensorOptions.cpp b/c10/core/TensorOptions.cpp
index e1fdc5b39de..a9380f51392 100644
--- a/c10/core/TensorOptions.cpp
+++ b/c10/core/TensorOptions.cpp
@@ -17,18 +17,20 @@ namespace c10 {
 // internal state and what its getters will return.
 
 std::ostream& operator<<(std::ostream& stream, const TensorOptions& options) {
-
-  auto print = [&](const char *label, auto prop, bool has_prop) {
+  auto print = [&](const char* label, auto prop, bool has_prop) {
     stream << label << std::boolalpha << prop << (has_prop ? "" : " (default)");
   };
 
   print("TensorOptions(dtype=", options.dtype(), options.has_dtype());
   print(", device=", options.device(), options.has_device());
   print(", layout=", options.layout(), options.has_layout());
-  print(", requires_grad=", options.requires_grad(), options.has_requires_grad());
-  print(", pinned_memory=", options.pinned_memory(), options.has_pinned_memory());
+  print(
+      ", requires_grad=", options.requires_grad(), options.has_requires_grad());
+  print(
+      ", pinned_memory=", options.pinned_memory(), options.has_pinned_memory());
 
-  // note: default-supplying memory_format() getter not provided; no canonical default
+  // note: default-supplying memory_format() getter not provided; no canonical
+  // default
   stream << ", memory_format=";
   if (options.has_memory_format()) {
     stream << *options.memory_format_opt();
diff --git a/c10/core/TensorOptions.h b/c10/core/TensorOptions.h
index 4f750de0fff..06ddb2f008a 100644
--- a/c10/core/TensorOptions.h
+++ b/c10/core/TensorOptions.h
@@ -1,17 +1,17 @@
 #pragma once
 
-#include <c10/core/DefaultDtype.h>
 #include <c10/core/Backend.h>
+#include <c10/core/DefaultDtype.h>
+#include <c10/core/Device.h>
+#include <c10/core/DispatchKeySet.h>
 #include <c10/core/Layout.h>
+#include <c10/core/MemoryFormat.h>
 #include <c10/core/ScalarType.h>
 #include <c10/core/ScalarTypeToTypeMeta.h>
-#include <c10/core/Device.h>
-#include <c10/core/MemoryFormat.h>
-#include <c10/core/DispatchKeySet.h>
 
-#include <c10/util/Optional.h>
-#include <c10/util/C++17.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/C++17.h>
+#include <c10/util/Optional.h>
 
 #include <cstddef>
 #include <iosfwd>
@@ -19,14 +19,18 @@
 
 namespace c10 {
 
-DispatchKey computeDispatchKey(c10::optional<ScalarType> dtype, c10::optional<Layout> layout, c10::optional<Device> device);
+DispatchKey computeDispatchKey(
+    c10::optional<ScalarType> dtype,
+    c10::optional<Layout> layout,
+    c10::optional<Device> device);
 
 inline ScalarType dtype_or_default(c10::optional<ScalarType> dtype) {
-  return value_or_else(dtype, [] {return get_default_dtype_as_scalartype();});
+  return value_or_else(dtype, [] { return get_default_dtype_as_scalartype(); });
 }
 
-inline caffe2::TypeMeta dtype_or_default(c10::optional<caffe2::TypeMeta> dtype) {
-  return value_or_else(dtype, [] {return get_default_dtype();});
+inline caffe2::TypeMeta dtype_or_default(
+    c10::optional<caffe2::TypeMeta> dtype) {
+  return value_or_else(dtype, [] { return get_default_dtype(); });
 }
 
 inline Layout layout_or_default(c10::optional<Layout> layout) {
@@ -34,7 +38,7 @@ inline Layout layout_or_default(c10::optional<Layout> layout) {
 }
 
 inline Device device_or_default(c10::optional<Device> device) {
-  return value_or_else(device, [] {return Device(kCPU);});
+  return value_or_else(device, [] { return Device(kCPU); });
 }
 
 inline bool pinned_memory_or_default(c10::optional<bool> pinned_memory) {
@@ -65,7 +69,8 @@ inline bool pinned_memory_or_default(c10::optional<bool> pinned_memory) {
 ///     at::dtype(at::kInt)
 ///
 /// Additionally, anywhere a TensorOptions is expected, you can directly
-/// pass at::kCUDA / at::kInt, and it will implicitly convert to a TensorOptions.
+/// pass at::kCUDA / at::kInt, and it will implicitly convert to a
+/// TensorOptions.
 ///
 /// Here are some recommended ways to create a 2x2 tensor of zeros
 /// with certain properties.  These all *implicitly* make use of
@@ -108,7 +113,8 @@ inline bool pinned_memory_or_default(c10::optional<bool> pinned_memory) {
 ///    }
 ///
 ///    template <typename... Args,
-///             typename = std::enable_if_t<std::is_constructible<Device, Args&&...>::value>>
+///             typename = std::enable_if_t<std::is_constructible<Device,
+///             Args&&...>::value>>
 ///    /* implicit */  TensorOptions(Args&&... args)
 ///     : TensorOptions(Device(std::forward<Args>(args)...)) {}
 ///
@@ -121,20 +127,21 @@ inline bool pinned_memory_or_default(c10::optional<bool> pinned_memory) {
 /// To get around this, we templatize the `Device` constructor. Since overload
 /// resolution is done before template resolution, our problem is solved.
 
-DispatchKey computeDispatchKey(optional<ScalarType> dtype, optional<Layout> layout, optional<Device> device);
-
+DispatchKey computeDispatchKey(
+    optional<ScalarType> dtype,
+    optional<Layout> layout,
+    optional<Device> device);
 
 struct C10_API TensorOptions {
   TensorOptions()
-    : requires_grad_(false)
-    , pinned_memory_(false)
-    , has_device_(false)
-    , has_dtype_(false)
-    , has_layout_(false)
-    , has_requires_grad_(false)
-    , has_pinned_memory_(false)
-    , has_memory_format_(false)
-    {}
+      : requires_grad_(false),
+        pinned_memory_(false),
+        has_device_(false),
+        has_dtype_(false),
+        has_layout_(false),
+        has_requires_grad_(false),
+        has_pinned_memory_(false),
+        has_memory_format_(false) {}
 
   /// Constructs a `TensorOptions` object with the given layout.
   /* implicit */ TensorOptions(Layout layout) : TensorOptions() {
@@ -143,8 +150,9 @@ struct C10_API TensorOptions {
 
   /// Constructs a `TensorOptions` object with the given device.
   /// See NOTE [ TensorOptions Constructors ] on why this is templatized.
-  template<typename T,
-           typename = std::enable_if_t<std::is_same<std::decay_t<T>, Device>::value>>
+  template <
+      typename T,
+      typename = std::enable_if_t<std::is_same<std::decay_t<T>, Device>::value>>
   /* implicit */ TensorOptions(T&& device) : TensorOptions() {
     this->set_device(std::forward<T>(device));
   }
@@ -157,10 +165,12 @@ struct C10_API TensorOptions {
   /// NB: Ideally we only allow implicit constructors here. But there is no easy
   ///     way to detect them. So we have this one that allows explicit
   ///     constructors too.
-  template <typename... Args,
-            typename = std::enable_if_t<std::is_constructible<Device, Args&&...>::value>>
-   /* implicit */ TensorOptions(Args&&... args)
-    : TensorOptions(Device(std::forward<Args>(args)...)) {}
+  template <
+      typename... Args,
+      typename =
+          std::enable_if_t<std::is_constructible<Device, Args&&...>::value>>
+  /* implicit */ TensorOptions(Args&&... args)
+      : TensorOptions(Device(std::forward<Args>(args)...)) {}
 
   /// Constructs a `TensorOptions` object with the given dtype.
   /* implicit */ TensorOptions(caffe2::TypeMeta dtype) : TensorOptions() {
@@ -179,7 +189,8 @@ struct C10_API TensorOptions {
 
   /// Return a copy of `TensorOptions` with `device` set to the given one, or
   /// cleared if `device` is `nullopt`.
-  C10_NODISCARD TensorOptions device(c10::optional<Device> device) const noexcept {
+  C10_NODISCARD TensorOptions
+  device(c10::optional<Device> device) const noexcept {
     TensorOptions r = *this;
     r.set_device(device);
     return r;
@@ -188,9 +199,10 @@ struct C10_API TensorOptions {
   /// Return a copy of `TensorOptions` with `device` set to the given one.
   /// (This overload ensures that variadic template c10::optional constructor
   /// for Device work correctly.)
-  template<typename ... Args>
+  template <typename... Args>
   C10_NODISCARD TensorOptions device(Args&&... args) const noexcept {
-    return device(c10::optional<Device>(c10::in_place, std::forward<Args>(args)...));
+    return device(
+        c10::optional<Device>(c10::in_place, std::forward<Args>(args)...));
   }
 
   /// Return a copy of `TensorOptions`, but with device set to CUDA, and the
@@ -198,19 +210,22 @@ struct C10_API TensorOptions {
   ///
   /// TODO: This function encourages bad behavior (assuming CUDA is
   /// the only device that matters).  Get rid of it / rename it.
-  C10_NODISCARD TensorOptions device_index(int16_t device_index) const noexcept {
+  C10_NODISCARD TensorOptions
+  device_index(int16_t device_index) const noexcept {
     return device(Device::Type::CUDA, device_index);
   }
 
   /// Return a copy of `TensorOptions` with `dtype` set to the given one.
-  C10_NODISCARD TensorOptions dtype(c10::optional<caffe2::TypeMeta> dtype) const noexcept {
+  C10_NODISCARD TensorOptions
+  dtype(c10::optional<caffe2::TypeMeta> dtype) const noexcept {
     TensorOptions r = *this;
     r.set_dtype(dtype);
     return r;
   }
 
   // legacy function to support ScalarType
-  C10_NODISCARD TensorOptions dtype(c10::optional<ScalarType> dtype) const noexcept {
+  C10_NODISCARD TensorOptions
+  dtype(c10::optional<ScalarType> dtype) const noexcept {
     TensorOptions r = *this;
     r.set_dtype(dtype);
     return r;
@@ -225,28 +240,32 @@ struct C10_API TensorOptions {
   }
 
   /// Sets the layout of the `TensorOptions`.
-  C10_NODISCARD TensorOptions layout(c10::optional<Layout> layout) const noexcept {
+  C10_NODISCARD TensorOptions
+  layout(c10::optional<Layout> layout) const noexcept {
     TensorOptions r = *this;
     r.set_layout(layout);
     return r;
   }
 
   /// Sets the `requires_grad` property of the `TensorOptions`.
-  C10_NODISCARD TensorOptions requires_grad(c10::optional<bool> requires_grad) const noexcept {
+  C10_NODISCARD TensorOptions
+  requires_grad(c10::optional<bool> requires_grad) const noexcept {
     TensorOptions r = *this;
     r.set_requires_grad(requires_grad);
     return r;
   }
 
   /// Sets the `pinned_memory` property on the `TensorOptions`.
-  C10_NODISCARD TensorOptions pinned_memory(c10::optional<bool> pinned_memory) const noexcept {
+  C10_NODISCARD TensorOptions
+  pinned_memory(c10::optional<bool> pinned_memory) const noexcept {
     TensorOptions r = *this;
     r.set_pinned_memory(pinned_memory);
     return r;
   }
 
   /// Sets the `memory_format` property on `TensorOptions`.
-  C10_NODISCARD TensorOptions memory_format(c10::optional<MemoryFormat> memory_format) const noexcept {
+  C10_NODISCARD TensorOptions
+  memory_format(c10::optional<MemoryFormat> memory_format) const noexcept {
     TensorOptions r = *this;
     r.set_memory_format(memory_format);
     return r;
@@ -343,13 +362,15 @@ struct C10_API TensorOptions {
 
   // For compatibility with legacy tensor.type() comparisons
   bool type_equal(const TensorOptions& other) const {
-    return computeDispatchKey() == other.computeDispatchKey() && typeMetaToScalarType(dtype_) == typeMetaToScalarType(other.dtype());
+    return computeDispatchKey() == other.computeDispatchKey() &&
+        typeMetaToScalarType(dtype_) == typeMetaToScalarType(other.dtype());
   }
 
   /// Returns the `pinned_memory` property of the `TensorOptions`, or
   /// `c10::nullopt` if `pinned_memory` is not specified.
   c10::optional<bool> pinned_memory_opt() const noexcept {
-    return has_pinned_memory_ ? c10::make_optional(pinned_memory_) : c10::nullopt;
+    return has_pinned_memory_ ? c10::make_optional(pinned_memory_)
+                              : c10::nullopt;
   }
 
   /// Returns whether the `memory_layout` is specified
@@ -363,7 +384,8 @@ struct C10_API TensorOptions {
   /// Returns the `memory_layout` property of `TensorOptions, or
   /// `c10::nullopt` if `memory_format` is not specified.
   c10::optional<MemoryFormat> memory_format_opt() const noexcept {
-    return has_memory_format_ ? c10::make_optional(memory_format_) : c10::nullopt;
+    return has_memory_format_ ? c10::make_optional(memory_format_)
+                              : c10::nullopt;
   }
 
   // Resolves the ATen backend specified by the current construction axes.
@@ -384,18 +406,25 @@ struct C10_API TensorOptions {
   ///
   TensorOptions merge_in(TensorOptions options) const noexcept {
     TensorOptions merged = *this;
-    if (options.has_device()) merged.set_device(options.device_opt());
-    if (options.has_dtype()) merged.set_dtype(options.dtype_opt());
-    if (options.has_layout()) merged.set_layout(options.layout_opt());
+    if (options.has_device())
+      merged.set_device(options.device_opt());
+    if (options.has_dtype())
+      merged.set_dtype(options.dtype_opt());
+    if (options.has_layout())
+      merged.set_layout(options.layout_opt());
     // NB: requires grad is right biased; not a logical AND/OR!
-    if (options.has_requires_grad()) merged.set_requires_grad(options.requires_grad_opt());
-    if (options.has_pinned_memory()) merged.set_pinned_memory(options.pinned_memory_opt());
-    if (options.has_memory_format()) merged.set_memory_format(options.memory_format_opt());
+    if (options.has_requires_grad())
+      merged.set_requires_grad(options.requires_grad_opt());
+    if (options.has_pinned_memory())
+      merged.set_pinned_memory(options.pinned_memory_opt());
+    if (options.has_memory_format())
+      merged.set_memory_format(options.memory_format_opt());
     return merged;
   }
 
   // TODO remove after TensorOptions rationalization
-  TensorOptions merge_memory_format(c10::optional<MemoryFormat> optional_memory_format) const noexcept {
+  TensorOptions merge_memory_format(
+      c10::optional<MemoryFormat> optional_memory_format) const noexcept {
     TensorOptions merged = *this;
     if (optional_memory_format.has_value()) {
       merged.set_memory_format(*optional_memory_format);
@@ -408,11 +437,11 @@ struct C10_API TensorOptions {
   // the most part, this just means that this function never returns an
   // Autograd key)
   DispatchKey computeDispatchKey() const {
-    return c10::computeDispatchKey(optTypeMetaToScalarType(dtype_opt()), layout_opt(), device_opt());
+    return c10::computeDispatchKey(
+        optTypeMetaToScalarType(dtype_opt()), layout_opt(), device_opt());
   }
 
  private:
-
   // These methods are currently private because I'm not sure if it's wise
   // to actually publish them.  They are methods because I need them in
   // the constructor and the functional API implementation.
@@ -515,13 +544,12 @@ struct C10_API TensorOptions {
   // Bitmask required here to get this to fit inside 32 bits (or even 64 bits,
   // for that matter)
 
-  bool requires_grad_     : 1;
-  bool pinned_memory_     : 1;
+  bool requires_grad_ : 1;
+  bool pinned_memory_ : 1;
 
-
-  bool has_device_        : 1;
-  bool has_dtype_         : 1;
-  bool has_layout_        : 1;
+  bool has_device_ : 1;
+  bool has_dtype_ : 1;
+  bool has_layout_ : 1;
   bool has_requires_grad_ : 1;
   bool has_pinned_memory_ : 1;
   bool has_memory_format_ : 1;
@@ -530,8 +558,9 @@ struct C10_API TensorOptions {
 // We should aspire to fit in one machine-size word; but a size greater than two
 // words is too much.  (We are doing terribly on 32-bit archs, where we require
 // three machine size words to store tensor options.  Eek!)
-static_assert( sizeof(TensorOptions) <= sizeof(int64_t) * 2,
-               "TensorOptions must fit in 128-bits" );
+static_assert(
+    sizeof(TensorOptions) <= sizeof(int64_t) * 2,
+    "TensorOptions must fit in 128-bits");
 
 /// Convenience function that returns a `TensorOptions` object with the `dtype`
 /// set to the given one.
@@ -591,88 +620,106 @@ inline std::string toString(const TensorOptions options) {
 
 // This is intended to be a centralized location by which we can determine
 // what an appropriate DispatchKey for a tensor is.
-inline DispatchKey computeDispatchKey(c10::optional<ScalarType> dtype, c10::optional<Layout> layout, c10::optional<Device> device) {
+inline DispatchKey computeDispatchKey(
+    c10::optional<ScalarType> dtype,
+    c10::optional<Layout> layout,
+    c10::optional<Device> device) {
   const auto layout_ = layout_or_default(layout);
   const auto device_ = device_or_default(device);
   switch (layout_) {
-      case Layout::Strided: {
-        const auto dtype_ = dtype_or_default(dtype);
-        switch (device_.type()) {
-          case DeviceType::CPU: {
-            if (isQIntType(dtype_)) {
-              return DispatchKey::QuantizedCPU;
-            }
-            return DispatchKey::CPU;
+    case Layout::Strided: {
+      const auto dtype_ = dtype_or_default(dtype);
+      switch (device_.type()) {
+        case DeviceType::CPU: {
+          if (isQIntType(dtype_)) {
+            return DispatchKey::QuantizedCPU;
           }
-          case DeviceType::CUDA: {
-            if (isQIntType(dtype_)) {
-              return DispatchKey::QuantizedCUDA;
-            }
-            return DispatchKey::CUDA;
-          }
-          case DeviceType::XPU: {
-            if (isQIntType(dtype_)) {
-              return DispatchKey::QuantizedXPU;
-            }
-            return DispatchKey::XPU;
-          }
-          case DeviceType::MKLDNN:
-          case DeviceType::OPENGL:
-          case DeviceType::OPENCL:
-          case DeviceType::IDEEP:
-            TORCH_INTERNAL_ASSERT(0, "This is a grandfathered Caffe2 device type ", device_.type(), ", it shouldn't ever convert to a DispatchKey.  File a bug describing what you were doing if you think this is in error.");
-          case DeviceType::HIP:
-            return DispatchKey::HIP;
-          case DeviceType::FPGA:
-            return DispatchKey::FPGA;
-          case DeviceType::MSNPU:
-            return DispatchKey::MSNPU;
-          case DeviceType::XLA:
-            return DispatchKey::XLA;
-          case DeviceType::MLC:
-            return DispatchKey::MLC;
-          case DeviceType::Vulkan:
-            return DispatchKey::Vulkan;
-          case DeviceType::Metal:
-            return DispatchKey::Metal;
-          case DeviceType::Meta:
-            return DispatchKey::Meta;
-          default:
-            TORCH_CHECK_NOT_IMPLEMENTED(false, "Unsupported device type for dense layout: ", device_.type());
+          return DispatchKey::CPU;
         }
+        case DeviceType::CUDA: {
+          if (isQIntType(dtype_)) {
+            return DispatchKey::QuantizedCUDA;
+          }
+          return DispatchKey::CUDA;
+        }
+        case DeviceType::XPU: {
+          if (isQIntType(dtype_)) {
+            return DispatchKey::QuantizedXPU;
+          }
+          return DispatchKey::XPU;
+        }
+        case DeviceType::MKLDNN:
+        case DeviceType::OPENGL:
+        case DeviceType::OPENCL:
+        case DeviceType::IDEEP:
+          TORCH_INTERNAL_ASSERT(
+              0,
+              "This is a grandfathered Caffe2 device type ",
+              device_.type(),
+              ", it shouldn't ever convert to a DispatchKey.  File a bug describing what you were doing if you think this is in error.");
+        case DeviceType::HIP:
+          return DispatchKey::HIP;
+        case DeviceType::FPGA:
+          return DispatchKey::FPGA;
+        case DeviceType::MSNPU:
+          return DispatchKey::MSNPU;
+        case DeviceType::XLA:
+          return DispatchKey::XLA;
+        case DeviceType::MLC:
+          return DispatchKey::MLC;
+        case DeviceType::Vulkan:
+          return DispatchKey::Vulkan;
+        case DeviceType::Metal:
+          return DispatchKey::Metal;
+        case DeviceType::Meta:
+          return DispatchKey::Meta;
+        default:
+          TORCH_CHECK_NOT_IMPLEMENTED(
+              false,
+              "Unsupported device type for dense layout: ",
+              device_.type());
       }
-      case Layout::Sparse:
-        switch (device_.type()) {
-          case DeviceType::CPU:
-            return DispatchKey::SparseCPU;
-          case DeviceType::CUDA:
-            return DispatchKey::SparseCUDA;
-          case DeviceType::HIP:
-            return DispatchKey::SparseHIP;
-          case DeviceType::XPU:
-            return DispatchKey::SparseXPU;
-          default:
-            TORCH_CHECK_NOT_IMPLEMENTED(false, "Unsupported device type for sparse layout: ", device_.type());
-        }
-      case Layout::Mkldnn:
-        switch (device_.type()) {
-          case DeviceType::CPU:
-            return DispatchKey::MkldnnCPU;
-          default:
-            TORCH_CHECK_NOT_IMPLEMENTED(false, "Unsupported device type for mkldnn layout: ", device_.type());
-        }
-      case Layout::SparseCsr:
-        switch(device_.type()) {
-          case DeviceType::CPU:
-            return DispatchKey::SparseCsrCPU;
-          case DeviceType::CUDA:
-            return DispatchKey::SparseCsrCUDA;
-          default:
-            AT_ERROR("Unsupported device type for sparse CSR layout: ", device_.type());
-        }
-      default:
-        TORCH_CHECK(false, "Unsupported layout: ", layout_);
     }
+    case Layout::Sparse:
+      switch (device_.type()) {
+        case DeviceType::CPU:
+          return DispatchKey::SparseCPU;
+        case DeviceType::CUDA:
+          return DispatchKey::SparseCUDA;
+        case DeviceType::HIP:
+          return DispatchKey::SparseHIP;
+        case DeviceType::XPU:
+          return DispatchKey::SparseXPU;
+        default:
+          TORCH_CHECK_NOT_IMPLEMENTED(
+              false,
+              "Unsupported device type for sparse layout: ",
+              device_.type());
+      }
+    case Layout::Mkldnn:
+      switch (device_.type()) {
+        case DeviceType::CPU:
+          return DispatchKey::MkldnnCPU;
+        default:
+          TORCH_CHECK_NOT_IMPLEMENTED(
+              false,
+              "Unsupported device type for mkldnn layout: ",
+              device_.type());
+      }
+    case Layout::SparseCsr:
+      switch (device_.type()) {
+        case DeviceType::CPU:
+          return DispatchKey::SparseCsrCPU;
+        case DeviceType::CUDA:
+          return DispatchKey::SparseCsrCUDA;
+        default:
+          AT_ERROR(
+              "Unsupported device type for sparse CSR layout: ",
+              device_.type());
+      }
+    default:
+      TORCH_CHECK(false, "Unsupported layout: ", layout_);
+  }
 }
 
 inline Layout dispatchKeyToLayout(DispatchKey dispatch_key) {
@@ -692,7 +739,7 @@ inline Layout dispatchKeyToLayout(DispatchKey dispatch_key) {
 }
 
 inline DeviceType dispatchKeyToDeviceType(DispatchKey dispatch_key) {
-  switch(dispatch_key) {
+  switch (dispatch_key) {
     // stuff that's real
     case DispatchKey::CPU:
     case DispatchKey::SparseCPU:
@@ -730,14 +777,18 @@ inline DeviceType dispatchKeyToDeviceType(DispatchKey dispatch_key) {
     case DispatchKey::MSNPU:
       return DeviceType::MSNPU;
     default:
-      TORCH_CHECK(false, "DispatchKey ", dispatch_key, " doesn't correspond to a device");
+      TORCH_CHECK(
+          false,
+          "DispatchKey ",
+          dispatch_key,
+          " doesn't correspond to a device");
   }
 }
 
 inline TensorOptions dispatchKeyToTensorOptions(DispatchKey dispatch_key) {
   return TensorOptions()
-          .layout(dispatchKeyToLayout(dispatch_key))
-          .device(dispatchKeyToDeviceType(dispatch_key));
+      .layout(dispatchKeyToLayout(dispatch_key))
+      .device(dispatchKeyToDeviceType(dispatch_key));
 }
 
 } // namespace c10
diff --git a/c10/core/UndefinedTensorImpl.cpp b/c10/core/UndefinedTensorImpl.cpp
index 7252c1cc4dc..dafa0742e75 100644
--- a/c10/core/UndefinedTensorImpl.cpp
+++ b/c10/core/UndefinedTensorImpl.cpp
@@ -5,7 +5,7 @@ namespace c10 {
 
 // should this use the globalContext?  Can it get a context passed in somehow?
 UndefinedTensorImpl::UndefinedTensorImpl()
-: TensorImpl(DispatchKey::Undefined, caffe2::TypeMeta(), c10::nullopt) {
+    : TensorImpl(DispatchKey::Undefined, caffe2::TypeMeta(), c10::nullopt) {
   set_storage_access_should_throw();
 }
 
@@ -19,7 +19,8 @@ int64_t UndefinedTensorImpl::stride(int64_t d) const {
 
 #ifdef DEBUG
 bool UndefinedTensorImpl::has_storage() const {
-  TORCH_INTERNAL_ASSERT_DEBUG_ONLY(!storage_, "UndefinedTensorImpl assumes that storage_ is never set");
+  TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+      !storage_, "UndefinedTensorImpl assumes that storage_ is never set");
   return false;
 }
 #endif
@@ -39,4 +40,4 @@ const char* UndefinedTensorImpl::tensorimpl_type_name() const {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 UndefinedTensorImpl UndefinedTensorImpl::_singleton;
 
-}
+} // namespace c10
diff --git a/c10/core/UndefinedTensorImpl.h b/c10/core/UndefinedTensorImpl.h
index 23d48426dbb..fc650185049 100644
--- a/c10/core/UndefinedTensorImpl.h
+++ b/c10/core/UndefinedTensorImpl.h
@@ -7,13 +7,14 @@ namespace c10 {
 struct C10_API UndefinedTensorImpl final : public TensorImpl {
  public:
   // Without this, we get:
-  //  error: identifier "at::UndefinedTensorImpl::_singleton" is undefined in device code
+  //  error: identifier "at::UndefinedTensorImpl::_singleton" is undefined in
+  //  device code
   // (ostensibly because the constexpr tricks MSVC into trying to compile this
   // function for device as well).
 #ifdef _WIN32
-  static inline TensorImpl * singleton() {
+  static inline TensorImpl* singleton() {
 #else
-  static constexpr inline TensorImpl * singleton() {
+  static constexpr inline TensorImpl* singleton() {
 #endif
     return &_singleton;
   }
@@ -24,7 +25,8 @@ struct C10_API UndefinedTensorImpl final : public TensorImpl {
   bool has_storage() const override;
 #endif
   void set_storage_offset(int64_t offset) override;
-private:
+
+ private:
   UndefinedTensorImpl();
   static UndefinedTensorImpl _singleton;
   const char* tensorimpl_type_name() const override;
diff --git a/c10/core/WrapDimMinimal.h b/c10/core/WrapDimMinimal.h
index 32d3788c7f1..01cb1c641a1 100644
--- a/c10/core/WrapDimMinimal.h
+++ b/c10/core/WrapDimMinimal.h
@@ -4,10 +4,17 @@
 
 namespace c10 {
 
-static inline int64_t maybe_wrap_dim(int64_t dim, int64_t dim_post_expr, bool wrap_scalar=true) {
+static inline int64_t maybe_wrap_dim(
+    int64_t dim,
+    int64_t dim_post_expr,
+    bool wrap_scalar = true) {
   if (dim_post_expr <= 0) {
     if (!wrap_scalar) {
-      TORCH_CHECK_INDEX(false, "dimension specified as ", dim, " but tensor has no dimensions");
+      TORCH_CHECK_INDEX(
+          false,
+          "dimension specified as ",
+          dim,
+          " but tensor has no dimensions");
     }
     dim_post_expr = 1; // this will make range [-1, 0]
   }
@@ -15,12 +22,19 @@ static inline int64_t maybe_wrap_dim(int64_t dim, int64_t dim_post_expr, bool wr
   int64_t min = -dim_post_expr;
   int64_t max = dim_post_expr - 1;
   if (dim < min || dim > max) {
-    TORCH_CHECK_INDEX(false,
-      "Dimension out of range (expected to be in range of [",
-      min, ", ", max, "], but got ", dim, ")");
+    TORCH_CHECK_INDEX(
+        false,
+        "Dimension out of range (expected to be in range of [",
+        min,
+        ", ",
+        max,
+        "], but got ",
+        dim,
+        ")");
   }
-  if (dim < 0) dim += dim_post_expr;
+  if (dim < 0)
+    dim += dim_post_expr;
   return dim;
 }
 
-}
+} // namespace c10
diff --git a/c10/core/impl/DeviceGuardImplInterface.cpp b/c10/core/impl/DeviceGuardImplInterface.cpp
index e44c76376ec..6cee6ed583a 100644
--- a/c10/core/impl/DeviceGuardImplInterface.cpp
+++ b/c10/core/impl/DeviceGuardImplInterface.cpp
@@ -5,11 +5,15 @@ namespace impl {
 
 // NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
 std::atomic<const DeviceGuardImplInterface*>
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-device_guard_impl_registry[static_cast<size_t>(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)];
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+    device_guard_impl_registry[static_cast<size_t>(
+        DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)];
 
-DeviceGuardImplRegistrar::DeviceGuardImplRegistrar(DeviceType type, const DeviceGuardImplInterface* impl) {
+DeviceGuardImplRegistrar::DeviceGuardImplRegistrar(
+    DeviceType type,
+    const DeviceGuardImplInterface* impl) {
   device_guard_impl_registry[static_cast<size_t>(type)].store(impl);
 }
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/DeviceGuardImplInterface.h b/c10/core/impl/DeviceGuardImplInterface.h
index b9edf56ddde..e9a3d880c72 100644
--- a/c10/core/impl/DeviceGuardImplInterface.h
+++ b/c10/core/impl/DeviceGuardImplInterface.h
@@ -30,16 +30,16 @@ class DataPtr;
  * should map one-to-one with actual event flags for those backends.
  */
 enum class EventFlag {
-    PYTORCH_DEFAULT,
-    BACKEND_DEFAULT,
-    // CUDA flags
-    CUDA_EVENT_DEFAULT,
-    CUDA_EVENT_DISABLE_TIMING, // PyTorch-default for CUDA
-    // HIP flags
-    HIP_EVENT_DEFAULT,
-    HIP_EVENT_DISABLE_TIMING, // PyTorch-default for HIP
-    // FOR TESTING ONLY
-    INVALID
+  PYTORCH_DEFAULT,
+  BACKEND_DEFAULT,
+  // CUDA flags
+  CUDA_EVENT_DEFAULT,
+  CUDA_EVENT_DISABLE_TIMING, // PyTorch-default for CUDA
+  // HIP flags
+  HIP_EVENT_DEFAULT,
+  HIP_EVENT_DISABLE_TIMING, // PyTorch-default for HIP
+  // FOR TESTING ONLY
+  INVALID
 };
 
 namespace impl {
@@ -126,47 +126,44 @@ struct C10_API DeviceGuardImplInterface {
    */
   virtual Stream exchangeStream(Stream) const noexcept = 0;
 
-/**
- * Destroys the given event.
- */
-  virtual void destroyEvent (
-    void* event,
-    const DeviceIndex device_index) const noexcept { }
+  /**
+   * Destroys the given event.
+   */
+  virtual void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept {}
 
-/**
- * Increments the event's version and enqueues a job with this version
- * in the stream's work queue. When the stream process that job
- * it notifies all streams waiting on / blocked by that version of the
- * event to continue and marks that version as recorded.
- * */
+  /**
+   * Increments the event's version and enqueues a job with this version
+   * in the stream's work queue. When the stream process that job
+   * it notifies all streams waiting on / blocked by that version of the
+   * event to continue and marks that version as recorded.
+   * */
   virtual void record(
-    void** event,
-    const Stream& stream,
-    const DeviceIndex device_index,
-    const c10::EventFlag flag) const {
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const c10::EventFlag flag) const {
     TORCH_CHECK(false, "Backend doesn't support events.");
   }
 
-/**
- * Does nothing if the event has not been scheduled to be recorded.
- * If the event was previously enqueued to be recorded, a command
- * to wait for the version of the event that exists at the time of this call
- * is inserted in the stream's work queue.
- * When the stream reaches this command it will stop processing
- * additional commands until that version of the event is marked as recorded.
- */
-  virtual void block(
-    void* event,
-    const Stream& stream) const {
+  /**
+   * Does nothing if the event has not been scheduled to be recorded.
+   * If the event was previously enqueued to be recorded, a command
+   * to wait for the version of the event that exists at the time of this call
+   * is inserted in the stream's work queue.
+   * When the stream reaches this command it will stop processing
+   * additional commands until that version of the event is marked as recorded.
+   */
+  virtual void block(void* event, const Stream& stream) const {
     TORCH_CHECK(false, "Backend doesn't support events.");
   }
 
-/**
- * Returns true if (and only if)
- *  (1) the event has never been scheduled to be recorded
- *  (2) the current version is marked as recorded.
- * Returns false otherwise.
- */
+  /**
+   * Returns true if (and only if)
+   *  (1) the event has never been scheduled to be recorded
+   *  (2) the current version is marked as recorded.
+   * Returns false otherwise.
+   */
   virtual bool queryEvent(void* event) const {
     TORCH_CHECK(false, "Backend doesn't support events.");
   }
@@ -178,13 +175,13 @@ struct C10_API DeviceGuardImplInterface {
    */
   virtual DeviceIndex deviceCount() const noexcept = 0;
 
-
   /**
    * Ensure the caching allocator (if any) is aware that the given DataPtr is
    * being used on the given stream, and that it should thus avoid recycling the
    * DataPtr until all work on that stream is done.
    */
-  virtual void recordDataPtrOnStream(const c10::DataPtr&, const Stream&) const { }
+  virtual void recordDataPtrOnStream(const c10::DataPtr&, const Stream&) const {
+  }
 
   /**
    * Intended use of this class is to leak the DeviceGuardImpl at program end.
@@ -228,23 +225,21 @@ struct NoOpDeviceGuardImpl final : public DeviceGuardImplInterface {
   }
 
   // Event-related functions
-  void record(void** event,
-    const Stream& stream,
-    const DeviceIndex device_index,
-    const EventFlag flag) const override {
+  void record(
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const EventFlag flag) const override {
     TORCH_CHECK(false, D, " backend doesn't support events.");
   }
-  void block(
-    void* event,
-    const Stream& stream) const override {
+  void block(void* event, const Stream& stream) const override {
     TORCH_CHECK(false, D, " backend doesn't support events.")
   }
   bool queryEvent(void* event) const override {
     TORCH_CHECK(false, D, " backend doesn't support events.")
   }
-  void destroyEvent(
-    void* event,
-    const DeviceIndex device_index) const noexcept override { }
+  void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept override {}
 };
 
 // The registry is NON-owning.  Each stored pointer is std::atomic so
@@ -262,7 +257,8 @@ struct NoOpDeviceGuardImpl final : public DeviceGuardImplInterface {
 // putting them in the registry.  This is done by deleting the destructor
 // on DeviceGuardImplInterface.
 extern C10_API std::atomic<const DeviceGuardImplInterface*>
-device_guard_impl_registry[static_cast<size_t>(DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)];
+    device_guard_impl_registry[static_cast<size_t>(
+        DeviceType::COMPILE_TIME_MAX_DEVICE_TYPES)];
 
 // I can't conveniently use c10/util/Registry.h for the following reason:
 // c10/util/Registry.h gives me a slow way of Create'ing a object of some
@@ -273,12 +269,13 @@ device_guard_impl_registry[static_cast<size_t>(DeviceType::COMPILE_TIME_MAX_DEVI
 // into device_guard_impl_registry.
 
 class C10_API DeviceGuardImplRegistrar {
-public:
+ public:
   DeviceGuardImplRegistrar(DeviceType, const DeviceGuardImplInterface*);
 };
 
-#define C10_REGISTER_GUARD_IMPL(DevType, DeviceGuardImpl) \
-  static ::c10::impl::DeviceGuardImplRegistrar C10_ANONYMOUS_VARIABLE(g_##DeviceType)(::c10::DeviceType::DevType, new DeviceGuardImpl());
+#define C10_REGISTER_GUARD_IMPL(DevType, DeviceGuardImpl)              \
+  static ::c10::impl::DeviceGuardImplRegistrar C10_ANONYMOUS_VARIABLE( \
+      g_##DeviceType)(::c10::DeviceType::DevType, new DeviceGuardImpl());
 
 inline const DeviceGuardImplInterface* getDeviceGuardImpl(DeviceType type) {
   // Two adjacent int16_t fields DeviceType and DeviceIndex has field access
@@ -301,4 +298,5 @@ inline bool hasDeviceGuardImpl(DeviceType type) {
   return device_guard_impl_registry[static_cast<size_t>(type)].load();
 }
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/FakeGuardImpl.h b/c10/core/impl/FakeGuardImpl.h
index 24f48fb8fed..2d47db0fdb1 100644
--- a/c10/core/impl/FakeGuardImpl.h
+++ b/c10/core/impl/FakeGuardImpl.h
@@ -60,17 +60,16 @@ struct FakeGuardImpl final : public DeviceGuardImplInterface {
 
   // Event-related functions
   void record(
-    void** event,
-    const Stream& stream,
-    const DeviceIndex device_index,
-    const EventFlag flag) const override { }
-  void block(
-    void* event,
-    const Stream& stream) const override { }
-  bool queryEvent(void* event) const override { return true; }
-  void destroyEvent(
-    void* event,
-    const DeviceIndex device_index) const noexcept override { }
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const EventFlag flag) const override {}
+  void block(void* event, const Stream& stream) const override {}
+  bool queryEvent(void* event) const override {
+    return true;
+  }
+  void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept override {}
 
   // Convenience methods for testing
   static DeviceIndex getDeviceIndex() {
@@ -87,9 +86,11 @@ struct FakeGuardImpl final : public DeviceGuardImplInterface {
   static void resetStreams() {
     current_streams_.fill(0);
   }
-private:
+
+ private:
   thread_local static DeviceIndex current_device_;
-  thread_local static std::array<StreamId, kFakeGuardImplMaxDevices> current_streams_;
+  thread_local static std::array<StreamId, kFakeGuardImplMaxDevices>
+      current_streams_;
 };
 
 template <DeviceType T>
@@ -99,7 +100,8 @@ template <DeviceType T>
 constexpr DeviceType FakeGuardImpl<T>::static_type;
 
 template <DeviceType T>
-thread_local std::array<StreamId, kFakeGuardImplMaxDevices> FakeGuardImpl<T>::current_streams_ = {0,0,0,0,0,0,0,0};
+thread_local std::array<StreamId, kFakeGuardImplMaxDevices>
+    FakeGuardImpl<T>::current_streams_ = {0, 0, 0, 0, 0, 0, 0, 0};
 
-
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/InlineDeviceGuard.h b/c10/core/impl/InlineDeviceGuard.h
index fc3d64444a6..007c9e9bcfc 100644
--- a/c10/core/impl/InlineDeviceGuard.h
+++ b/c10/core/impl/InlineDeviceGuard.h
@@ -1,18 +1,17 @@
 #pragma once
 
-// This file provides implementations of InlineDeviceGuard and InlineOptionalDeviceGuard.
+// This file provides implementations of InlineDeviceGuard and
+// InlineOptionalDeviceGuard.
 
 #include <c10/core/Device.h>
 #include <c10/core/impl/DeviceGuardImplInterface.h>
 #include <c10/core/impl/VirtualGuardImpl.h>
-#include <c10/util/Optional.h>
 #include <c10/util/C++17.h>
+#include <c10/util/Optional.h>
 
 namespace c10 {
 namespace impl {
 
-
-
 /**
  * A DeviceGuard is an RAII class that sets a device to some value
  * on construction, and resets the device to its original value on
@@ -54,7 +53,7 @@ namespace impl {
  */
 template <typename T>
 class InlineDeviceGuard {
-public:
+ public:
   // Note [Omitted default constructor from RAII]
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   // In principle, we could add a default constructor to
@@ -69,25 +68,36 @@ public:
 
   /// Set the current device to the passed Device.
   explicit InlineDeviceGuard(Device device)
-    : impl_(device.type())
-    , original_device_(device.index() == -1 ? impl_.getDevice() : impl_.exchangeDevice(device))
-    , current_device_(device.index() == -1 ? original_device_ : device)
-    {}
+      : impl_(device.type()),
+        original_device_(
+            device.index() == -1 ? impl_.getDevice()
+                                 : impl_.exchangeDevice(device)),
+        current_device_(device.index() == -1 ? original_device_ : device) {}
 
   /// Set the current device index to the passed DeviceIndex.  (The
   /// device type is inferred from the template parameter T).
-  template <typename U=T, typename=typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type>
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          !std::is_same<U, VirtualGuardImpl>::value>::type>
   explicit InlineDeviceGuard(DeviceIndex device_index)
-    : InlineDeviceGuard(Device(U::static_type, device_index)) {}
+      : InlineDeviceGuard(Device(U::static_type, device_index)) {}
 
   /// Construct an InlineDeviceGuard using VirtualGuardImpl with an explicit
   /// DeviceGuardImplInterface pointer.
-  template <typename U=T, typename=typename std::enable_if<std::is_same<U, VirtualGuardImpl>::value>::type>
-  explicit InlineDeviceGuard(Device device, const DeviceGuardImplInterface* impl)
-    : impl_(VirtualGuardImpl(impl ? impl : getDeviceGuardImpl(device.type())))
-    , original_device_(device.index() == -1 ? impl_.getDevice() : impl_.exchangeDevice(device))
-    , current_device_(device.index() == -1 ? original_device_ : device)
-    {}
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          std::is_same<U, VirtualGuardImpl>::value>::type>
+  explicit InlineDeviceGuard(
+      Device device,
+      const DeviceGuardImplInterface* impl)
+      : impl_(
+            VirtualGuardImpl(impl ? impl : getDeviceGuardImpl(device.type()))),
+        original_device_(
+            device.index() == -1 ? impl_.getDevice()
+                                 : impl_.exchangeDevice(device)),
+        current_device_(device.index() == -1 ? original_device_ : device) {}
 
   /// Copy is disallowed
   InlineDeviceGuard(const InlineDeviceGuard<T>&) = delete;
@@ -103,12 +113,17 @@ public:
   }
 
   /// Sets the device to the given one.
-  template <typename U=T, typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value, int>::type = 0>
+  template <
+      typename U = T,
+      typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value, int>::
+          type = 0>
   void set_device(at::Device device) {
-    AT_ASSERT((U::static_type == DeviceType::HIP && device.is_cuda()) ||
-              device.type() == U::static_type);
+    AT_ASSERT(
+        (U::static_type == DeviceType::HIP && device.is_cuda()) ||
+        device.type() == U::static_type);
     auto index = device.index();
-    if (index == -1) return;
+    if (index == -1)
+      return;
     impl_.setDevice(device);
     current_device_ = device;
   }
@@ -116,8 +131,8 @@ public:
   /// Resets the currently set device to its original device, and then sets the
   /// current device to the passed device.  This is effectively equivalent to
   /// set_device when a guard supports only a single device type.
-  template <typename U=T>
-  typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value >::type
+  template <typename U = T>
+  typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type
   reset_device(at::Device device) {
     set_device(device);
   }
@@ -139,11 +154,14 @@ public:
   /// that it is unnecessary.
   ///
   /// Optional argument is for testing only.
-  template <typename U=T>
-  typename std::enable_if<std::is_same<U, VirtualGuardImpl>::value >::type
-  reset_device(at::Device device, const impl::DeviceGuardImplInterface* impl = nullptr) {
+  template <typename U = T>
+  typename std::enable_if<std::is_same<U, VirtualGuardImpl>::value>::type
+  reset_device(
+      at::Device device,
+      const impl::DeviceGuardImplInterface* impl = nullptr) {
     auto index = device.index();
-    if (index == -1) return;
+    if (index == -1)
+      return;
     if (device.type() == original_device_.type()) {
       AT_ASSERT(impl == nullptr || impl->type() == device.type());
       impl_.setDevice(device);
@@ -175,10 +193,10 @@ public:
     return current_device_;
   }
 
-protected:
+ protected:
   T impl_;
 
-private:
+ private:
   Device original_device_;
   Device current_device_;
 };
@@ -193,29 +211,33 @@ private:
  */
 template <typename T>
 class InlineOptionalDeviceGuard {
-public:
+ public:
   // Note [Explicit initialization of optional fields]
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   // Explicit initialization of optional fields
-  // required to workaround an nvcc bug; see https://github.com/pytorch/pytorch/issues/12117
+  // required to workaround an nvcc bug; see
+  // https://github.com/pytorch/pytorch/issues/12117
 
   /// Creates an uninitialized OptionalDeviceGuard.
   explicit InlineOptionalDeviceGuard()
-    : guard_() // See Note [Explicit initialization of optional fields]
-    {}
+      : guard_() // See Note [Explicit initialization of optional fields]
+  {}
 
   /// Set the current device to the passed Device, if it is not nullopt.
   explicit InlineOptionalDeviceGuard(optional<Device> device_opt)
-    : guard_() { // See Note [Explicit initialization of optional fields]
+      : guard_() { // See Note [Explicit initialization of optional fields]
     if (device_opt.has_value()) {
       guard_.emplace(device_opt.value());
     }
   }
 
   /// Set the current device to the passed DeviceIndex, if it is not nullopt.
-  template <typename U=T, typename=typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type>
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          !std::is_same<U, VirtualGuardImpl>::value>::type>
   explicit InlineOptionalDeviceGuard(optional<DeviceIndex> device_index_opt)
-    : guard_() { // See Note [Explicit initialization of optional fields]
+      : guard_() { // See Note [Explicit initialization of optional fields]
     if (device_index_opt.has_value()) {
       guard_.emplace(device_index_opt.value());
     }
@@ -225,7 +247,7 @@ public:
   /// and result in initialized OptionalDeviceGuard.
   template <typename... Args>
   explicit InlineOptionalDeviceGuard(Args&&... args)
-    : guard_(in_place, std::forward<Args>(args)...) {}
+      : guard_(in_place, std::forward<Args>(args)...) {}
 
   // TODO: Consider readding Tensor and TensorList constructors here, when
   // Tensor moves to c10.  (These are only valid on OptionalDeviceGuard,
@@ -313,11 +335,15 @@ public:
   //
   // We could solve this with an extra thread-local variable.  But no one is
   // actually using move-assignment.  So just get rid of it.
-  InlineOptionalDeviceGuard& operator=(InlineOptionalDeviceGuard&& other) = delete;
+  InlineOptionalDeviceGuard& operator=(InlineOptionalDeviceGuard&& other) =
+      delete;
 
   /// Sets the device to the given one.  Initializes OptionalDeviceGuard if it
   /// is not already initialized.
-  template <typename U=T, typename=typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type>
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          !std::is_same<U, VirtualGuardImpl>::value>::type>
   void set_device(at::Device device) {
     if (!guard_.has_value()) {
       guard_.emplace(device);
@@ -333,8 +359,13 @@ public:
   /// See notes on why this is called reset_device on InlineDeviceGuard.
   ///
   /// Optional argument is for testing only.
-  template <typename U=T, typename=typename std::enable_if<std::is_same<U, VirtualGuardImpl>::value>::type>
-  void reset_device(at::Device device, const DeviceGuardImplInterface* impl = nullptr) {
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          std::is_same<U, VirtualGuardImpl>::value>::type>
+  void reset_device(
+      at::Device device,
+      const DeviceGuardImplInterface* impl = nullptr) {
     if (!guard_.has_value()) {
       guard_.emplace(device, impl);
     } else {
@@ -346,7 +377,10 @@ public:
   /// current device to the passed device.  Initializes the guard if it is
   /// not already initialized.  This is effectively equivalent to set_device
   /// when a guard supports only a single device type.
-  template <typename U=T, typename=typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value>::type>
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          !std::is_same<U, VirtualGuardImpl>::value>::type>
   void reset_device(at::Device device) {
     if (!guard_.has_value()) {
       guard_.emplace(device);
@@ -357,7 +391,10 @@ public:
 
   /// Sets the device index to the given one.  The device type is statically
   /// known.
-  template <typename U=T, typename=typename std::enable_if<!std::is_same<U, VirtualGuardImpl>::value >::type>
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          !std::is_same<U, VirtualGuardImpl>::value>::type>
   void set_index(DeviceIndex index) {
     if (!guard_.has_value()) {
       guard_.emplace(index);
@@ -366,17 +403,19 @@ public:
     }
   }
 
-  /// Returns the device that was set immediately prior to initialization of the,
-  /// guard, or nullopt if the guard is uninitialized.
+  /// Returns the device that was set immediately prior to initialization of
+  /// the, guard, or nullopt if the guard is uninitialized.
   optional<Device> original_device() const {
-    return guard_.has_value() ? make_optional(guard_->original_device()) : nullopt;
+    return guard_.has_value() ? make_optional(guard_->original_device())
+                              : nullopt;
   }
 
   /// Returns the most recent device that was set using this device guard,
   /// either from construction, or via set_device, if the guard is initialized,
   /// or nullopt if the guard is uninitialized.
   optional<Device> current_device() const {
-    return guard_.has_value() ? make_optional(guard_->current_device()) : nullopt;
+    return guard_.has_value() ? make_optional(guard_->current_device())
+                              : nullopt;
   }
 
   /// Restore the original device, resetting this guard to uninitialized state.
@@ -384,8 +423,9 @@ public:
     guard_.reset();
   }
 
-private:
+ private:
   optional<InlineDeviceGuard<T>> guard_;
 };
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/InlineEvent.h b/c10/core/impl/InlineEvent.h
index 4127b69a78b..003a0b8407a 100644
--- a/c10/core/impl/InlineEvent.h
+++ b/c10/core/impl/InlineEvent.h
@@ -2,22 +2,19 @@
 
 #include <c10/core/DeviceType.h>
 #include <c10/core/Stream.h>
-#include <c10/util/Exception.h>
 #include <c10/core/impl/DeviceGuardImplInterface.h>
+#include <c10/util/Exception.h>
 
 namespace c10 {
 namespace impl {
 
 template <typename T>
 struct InlineEvent final {
-
   InlineEvent() = delete;
   InlineEvent(
-    const DeviceType _device_type,
-    const EventFlag _flag = EventFlag::PYTORCH_DEFAULT)
-  : backend_{_device_type},
-    device_type_{_device_type},
-    flag_{_flag} { }
+      const DeviceType _device_type,
+      const EventFlag _flag = EventFlag::PYTORCH_DEFAULT)
+      : backend_{_device_type}, device_type_{_device_type}, flag_{_flag} {}
 
   // Copy constructor and copy assignment operator (deleted)
   InlineEvent(const InlineEvent&) = delete;
@@ -25,7 +22,7 @@ struct InlineEvent final {
 
   // Move constructor and move assignment operator
   InlineEvent(InlineEvent&& other)
-  : InlineEvent(other.device_type_, other.flag_) {
+      : InlineEvent(other.device_type_, other.flag_) {
     swap(std::move(other));
   }
   InlineEvent& operator=(InlineEvent&& other) {
@@ -43,27 +40,36 @@ struct InlineEvent final {
   }
 
   ~InlineEvent() noexcept {
-    if (event_) backend_.destroyEvent(event_, device_index_);
+    if (event_)
+      backend_.destroyEvent(event_, device_index_);
   }
 
-  DeviceType device_type() const noexcept { return device_type_; }
-  DeviceIndex device_index() const noexcept { return device_index_; }
-  EventFlag flag() const noexcept { return flag_; }
-  bool was_marked_for_recording() const noexcept { return was_marked_for_recording_; }
-
+  DeviceType device_type() const noexcept {
+    return device_type_;
+  }
+  DeviceIndex device_index() const noexcept {
+    return device_index_;
+  }
+  EventFlag flag() const noexcept {
+    return flag_;
+  }
+  bool was_marked_for_recording() const noexcept {
+    return was_marked_for_recording_;
+  }
 
   void recordOnce(const Stream& stream) {
-    if (!was_marked_for_recording_) record(stream);
+    if (!was_marked_for_recording_)
+      record(stream);
   }
 
   void record(const Stream& stream) {
     TORCH_CHECK(
-      stream.device_type() == device_type_,
-      "Event device type ",
-      DeviceTypeName(device_type_),
-      " does not match recording stream's device type ",
-      DeviceTypeName(stream.device_type()),
-      ".");
+        stream.device_type() == device_type_,
+        "Event device type ",
+        DeviceTypeName(device_type_),
+        " does not match recording stream's device type ",
+        DeviceTypeName(stream.device_type()),
+        ".");
 
     backend_.record(&event_, stream, device_index_, flag_);
     was_marked_for_recording_ = true;
@@ -71,25 +77,27 @@ struct InlineEvent final {
   }
 
   void block(const Stream& stream) const {
-    if (!was_marked_for_recording_) return;
+    if (!was_marked_for_recording_)
+      return;
 
     TORCH_CHECK(
-      stream.device_type() == device_type_,
-      "Event device type ",
-      DeviceTypeName(device_type_),
-      " does not match blocking stream's device type ",
-      DeviceTypeName(stream.device_type()),
-      ".");
+        stream.device_type() == device_type_,
+        "Event device type ",
+        DeviceTypeName(device_type_),
+        " does not match blocking stream's device type ",
+        DeviceTypeName(stream.device_type()),
+        ".");
 
     backend_.block(event_, stream);
   }
 
   bool query() const {
-    if (!was_marked_for_recording_) return true;
+    if (!was_marked_for_recording_)
+      return true;
     return backend_.queryEvent(event_);
   }
 
-private:
+ private:
   void* event_ = nullptr;
   T backend_;
   DeviceType device_type_;
@@ -98,5 +106,5 @@ private:
   bool was_marked_for_recording_ = false;
 };
 
-} // impl
-} // c10
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/InlineStreamGuard.h b/c10/core/impl/InlineStreamGuard.h
index 42d4a473c4e..295e3095e7a 100644
--- a/c10/core/impl/InlineStreamGuard.h
+++ b/c10/core/impl/InlineStreamGuard.h
@@ -16,27 +16,34 @@ namespace impl {
  */
 template <typename T>
 class InlineStreamGuard : private InlineDeviceGuard<T> {
-public:
+ public:
   /// No default constructor, see Note [Omitted default constructor from RAII]
   explicit InlineStreamGuard() = delete;
 
   /// Set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream.
   explicit InlineStreamGuard(Stream stream)
-    : InlineDeviceGuard<T>(stream.device())
-    , original_stream_of_original_device_(this->impl_.getStream(original_device()))
-    , original_stream_of_current_device_(this->impl_.exchangeStream(stream))
-    , current_stream_(stream)
-    {}
+      : InlineDeviceGuard<T>(stream.device()),
+        original_stream_of_original_device_(
+            this->impl_.getStream(original_device())),
+        original_stream_of_current_device_(this->impl_.exchangeStream(stream)),
+        current_stream_(stream) {}
 
   /// This constructor exists purely for testing
-  template <typename U=T, typename=typename std::enable_if<std::is_same<U, VirtualGuardImpl>::value>::type>
-  explicit InlineStreamGuard(Stream stream, const DeviceGuardImplInterface* impl)
-    : InlineDeviceGuard<T>(stream.device(), impl ? impl : getDeviceGuardImpl(stream.device_type()))
-    , original_stream_of_original_device_(this->impl_.getStream(original_device()))
-    , original_stream_of_current_device_(this->impl_.exchangeStream(stream))
-    , current_stream_(stream)
-    {}
+  template <
+      typename U = T,
+      typename = typename std::enable_if<
+          std::is_same<U, VirtualGuardImpl>::value>::type>
+  explicit InlineStreamGuard(
+      Stream stream,
+      const DeviceGuardImplInterface* impl)
+      : InlineDeviceGuard<T>(
+            stream.device(),
+            impl ? impl : getDeviceGuardImpl(stream.device_type())),
+        original_stream_of_original_device_(
+            this->impl_.getStream(original_device())),
+        original_stream_of_current_device_(this->impl_.exchangeStream(stream)),
+        current_stream_(stream) {}
 
   /// Copy is disallowed
   InlineStreamGuard(const InlineStreamGuard<T>&) = delete;
@@ -110,8 +117,9 @@ public:
     return InlineDeviceGuard<T>::original_device();
   }
 
-private:
-  Stream original_stream_of_original_device_; // what the user probably cares about
+ private:
+  Stream
+      original_stream_of_original_device_; // what the user probably cares about
   Stream original_stream_of_current_device_; // what we need to restore
   Stream current_stream_;
 };
@@ -123,17 +131,16 @@ private:
  */
 template <typename T>
 class InlineOptionalStreamGuard {
-public:
+ public:
   /// Creates an uninitialized stream guard.
   explicit InlineOptionalStreamGuard()
-    : guard_() // See Note [Explicit initialization of optional fields]
-    {}
+      : guard_() // See Note [Explicit initialization of optional fields]
+  {}
 
   /// Set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream,
   /// if the passed stream is not nullopt.
-  explicit InlineOptionalStreamGuard(optional<Stream> stream_opt)
-    : guard_() {
+  explicit InlineOptionalStreamGuard(optional<Stream> stream_opt) : guard_() {
     if (stream_opt.has_value()) {
       guard_.emplace(stream_opt.value());
     }
@@ -142,13 +149,14 @@ public:
   /// All constructors of StreamGuard are valid for OptionalStreamGuard
   template <typename... Args>
   explicit InlineOptionalStreamGuard(Args&&... args)
-    : guard_(in_place, std::forward<Args>(args)...) {}
+      : guard_(in_place, std::forward<Args>(args)...) {}
 
   // See Note [Move construction for RAII guards is tricky]
   InlineOptionalStreamGuard(InlineOptionalStreamGuard<T>&& other) = delete;
 
   // See Note [Move assignment for RAII guards is tricky]
-  InlineOptionalStreamGuard& operator=(InlineOptionalStreamGuard&& other) = delete;
+  InlineOptionalStreamGuard& operator=(InlineOptionalStreamGuard&& other) =
+      delete;
 
   /// Resets the currently set stream to the original stream and
   /// the currently set device to the original device.  Then,
@@ -166,28 +174,31 @@ public:
   /// Returns the stream that was set at the time the guard was most recently
   /// initialized, or nullopt if the guard is uninitialized.
   optional<Stream> original_stream() const {
-    return guard_.has_value() ? make_optional(guard_->original_stream()) : nullopt;
+    return guard_.has_value() ? make_optional(guard_->original_stream())
+                              : nullopt;
   }
 
   /// Returns the most recent stream that was set using this stream guard,
-  /// either from construction, or via reset_stream, if the guard is initialized,
-  /// or nullopt if the guard is uninitialized.
+  /// either from construction, or via reset_stream, if the guard is
+  /// initialized, or nullopt if the guard is uninitialized.
   optional<Stream> current_stream() const {
-    return guard_.has_value() ? make_optional(guard_->current_stream()) : nullopt;
+    return guard_.has_value() ? make_optional(guard_->current_stream())
+                              : nullopt;
   }
 
-  /// Restore the original device and stream, resetting this guard to uninitialized state.
+  /// Restore the original device and stream, resetting this guard to
+  /// uninitialized state.
   void reset() {
     guard_.reset();
   }
 
-private:
+ private:
   optional<InlineStreamGuard<T>> guard_;
 };
 
 template <typename T>
 class InlineMultiStreamGuard {
-public:
+ public:
   /// Calls `set_stream` on each of the streams in the list.
   /// This may be useful if you need to set different streams
   /// for different devices.
@@ -216,10 +227,10 @@ public:
     }
   }
 
-protected:
+ protected:
   optional<T> impl_;
 
-private:
+ private:
   /// The original streams that were active on all devices.
   std::vector<Stream> original_streams_;
 
@@ -228,13 +239,17 @@ private:
     DeviceType type = streams[0].device_type();
     for (size_t idx = 1; idx < streams.size(); idx++) {
       TORCH_CHECK_VALUE(
-        streams[idx].device_type() == type,
-        "Streams have a mix of device types: stream 0 is on ",
-        streams[0].device(), " while stream ", idx, " is on device ",
-        streams[idx].device());
+          streams[idx].device_type() == type,
+          "Streams have a mix of device types: stream 0 is on ",
+          streams[0].device(),
+          " while stream ",
+          idx,
+          " is on device ",
+          streams[idx].device());
     }
     return type;
   }
 };
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/LocalDispatchKeySet.cpp b/c10/core/impl/LocalDispatchKeySet.cpp
index 16936e4fa62..e0a3c6b46ad 100644
--- a/c10/core/impl/LocalDispatchKeySet.cpp
+++ b/c10/core/impl/LocalDispatchKeySet.cpp
@@ -8,12 +8,12 @@ namespace impl {
 // NB: POD, must be zero initialized!
 // Note [TLS Initialization]
 // We wanted raw_local_dispatch_key_set to be initialized with non-zero state
-// e.g. BackendSelect and InplaceOrView in included set.  But certain Windows compiler (e.g the one
-// used in ARVR tests) only allow TLS to be zero-initialized.
-// To preserve the invariant that raw TLS storage of the default state is zero,
-// we obtain the actual include keyset by XORing raw_local_dispatch_key_set.included_
-// with c10::default_included_set.  This logic is encapsulated in struct
-// PODLocalDispatchKeySet.
+// e.g. BackendSelect and InplaceOrView in included set.  But certain Windows
+// compiler (e.g the one used in ARVR tests) only allow TLS to be
+// zero-initialized. To preserve the invariant that raw TLS storage of the
+// default state is zero, we obtain the actual include keyset by XORing
+// raw_local_dispatch_key_set.included_ with c10::default_included_set.  This
+// logic is encapsulated in struct PODLocalDispatchKeySet.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 thread_local PODLocalDispatchKeySet raw_local_dispatch_key_set;
 
@@ -28,26 +28,29 @@ void _force_tls_local_dispatch_key_set(LocalDispatchKeySet key_set) {
   raw_local_dispatch_key_set.set_excluded(key_set.excluded_);
 }
 
-// An RAII guard could snapshot and restore the entire state (entire DispatchKeySet) as
-// opposed to only snapshotting and restoring the state of its assigned DispatchKeySet.
-// I'm not sure which is better.  If only the RAII API is used, the two choices are
-// not distinguishable.
+// An RAII guard could snapshot and restore the entire state (entire
+// DispatchKeySet) as opposed to only snapshotting and restoring the state of
+// its assigned DispatchKeySet. I'm not sure which is better.  If only the RAII
+// API is used, the two choices are not distinguishable.
 //
-// However, if the guard chooses to snapshot and restore the entire DispatchKeySet,
-// the interaction with the non-RAII API changes.  Consider this sequence of events:
-// - An RAII guard is declared for a particular DispatchKeySet, but snapshots the entire
+// However, if the guard chooses to snapshot and restore the entire
+// DispatchKeySet, the interaction with the non-RAII API changes.  Consider this
+// sequence of events:
+// - An RAII guard is declared for a particular DispatchKeySet, but snapshots
+// the entire
 //   current DispatchKeySet.
-// - A call to the non-RAII API changes the state for DispatchKeys outside the assigned
+// - A call to the non-RAII API changes the state for DispatchKeys outside the
+// assigned
 //   set.
-// - The RAII guard goes out of scope, restoring the entire DispatchKeySet it snapshotted
-//   (which restores the state for its own assigned DispatchKey and wipes out the state
-//   for the other DispatchKeys set by the non-RAII API).
+// - The RAII guard goes out of scope, restoring the entire DispatchKeySet it
+// snapshotted
+//   (which restores the state for its own assigned DispatchKey and wipes out
+//   the state for the other DispatchKeys set by the non-RAII API).
 
 // RAII API
 
 IncludeDispatchKeyGuard::IncludeDispatchKeyGuard(DispatchKeySet include)
-  : tls_(&raw_local_dispatch_key_set)
-  , include_(include - tls_->included()) {
+    : tls_(&raw_local_dispatch_key_set), include_(include - tls_->included()) {
   if (!include_.empty()) {
     tls_->set_included(tls_->included() | include_);
   }
@@ -60,8 +63,7 @@ IncludeDispatchKeyGuard::~IncludeDispatchKeyGuard() {
 }
 
 ExcludeDispatchKeyGuard::ExcludeDispatchKeyGuard(DispatchKeySet exclude)
-  : tls_(&raw_local_dispatch_key_set)
-  , exclude_(exclude - tls_->excluded()) {
+    : tls_(&raw_local_dispatch_key_set), exclude_(exclude - tls_->excluded()) {
   if (!exclude_.empty()) {
     tls_->set_excluded(tls_->excluded() | exclude_);
   }
@@ -74,7 +76,8 @@ ExcludeDispatchKeyGuard::~ExcludeDispatchKeyGuard() {
 }
 
 // Non-RAII API
-// Please prefer using the RAII API. See declarations in LocalDispatchKeySet.h for details.
+// Please prefer using the RAII API. See declarations in LocalDispatchKeySet.h
+// for details.
 
 bool tls_is_dispatch_key_excluded(DispatchKey x) {
   return raw_local_dispatch_key_set.excluded().has(x);
@@ -115,4 +118,5 @@ bool tls_is_dispatch_keyset_excluded(DispatchKeySet ks) {
 bool tls_is_dispatch_keyset_included(DispatchKeySet ks) {
   return raw_local_dispatch_key_set.included().isSupersetOf(ks);
 }
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/LocalDispatchKeySet.h b/c10/core/impl/LocalDispatchKeySet.h
index b18b4d4de1d..c436dd51af1 100644
--- a/c10/core/impl/LocalDispatchKeySet.h
+++ b/c10/core/impl/LocalDispatchKeySet.h
@@ -36,10 +36,12 @@ struct C10_API PODLocalDispatchKeySet {
 
   // See Note [TLS Initialization]
   DispatchKeySet included() const {
-    return DispatchKeySet(DispatchKeySet::RAW, included_) ^ c10::default_included_set;
+    return DispatchKeySet(DispatchKeySet::RAW, included_) ^
+        c10::default_included_set;
   }
   DispatchKeySet excluded() const {
-    return DispatchKeySet(DispatchKeySet::RAW, excluded_) ^ c10::default_excluded_set;
+    return DispatchKeySet(DispatchKeySet::RAW, excluded_) ^
+        c10::default_excluded_set;
   }
 
   void set_included(DispatchKeySet x) {
@@ -49,11 +51,13 @@ struct C10_API PODLocalDispatchKeySet {
     excluded_ = (x ^ c10::default_excluded_set).raw_repr();
   }
 };
-static_assert(std::is_pod<PODLocalDispatchKeySet>::value, "PODLocalDispatchKeySet must be a POD type.");
+static_assert(
+    std::is_pod<PODLocalDispatchKeySet>::value,
+    "PODLocalDispatchKeySet must be a POD type.");
 
 struct C10_API LocalDispatchKeySet {
   /* implicit */ LocalDispatchKeySet(PODLocalDispatchKeySet x)
-    : included_(x.included()), excluded_(x.excluded()) {}
+      : included_(x.included()), excluded_(x.excluded()) {}
   DispatchKeySet included_;
   DispatchKeySet excluded_;
 };
@@ -63,7 +67,7 @@ struct C10_API LocalDispatchKeySet {
 #if defined(_MSC_VER) || defined(C10_ANDROID)
 C10_API LocalDispatchKeySet tls_local_dispatch_key_set();
 #else // defined(_MSC_VER) || defined(C10_ANDROID)
-  extern C10_API thread_local PODLocalDispatchKeySet raw_local_dispatch_key_set;
+extern C10_API thread_local PODLocalDispatchKeySet raw_local_dispatch_key_set;
 
 inline C10_API LocalDispatchKeySet tls_local_dispatch_key_set() {
   // Don't let people fiddle with the thread_local directly just
@@ -78,15 +82,17 @@ C10_API void _force_tls_local_dispatch_key_set(LocalDispatchKeySet key_set);
 // RAII API for manipulating the thread-local dispatch state.
 
 class C10_API IncludeDispatchKeyGuard {
-public:
+ public:
   IncludeDispatchKeyGuard(DispatchKeySet);
-  IncludeDispatchKeyGuard(DispatchKey k) : IncludeDispatchKeyGuard(DispatchKeySet(k)) {}
+  IncludeDispatchKeyGuard(DispatchKey k)
+      : IncludeDispatchKeyGuard(DispatchKeySet(k)) {}
   IncludeDispatchKeyGuard(const IncludeDispatchKeyGuard&) = delete;
   IncludeDispatchKeyGuard operator=(const IncludeDispatchKeyGuard&) = delete;
   IncludeDispatchKeyGuard(IncludeDispatchKeyGuard&&) = delete;
   IncludeDispatchKeyGuard operator=(IncludeDispatchKeyGuard&&) = delete;
   ~IncludeDispatchKeyGuard();
-private:
+
+ private:
   // A little micro-optimization to save us from tls_get_addr call
   // on destruction
   PODLocalDispatchKeySet* tls_;
@@ -94,15 +100,17 @@ private:
 };
 
 class C10_API ExcludeDispatchKeyGuard {
-public:
+ public:
   ExcludeDispatchKeyGuard(DispatchKeySet);
-  ExcludeDispatchKeyGuard(DispatchKey k) : ExcludeDispatchKeyGuard(DispatchKeySet(k)) {}
+  ExcludeDispatchKeyGuard(DispatchKey k)
+      : ExcludeDispatchKeyGuard(DispatchKeySet(k)) {}
   ExcludeDispatchKeyGuard(const ExcludeDispatchKeyGuard&) = delete;
   ExcludeDispatchKeyGuard operator=(const ExcludeDispatchKeyGuard&) = delete;
   ExcludeDispatchKeyGuard(ExcludeDispatchKeyGuard&&) = delete;
   ExcludeDispatchKeyGuard operator=(ExcludeDispatchKeyGuard&&) = delete;
   ~ExcludeDispatchKeyGuard();
-private:
+
+ private:
   // A little micro-optimization to save us from tls_get_addr call
   // on destruction
   PODLocalDispatchKeySet* tls_;
@@ -120,7 +128,8 @@ private:
 // through that DispatchKey's registered overrides.
 //
 // The non-RAII API is less efficient than the RAII guards because both the
-// getter and setter will do a tls_getaddr lookup (the RAII struct only needs one!)
+// getter and setter will do a tls_getaddr lookup (the RAII struct only needs
+// one!)
 
 C10_API bool tls_is_dispatch_key_excluded(DispatchKey x);
 C10_API void tls_set_dispatch_key_excluded(DispatchKey x, bool desired_state);
@@ -129,4 +138,5 @@ C10_API void tls_set_dispatch_key_included(DispatchKey x, bool desired_state);
 C10_API bool tls_is_dispatch_keyset_excluded(DispatchKeySet ks);
 C10_API bool tls_is_dispatch_keyset_included(DispatchKeySet ks);
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/impl/SizesAndStrides.cpp b/c10/core/impl/SizesAndStrides.cpp
index f6f5abcb5bb..db1d7c61e98 100644
--- a/c10/core/impl/SizesAndStrides.cpp
+++ b/c10/core/impl/SizesAndStrides.cpp
@@ -3,9 +3,13 @@
 namespace c10 {
 namespace impl {
 
-void SizesAndStrides::resizeSlowPath(const size_t newSize, const size_t oldSize) {
+void SizesAndStrides::resizeSlowPath(
+    const size_t newSize,
+    const size_t oldSize) {
   if (newSize <= C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE) {
-    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(!isInline(), "resizeSlowPath called when fast path should have been hit!");
+    TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+        !isInline(),
+        "resizeSlowPath called when fast path should have been hit!");
     int64_t* tempStorage = outOfLineStorage_;
     memcpy(
         &inlineStorage_[0],
@@ -24,15 +28,23 @@ void SizesAndStrides::resizeSlowPath(const size_t newSize, const size_t oldSize)
       // CANNOT USE allocateOutOfLineStorage(newSize) HERE! WOULD
       // OVERWRITE inlineStorage_!
       // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
-      int64_t* tempStorage = static_cast<int64_t *>(malloc(storageBytes(newSize)));
-      TORCH_CHECK(tempStorage, "Could not allocate memory to change Tensor SizesAndStrides!");
+      int64_t* tempStorage =
+          static_cast<int64_t*>(malloc(storageBytes(newSize)));
+      TORCH_CHECK(
+          tempStorage,
+          "Could not allocate memory to change Tensor SizesAndStrides!");
       const auto bytesToCopy = oldSize * sizeof(inlineStorage_[0]);
-      const auto bytesToZero = (newSize > oldSize) ? (newSize - oldSize) * sizeof(tempStorage[0]) : 0;
+      const auto bytesToZero = (newSize > oldSize)
+          ? (newSize - oldSize) * sizeof(tempStorage[0])
+          : 0;
       memcpy(&tempStorage[0], &inlineStorage_[0], bytesToCopy);
       if (bytesToZero) {
         memset(&tempStorage[oldSize], 0, bytesToZero);
       }
-      memcpy(&tempStorage[newSize], &inlineStorage_[C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE], bytesToCopy);
+      memcpy(
+          &tempStorage[newSize],
+          &inlineStorage_[C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE],
+          bytesToCopy);
       if (bytesToZero) {
         memset(&tempStorage[newSize + oldSize], 0, bytesToZero);
       }
@@ -55,7 +67,8 @@ void SizesAndStrides::resizeSlowPath(const size_t newSize, const size_t oldSize)
         resizeOutOfLineStorage(newSize);
       } else {
         // Zero the end of the sizes portion.
-        const auto bytesToZero = (newSize - oldSize) * sizeof(outOfLineStorage_[0]);
+        const auto bytesToZero =
+            (newSize - oldSize) * sizeof(outOfLineStorage_[0]);
         memset(&outOfLineStorage_[oldSize], 0, bytesToZero);
         memset(&outOfLineStorage_[newSize + oldSize], 0, bytesToZero);
       }
diff --git a/c10/core/impl/SizesAndStrides.h b/c10/core/impl/SizesAndStrides.h
index 4f7e19330ac..330779bad5e 100644
--- a/c10/core/impl/SizesAndStrides.h
+++ b/c10/core/impl/SizesAndStrides.h
@@ -19,7 +19,8 @@ namespace impl {
 // the number of strides. The memory layout is as follows:
 //
 // 1 size_t for the size
-// 5 eightbytes of inline sizes and 5 eightbytes of inline strides, OR pointer to out-of-line array
+// 5 eightbytes of inline sizes and 5 eightbytes of inline strides, OR pointer
+// to out-of-line array
 class C10_API SizesAndStrides {
  public:
   // TODO: different iterator types for sizes & strides to prevent
@@ -238,11 +239,16 @@ class C10_API SizesAndStrides {
     if (newSize == oldSize) {
       return;
     }
-    if (C10_LIKELY(newSize <= C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE && isInline())) {
+    if (C10_LIKELY(
+            newSize <= C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE && isInline())) {
       if (oldSize < newSize) {
-        const auto bytesToZero = (newSize - oldSize) * sizeof(inlineStorage_[0]);
+        const auto bytesToZero =
+            (newSize - oldSize) * sizeof(inlineStorage_[0]);
         memset(&inlineStorage_[oldSize], 0, bytesToZero);
-        memset(&inlineStorage_[C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE + oldSize], 0, bytesToZero);
+        memset(
+            &inlineStorage_[C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE + oldSize],
+            0,
+            bytesToZero);
       }
       size_ = newSize;
     } else {
@@ -267,14 +273,19 @@ class C10_API SizesAndStrides {
   }
 
   void allocateOutOfLineStorage(size_t size) {
-    outOfLineStorage_ = static_cast<int64_t *>(malloc(storageBytes(size)));
-    TORCH_CHECK(outOfLineStorage_, "Could not allocate memory for Tensor SizesAndStrides!");
+    outOfLineStorage_ = static_cast<int64_t*>(malloc(storageBytes(size)));
+    TORCH_CHECK(
+        outOfLineStorage_,
+        "Could not allocate memory for Tensor SizesAndStrides!");
   }
 
   void resizeOutOfLineStorage(size_t newSize) {
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(!isInline());
-    outOfLineStorage_ = static_cast<int64_t *>(realloc(outOfLineStorage_, storageBytes(newSize)));
-    TORCH_CHECK(outOfLineStorage_, "Could not allocate memory for Tensor SizesAndStrides!");
+    outOfLineStorage_ = static_cast<int64_t*>(
+        realloc(outOfLineStorage_, storageBytes(newSize)));
+    TORCH_CHECK(
+        outOfLineStorage_,
+        "Could not allocate memory for Tensor SizesAndStrides!");
   }
 
   void copyDataOutline(const SizesAndStrides& rhs) noexcept {
@@ -283,10 +294,9 @@ class C10_API SizesAndStrides {
 
   size_t size_;
   union {
-    int64_t *outOfLineStorage_;
+    int64_t* outOfLineStorage_;
     int64_t inlineStorage_[C10_SIZES_AND_STRIDES_MAX_INLINE_SIZE * 2]{};
   };
-
 };
 
 } // namespace impl
diff --git a/c10/core/impl/VirtualGuardImpl.h b/c10/core/impl/VirtualGuardImpl.h
index 1334cd7cfe9..896a11aa350 100644
--- a/c10/core/impl/VirtualGuardImpl.h
+++ b/c10/core/impl/VirtualGuardImpl.h
@@ -10,12 +10,11 @@ namespace impl {
  * to virtual dispatch on the DeviceGuardImpl registry.
  */
 class VirtualGuardImpl final : public DeviceGuardImplInterface {
-public:
+ public:
   VirtualGuardImpl(DeviceType device_type)
-    : impl_(getDeviceGuardImpl(device_type)) {}
+      : impl_(getDeviceGuardImpl(device_type)) {}
   // This constructor exists purely for testing
-  VirtualGuardImpl(const DeviceGuardImplInterface* impl)
-    : impl_(impl) {}
+  VirtualGuardImpl(const DeviceGuardImplInterface* impl) : impl_(impl) {}
 
   // Copying and moving is OK!
 
@@ -51,34 +50,32 @@ public:
   }
 
   // Event functions
-  void record(void** event,
-    const Stream& stream,
-    const DeviceIndex device_index,
-    const EventFlag flag) const override {
+  void record(
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const EventFlag flag) const override {
     impl_->record(event, stream, device_index, flag);
   }
-  void block(
-    void* event,
-    const Stream& stream) const override {
+  void block(void* event, const Stream& stream) const override {
     impl_->block(event, stream);
   }
   bool queryEvent(void* event) const override {
     return impl_->queryEvent(event);
   }
-  void destroyEvent(
-    void* event,
-    const DeviceIndex device_index) const noexcept override {
+  void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept override {
     impl_->destroyEvent(event, device_index);
   }
 
-  void recordDataPtrOnStream(
-    const c10::DataPtr& data_ptr,
-    const Stream& stream) const override {
+  void recordDataPtrOnStream(const c10::DataPtr& data_ptr, const Stream& stream)
+      const override {
     impl_->recordDataPtrOnStream(data_ptr, stream);
   }
 
-private:
+ private:
   const DeviceGuardImplInterface* impl_ = nullptr;
 };
 
-}} // namespace c10::impl
+} // namespace impl
+} // namespace c10
diff --git a/c10/core/thread_pool.cpp b/c10/core/thread_pool.cpp
index b567c018a68..122732fd1b2 100644
--- a/c10/core/thread_pool.cpp
+++ b/c10/core/thread_pool.cpp
@@ -3,9 +3,9 @@
 namespace c10 {
 
 ThreadPool::ThreadPool(
-      int pool_size,
-      int numa_node_id,
-      std::function<void()> init_thread)
+    int pool_size,
+    int numa_node_id,
+    std::function<void()> init_thread)
     : threads_(pool_size < 0 ? defaultNumThreads() : pool_size),
       running_(true),
       complete_(true),
@@ -13,7 +13,7 @@ ThreadPool::ThreadPool(
       total_(threads_.size()),
       numa_node_id_(numa_node_id) {
   for (std::size_t i = 0; i < threads_.size(); ++i) {
-    threads_[i] = std::thread([this, i, init_thread](){
+    threads_[i] = std::thread([this, i, init_thread]() {
       if (init_thread) {
         init_thread();
       }
diff --git a/c10/core/thread_pool.h b/c10/core/thread_pool.h
index 33a60aa14cc..3fadd2add89 100644
--- a/c10/core/thread_pool.h
+++ b/c10/core/thread_pool.h
@@ -50,9 +50,9 @@ class C10_API ThreadPool : public c10::TaskThreadPoolBase {
     const std::function<void(std::size_t)> with_id;
 
     explicit task_element_t(std::function<void()> f)
-      : run_with_id(false), no_id(std::move(f)), with_id(nullptr) {}
+        : run_with_id(false), no_id(std::move(f)), with_id(nullptr) {}
     explicit task_element_t(std::function<void(std::size_t)> f)
-      : run_with_id(true), no_id(nullptr), with_id(std::move(f)) {}
+        : run_with_id(true), no_id(nullptr), with_id(std::move(f)) {}
   };
 
   std::queue<task_element_t> tasks_;
@@ -105,13 +105,11 @@ class C10_API ThreadPool : public c10::TaskThreadPoolBase {
 
 class C10_API TaskThreadPool : public c10::ThreadPool {
  public:
-  explicit TaskThreadPool(
-      std::size_t pool_size,
-      int numa_node_id = -1)
-      : ThreadPool(pool_size, numa_node_id, [numa_node_id](){
-        setThreadName("CaffeTaskThread");
-        NUMABind(numa_node_id);
-      }) {}
+  explicit TaskThreadPool(std::size_t pool_size, int numa_node_id = -1)
+      : ThreadPool(pool_size, numa_node_id, [numa_node_id]() {
+          setThreadName("CaffeTaskThread");
+          NUMABind(numa_node_id);
+        }) {}
 };
 
 C10_DECLARE_SHARED_REGISTRY(
diff --git a/c10/cuda/CUDACachingAllocator.cpp b/c10/cuda/CUDACachingAllocator.cpp
index 4e3b04165cd..2b303b8960d 100644
--- a/c10/cuda/CUDACachingAllocator.cpp
+++ b/c10/cuda/CUDACachingAllocator.cpp
@@ -1,9 +1,9 @@
 
 #include <c10/cuda/CUDACachingAllocator.h>
 
-#include <c10/cuda/CUDAGuard.h>
 #include <c10/cuda/CUDAException.h>
 #include <c10/cuda/CUDAFunctions.h>
+#include <c10/cuda/CUDAGuard.h>
 #include <c10/util/UniqueVoidPtr.h>
 
 #include <cuda_runtime_api.h>
@@ -56,47 +56,57 @@ namespace CUDACachingAllocator {
 /**
  * Note [Interaction with CUDA graph capture]
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * Graph capture performs a dry run of a region of execution, freezing all CUDA work
- * (and virtual addresses used during that work) into a "graph." The graph may be "replayed"
- * like a single giant kernel, with greatly reduced CPU overhead as well as modestly improved
- * GPU performance.
+ * Graph capture performs a dry run of a region of execution, freezing all CUDA
+ * work (and virtual addresses used during that work) into a "graph." The graph
+ * may be "replayed" like a single giant kernel, with greatly reduced CPU
+ * overhead as well as modestly improved GPU performance.
  *
- * Because capture bakes in memory addresses, the memory used during capture must be available
- * for the graph to use during replay. DeviceCachingAllocator assigns and frees memory eagerly
- * and dynamically, so if we're not careful about managing graphs' memory, at replay time those
- * memory addresses could be use by other tensors.
+ * Because capture bakes in memory addresses, the memory used during capture
+ * must be available for the graph to use during replay. DeviceCachingAllocator
+ * assigns and frees memory eagerly and dynamically, so if we're not careful
+ * about managing graphs' memory, at replay time those memory addresses could be
+ * use by other tensors.
  *
- * To guarantee a graph's baked in addresses are safe to reuse in replay, DeviceAllocator
- * satisfies allocations from a graph-private memory pool during capture, and doesn't begin
- * cudaFreeing those addresses until the graph is destroyed.
+ * To guarantee a graph's baked in addresses are safe to reuse in replay,
+ * DeviceAllocator satisfies allocations from a graph-private memory pool during
+ * capture, and doesn't begin cudaFreeing those addresses until the graph is
+ * destroyed.
  *
- * Within the private pool, allocations are freed and reassigned as usual during capture.
- * Memory regions will be used in a consistent order during replay.
- * So a private pool doesn't use memory more wastefully than the default pools during capture,
- * but it does reserve its high-water mark of used memory away from the default pools as long
- * as the capture(s) it served survive (regardless whether those captures are idle or replaying).
+ * Within the private pool, allocations are freed and reassigned as usual during
+ * capture. Memory regions will be used in a consistent order during replay. So
+ * a private pool doesn't use memory more wastefully than the default pools
+ * during capture, but it does reserve its high-water mark of used memory away
+ * from the default pools as long as the capture(s) it served survive
+ * (regardless whether those captures are idle or replaying).
  *
- * CUDAGraph's requests for private pools are mediated by DeviceAllocator::notifyCaptureBegin,
- * notifyCaptureEnd, and notifyCaptureDestroy.
+ * CUDAGraph's requests for private pools are mediated by
+ * DeviceAllocator::notifyCaptureBegin, notifyCaptureEnd, and
+ * notifyCaptureDestroy.
  */
 
 namespace {
 
 using stream_set = std::unordered_set<cuda::CUDAStream>;
 
-constexpr size_t kMinBlockSize  =      512; // all sizes are rounded to at least 512 bytes
-constexpr size_t kSmallSize     =  1048576; // largest "small" allocation is 1 MiB
-constexpr size_t kSmallBuffer   =  2097152; // "small" allocations are packed in 2 MiB blocks
-constexpr size_t kLargeBuffer   = 20971520; // "large" allocations may be packed in 20 MiB blocks
-constexpr size_t kMinLargeAlloc = 10485760; // allocations between 1 and 10 MiB may use kLargeBuffer
-constexpr size_t kRoundLarge    =  2097152; // round up large allocations to 2 MiB
+constexpr size_t kMinBlockSize =
+    512; // all sizes are rounded to at least 512 bytes
+constexpr size_t kSmallSize = 1048576; // largest "small" allocation is 1 MiB
+constexpr size_t kSmallBuffer =
+    2097152; // "small" allocations are packed in 2 MiB blocks
+constexpr size_t kLargeBuffer =
+    20971520; // "large" allocations may be packed in 20 MiB blocks
+constexpr size_t kMinLargeAlloc =
+    10485760; // allocations between 1 and 10 MiB may use kLargeBuffer
+constexpr size_t kRoundLarge = 2097152; // round up large allocations to 2 MiB
 
 typedef std::bitset<static_cast<size_t>(StatType::NUM_TYPES)> StatTypes;
 
 void update_stat(Stat& stat, int64_t amount) {
   stat.current += amount;
 
-  TORCH_INTERNAL_ASSERT(stat.current >= 0, "Negative tracked stat in CUDA allocator (likely logic error).");
+  TORCH_INTERNAL_ASSERT(
+      stat.current >= 0,
+      "Negative tracked stat in CUDA allocator (likely logic error).");
 
   stat.peak = std::max(stat.current, stat.peak);
   if (amount > 0) {
@@ -116,7 +126,10 @@ void reset_peak_stat(Stat& stat) {
   stat.peak = stat.current;
 }
 
-void update_stat_array(StatArray& stat_array, int64_t amount, const StatTypes& stat_types) {
+void update_stat_array(
+    StatArray& stat_array,
+    int64_t amount,
+    const StatTypes& stat_types) {
   for (size_t stat_type = 0; stat_type < stat_types.size(); ++stat_type) {
     if (stat_types[stat_type]) {
       update_stat(stat_array[stat_type], amount);
@@ -129,45 +142,64 @@ struct PrivatePool;
 typedef bool (*Comparison)(const Block*, const Block*);
 
 struct BlockPool {
-  BlockPool(Comparison comparator,
-            bool small,
-            PrivatePool* private_pool=nullptr) :
-    blocks(comparator),
-    is_small(small),
-    owner_PrivatePool(private_pool) {}
+  BlockPool(
+      Comparison comparator,
+      bool small,
+      PrivatePool* private_pool = nullptr)
+      : blocks(comparator), is_small(small), owner_PrivatePool(private_pool) {}
   std::set<Block*, Comparison> blocks;
   const bool is_small;
   PrivatePool* owner_PrivatePool;
 };
 
 struct Block {
-  int           device;      // gpu
-  cudaStream_t  stream;      // allocation stream
-  stream_set    stream_uses; // streams on which the block was used
-  size_t        size;        // block size in bytes
-  BlockPool*    pool;        // owning memory pool
-  void*         ptr;         // memory address
-  bool          allocated;   // in-use flag
-  Block*        prev;        // prev block if split from a larger allocation
-  Block*        next;        // next block if split from a larger allocation
-  int           event_count; // number of outstanding CUDA events
+  int device; // gpu
+  cudaStream_t stream; // allocation stream
+  stream_set stream_uses; // streams on which the block was used
+  size_t size; // block size in bytes
+  BlockPool* pool; // owning memory pool
+  void* ptr; // memory address
+  bool allocated; // in-use flag
+  Block* prev; // prev block if split from a larger allocation
+  Block* next; // next block if split from a larger allocation
+  int event_count; // number of outstanding CUDA events
 
-  Block(int device, cudaStream_t stream, size_t size, BlockPool* pool, void* ptr) :
-    device(device), stream(stream), stream_uses(), size(size), pool(pool),
-    ptr(ptr), allocated(0), prev(nullptr), next(nullptr), event_count(0) { }
+  Block(
+      int device,
+      cudaStream_t stream,
+      size_t size,
+      BlockPool* pool,
+      void* ptr)
+      : device(device),
+        stream(stream),
+        stream_uses(),
+        size(size),
+        pool(pool),
+        ptr(ptr),
+        allocated(0),
+        prev(nullptr),
+        next(nullptr),
+        event_count(0) {}
 
   // constructor for search key
-  Block(int device, cudaStream_t stream, size_t size) :
-    device(device), stream(stream), stream_uses(), size(size), pool(nullptr),
-    ptr(nullptr), allocated(0), prev(nullptr), next(nullptr), event_count(0) { }
+  Block(int device, cudaStream_t stream, size_t size)
+      : device(device),
+        stream(stream),
+        stream_uses(),
+        size(size),
+        pool(nullptr),
+        ptr(nullptr),
+        allocated(0),
+        prev(nullptr),
+        next(nullptr),
+        event_count(0) {}
 
   bool is_split() const {
     return (prev != nullptr) || (next != nullptr);
   }
 };
 
-static bool BlockComparator(const Block* a, const Block* b)
-{
+static bool BlockComparator(const Block* a, const Block* b) {
   if (a->stream != b->stream) {
     return (uintptr_t)a->stream < (uintptr_t)b->stream;
   }
@@ -197,17 +229,28 @@ static std::string format_size(uint64_t size) {
 }
 
 struct AllocParams {
-  AllocParams(int device, size_t size, cudaStream_t stream, BlockPool* pool, size_t alloc_size,
-              DeviceStats& stats) :
-    search_key(device, stream, size),
-    pool(pool),
-    alloc_size(alloc_size),
-    block(nullptr),
-    err(cudaSuccess) {}
+  AllocParams(
+      int device,
+      size_t size,
+      cudaStream_t stream,
+      BlockPool* pool,
+      size_t alloc_size,
+      DeviceStats& stats)
+      : search_key(device, stream, size),
+        pool(pool),
+        alloc_size(alloc_size),
+        block(nullptr),
+        err(cudaSuccess) {}
 
-  int device() { return search_key.device; }
-  cudaStream_t stream() { return search_key.stream; }
-  size_t size() { return search_key.size; }
+  int device() {
+    return search_key.device;
+  }
+  cudaStream_t stream() {
+    return search_key.stream;
+  }
+  size_t size() {
+    return search_key.size;
+  }
 
   Block search_key;
   BlockPool* pool;
@@ -217,26 +260,27 @@ struct AllocParams {
   cudaError_t err;
 };
 
-
 // CUDA graphs helper
 struct PrivatePool {
-  PrivatePool() :
-    use_count(1),
-    cudaMalloc_count(0),
-    large_blocks(BlockComparator, /*is_small=*/false, this),
-    small_blocks(BlockComparator, /*is_small=*/true, this) {}
+  PrivatePool()
+      : use_count(1),
+        cudaMalloc_count(0),
+        large_blocks(BlockComparator, /*is_small=*/false, this),
+        small_blocks(BlockComparator, /*is_small=*/true, this) {}
   PrivatePool(const PrivatePool&) = delete;
   PrivatePool(PrivatePool&&) = delete;
   PrivatePool& operator=(const PrivatePool&) = delete;
   // Number of live graphs using this pool
   int use_count;
-  // Number of unfreed cudaMallocs made for this pool. When use_count and cudaMalloc_count
-  // drop to zero, we can delete this PrivatePool from graph_pools.
+  // Number of unfreed cudaMallocs made for this pool. When use_count and
+  // cudaMalloc_count drop to zero, we can delete this PrivatePool from
+  // graph_pools.
   int cudaMalloc_count;
-  // Instead of maintaining private BlockPools here, I could stuff all blocks (private or no)
-  // into the top-level large_blocks and small_blocks, and distinguish private blocks by adding
-  // a "pool id" check above the stream check in BlockComparator. BlockComparator is performance-
-  // critial though, I'd rather not add more logic to it.
+  // Instead of maintaining private BlockPools here, I could stuff all blocks
+  // (private or no) into the top-level large_blocks and small_blocks, and
+  // distinguish private blocks by adding a "pool id" check above the stream
+  // check in BlockComparator. BlockComparator is performance- critial though,
+  // I'd rather not add more logic to it.
   BlockPool large_blocks;
   BlockPool small_blocks;
 };
@@ -249,12 +293,14 @@ struct MempoolIdHash {
 
 cudaError_t cudaMallocMaybeCapturing(void** p, size_t size) {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
-  if (at::cuda::currentStreamCaptureStatusMayInitCtx() == at::cuda::CaptureStatus::None) {
+  if (at::cuda::currentStreamCaptureStatusMayInitCtx() ==
+      at::cuda::CaptureStatus::None) {
 #endif
     return cudaMalloc(p, size);
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
   } else {
-    // It's ok to capture cudaMallocs, as long as we never cudaFree those addresses before replay.
+    // It's ok to capture cudaMallocs, as long as we never cudaFree those
+    // addresses before replay.
     at::cuda::CUDAStreamCaptureModeGuard g{cudaStreamCaptureModeRelaxed};
     return cudaMalloc(p, size);
   }
@@ -264,9 +310,7 @@ cudaError_t cudaMallocMaybeCapturing(void** p, size_t size) {
 } // namespace
 
 class DeviceCachingAllocator {
-
  private:
-
   // lock around all operations
   mutable std::recursive_mutex mutex;
 
@@ -302,38 +346,41 @@ class DeviceCachingAllocator {
   // Members specific to CUDA graphs
 
   // Private pools for CUDA graphs
-  std::unordered_map<MempoolId_t, std::unique_ptr<PrivatePool>, MempoolIdHash> graph_pools;
-  // Pools no longer referenced by any graph. Their BlockPools are eligible for free_blocks.
-  // Can't be a vector or deque because we might erase entries in any order.
-  // Could be an std::list, but we don't care much, access and insert/erase are rare.
-  std::unordered_map<MempoolId_t, PrivatePool*, MempoolIdHash> graph_pools_freeable;
+  std::unordered_map<MempoolId_t, std::unique_ptr<PrivatePool>, MempoolIdHash>
+      graph_pools;
+  // Pools no longer referenced by any graph. Their BlockPools are eligible for
+  // free_blocks. Can't be a vector or deque because we might erase entries in
+  // any order. Could be an std::list, but we don't care much, access and
+  // insert/erase are rare.
+  std::unordered_map<MempoolId_t, PrivatePool*, MempoolIdHash>
+      graph_pools_freeable;
 
   // Maps a capturing stream to its assigned private pool,
   // in case we want multiple captures to share the same pool
   std::unordered_map<CaptureId_t, MempoolId_t> capture_to_pool_map;
 
  public:
-
-  DeviceCachingAllocator() :
-      large_blocks(BlockComparator, /*is_small=*/false),
-      small_blocks(BlockComparator, /*is_small=*/true) {}
+  DeviceCachingAllocator()
+      : large_blocks(BlockComparator, /*is_small=*/false),
+        small_blocks(BlockComparator, /*is_small=*/true) {}
 
   // All public methods (except the above) acquire the allocator mutex.
   // Thus, do not call a public method from another public method.
 
-  Block* malloc(int device, size_t size, cudaStream_t stream)
-  {
+  Block* malloc(int device, size_t size, cudaStream_t stream) {
     std::unique_lock<std::recursive_mutex> lock(mutex);
 
     if (C10_LIKELY(captures_underway == 0)) {
-      // Processes end-of-life events for outstanding allocations used on multiple streams
-      // (checks if their GPU-side uses are complete and recycles their memory if so)
+      // Processes end-of-life events for outstanding allocations used on
+      // multiple streams (checks if their GPU-side uses are complete and
+      // recycles their memory if so)
       //
       // Q. Why skip process_events if a capture might be underway?
-      // A. process_events involves cudaEventQueries, illegal during CUDA graph capture.
-      //    Dumb simple solution: defer reclaiming these allocations until after capture.
-      //    Cross-stream memory use is uncommon, so the deferral's effect on memory use
-      //    during capture should be small.
+      // A. process_events involves cudaEventQueries, illegal during CUDA graph
+      // capture.
+      //    Dumb simple solution: defer reclaiming these allocations until after
+      //    capture. Cross-stream memory use is uncommon, so the deferral's
+      //    effect on memory use during capture should be small.
       process_events();
     }
 
@@ -345,14 +392,14 @@ class DeviceCachingAllocator {
     params.stat_types[static_cast<size_t>(get_stat_type_for_pool(pool))] = true;
 
     bool block_found =
-      // Search pool
-      get_free_block(params)
-      // Trigger callbacks and retry search
-      || (trigger_free_memory_callbacks(params) && get_free_block(params))
-      // Attempt allocate
-      || alloc_block(params, false)
-      // Free all non-split cached blocks and retry alloc.
-      || (free_cached_blocks() && alloc_block(params, true));
+        // Search pool
+        get_free_block(params)
+        // Trigger callbacks and retry search
+        || (trigger_free_memory_callbacks(params) && get_free_block(params))
+        // Attempt allocate
+        || alloc_block(params, false)
+        // Free all non-split cached blocks and retry alloc.
+        || (free_cached_blocks() && alloc_block(params, true));
 
     if (!block_found) {
       // For any error code other than cudaErrorMemoryAllocation,
@@ -388,21 +435,32 @@ class DeviceCachingAllocator {
       // Note that at this point free_cached_blocks has already returned all
       // possible "cached" memory to the driver. The only remaining "cached"
       // memory is split from a larger block that is partially in-use.
-      TORCH_CHECK_WITH(CUDAOutOfMemoryError, false,
-        "CUDA out of memory. Tried to allocate ", format_size(alloc_size),
-        " (GPU ", device, "; ",
-        format_size(device_total), " total capacity; ",
-        format_size(stats.allocated_bytes[static_cast<size_t>(StatType::AGGREGATE)].current),
-        " already allocated; ",
-        format_size(device_free), " free; ",
-        allowed_info,
-        format_size(stats.reserved_bytes[static_cast<size_t>(StatType::AGGREGATE)].current),
-        " reserved in total by PyTorch)");
+      TORCH_CHECK_WITH(
+          CUDAOutOfMemoryError,
+          false,
+          "CUDA out of memory. Tried to allocate ",
+          format_size(alloc_size),
+          " (GPU ",
+          device,
+          "; ",
+          format_size(device_total),
+          " total capacity; ",
+          format_size(
+              stats.allocated_bytes[static_cast<size_t>(StatType::AGGREGATE)]
+                  .current),
+          " already allocated; ",
+          format_size(device_free),
+          " free; ",
+          allowed_info,
+          format_size(
+              stats.reserved_bytes[static_cast<size_t>(StatType::AGGREGATE)]
+                  .current),
+          " reserved in total by PyTorch)");
     }
 
-    TORCH_INTERNAL_ASSERT(params.err == cudaSuccess &&
-                          params.block != nullptr &&
-                          params.block->ptr != nullptr);
+    TORCH_INTERNAL_ASSERT(
+        params.err == cudaSuccess && params.block != nullptr &&
+        params.block->ptr != nullptr);
     Block* block = params.block;
     Block* remaining = nullptr;
 
@@ -425,16 +483,19 @@ class DeviceCachingAllocator {
 
       if (already_split) {
         // An already-split inactive block is being shrunk by size bytes.
-        update_stat_array(stats.inactive_split_bytes, -block->size, params.stat_types);
+        update_stat_array(
+            stats.inactive_split_bytes, -block->size, params.stat_types);
       } else {
-        // A new split inactive block is being created from a previously unsplit block,
-        // size remaining->size bytes.
-        update_stat_array(stats.inactive_split_bytes, remaining->size, params.stat_types);
+        // A new split inactive block is being created from a previously unsplit
+        // block, size remaining->size bytes.
+        update_stat_array(
+            stats.inactive_split_bytes, remaining->size, params.stat_types);
         update_stat_array(stats.inactive_split, 1, params.stat_types);
       }
     } else if (already_split) {
       // An already-split block is becoming active
-      update_stat_array(stats.inactive_split_bytes, -block->size, params.stat_types);
+      update_stat_array(
+          stats.inactive_split_bytes, -block->size, params.stat_types);
       update_stat_array(stats.inactive_split, -1, params.stat_types);
     }
 
@@ -453,8 +514,7 @@ class DeviceCachingAllocator {
     return block;
   }
 
-  void free(Block* block)
-  {
+  void free(Block* block) {
     std::lock_guard<std::recursive_mutex> lock(mutex);
 
     block->allocated = false;
@@ -464,15 +524,17 @@ class DeviceCachingAllocator {
 
     StatTypes stat_types;
     stat_types[static_cast<size_t>(StatType::AGGREGATE)] = true;
-    stat_types[static_cast<size_t>(get_stat_type_for_pool(*(block->pool)))] = true;
+    stat_types[static_cast<size_t>(get_stat_type_for_pool(*(block->pool)))] =
+        true;
     update_stat_array(stats.allocation, -1, {stat_types});
     update_stat_array(stats.allocated_bytes, -block->size, {stat_types});
 
     if (!block->stream_uses.empty()) {
       if (C10_UNLIKELY(captures_underway)) {
-        // It's forbidden to cudaEventQuery an event recorded during CUDA graph capture.
-        // We conservatively defer recording end-of-life events until the next call to
-        // process_events() (which won't happen until no captures are underway)
+        // It's forbidden to cudaEventQuery an event recorded during CUDA graph
+        // capture. We conservatively defer recording end-of-life events until
+        // the next call to process_events() (which won't happen until no
+        // captures are underway)
         needs_events_deferred_until_no_capture.push_back(block);
       } else {
         insert_events(block);
@@ -487,7 +549,7 @@ class DeviceCachingAllocator {
     while (block->prev) {
       block = block->prev;
     }
-    void *basePtr = block->ptr;
+    void* basePtr = block->ptr;
     if (outSize) {
       size_t size = 0;
       while (block) {
@@ -525,13 +587,14 @@ class DeviceCachingAllocator {
   }
 
   /** Retrieves info (total size + largest block) of the memory cache **/
-  void cacheInfo(size_t* total, size_t* largest)
-  {
+  void cacheInfo(size_t* total, size_t* largest) {
     std::lock_guard<std::recursive_mutex> lock(mutex);
-    if (*largest == 0) {  // make an initial guess if a zero *largest is passed in
+    if (*largest ==
+        0) { // make an initial guess if a zero *largest is passed in
       size_t tmp_bytes;
-      cudaMemGetInfo(largest,  // Use free memory as an optimistic initial guess of *largest
-                     &tmp_bytes);
+      cudaMemGetInfo(
+          largest, // Use free memory as an optimistic initial guess of *largest
+          &tmp_bytes);
     }
     cache_info_aux(large_blocks, total, largest);
     cache_info_aux(small_blocks, total, largest);
@@ -551,7 +614,9 @@ class DeviceCachingAllocator {
   void resetAccumulatedStats() {
     std::lock_guard<std::recursive_mutex> lock(mutex);
 
-    for (size_t statType = 0; statType < static_cast<size_t>(StatType::NUM_TYPES); ++statType) {
+    for (size_t statType = 0;
+         statType < static_cast<size_t>(StatType::NUM_TYPES);
+         ++statType) {
       reset_accumulated_stat(stats.allocation[statType]);
       reset_accumulated_stat(stats.segment[statType]);
       reset_accumulated_stat(stats.active[statType]);
@@ -570,7 +635,9 @@ class DeviceCachingAllocator {
   void resetPeakStats() {
     std::lock_guard<std::recursive_mutex> lock(mutex);
 
-    for (size_t statType = 0; statType < static_cast<size_t>(StatType::NUM_TYPES); ++statType) {
+    for (size_t statType = 0;
+         statType < static_cast<size_t>(StatType::NUM_TYPES);
+         ++statType) {
       reset_peak_stat(stats.allocation[statType]);
       reset_peak_stat(stats.segment[statType]);
       reset_peak_stat(stats.active[statType]);
@@ -582,7 +649,8 @@ class DeviceCachingAllocator {
     }
   }
 
-  /** Dump a complete snapshot of the memory held by the allocator. Potentially VERY expensive. **/
+  /** Dump a complete snapshot of the memory held by the allocator. Potentially
+   * VERY expensive. **/
   std::vector<SegmentInfo> snapshot() const {
     std::lock_guard<std::recursive_mutex> lock(mutex);
 
@@ -606,7 +674,8 @@ class DeviceCachingAllocator {
 
         block_info.size = block->size;
         block_info.allocated = block->allocated;
-        block_info.active = block->allocated || (block->event_count > 0) || !block->stream_uses.empty();
+        block_info.active = block->allocated || (block->event_count > 0) ||
+            !block->stream_uses.empty();
 
         segment_info.total_size += block_info.size;
         if (block_info.allocated) {
@@ -620,9 +689,12 @@ class DeviceCachingAllocator {
       }
     }
 
-    std::sort(result.begin(), result.end(), [](const SegmentInfo& a, const SegmentInfo& b) {
-      return a.address < b.address;
-    });
+    std::sort(
+        result.begin(),
+        result.end(),
+        [](const SegmentInfo& a, const SegmentInfo& b) {
+          return a.address < b.address;
+        });
 
     return result;
   }
@@ -643,22 +715,26 @@ class DeviceCachingAllocator {
     captures_underway++;
     auto it = graph_pools.find(mempool_id);
     if (it == graph_pools.end()) {
-      // mempool_id does not reference an existing pool. Make a new pool for this capture.
-      graph_pools.emplace(std::make_pair(mempool_id, std::unique_ptr<PrivatePool>(new PrivatePool)));
+      // mempool_id does not reference an existing pool. Make a new pool for
+      // this capture.
+      graph_pools.emplace(std::make_pair(
+          mempool_id, std::unique_ptr<PrivatePool>(new PrivatePool)));
     } else {
-      // mempool_id references an existing pool, which the current capture will share.
-      // Check this pool is live (at least one other capture already references it).
+      // mempool_id references an existing pool, which the current capture will
+      // share. Check this pool is live (at least one other capture already
+      // references it).
       TORCH_INTERNAL_ASSERT(it->second->use_count > 0);
       it->second->use_count++;
     }
-    // Maps this graph_id to mempool_id and makes sure this graph_id wasn't somehow
-    // assigned a mempool_id already. Keeps essential effect (insert) out of macro.
+    // Maps this graph_id to mempool_id and makes sure this graph_id wasn't
+    // somehow assigned a mempool_id already. Keeps essential effect (insert)
+    // out of macro.
     bool inserted = capture_to_pool_map.insert({graph_id, mempool_id}).second;
     TORCH_INTERNAL_ASSERT(inserted);
   }
 
   // Called by CUDAGraph::capture_end
-  void  notifyCaptureEnd(CaptureId_t graph_id) {
+  void notifyCaptureEnd(CaptureId_t graph_id) {
     std::lock_guard<std::recursive_mutex> lock(mutex);
     captures_underway--;
     auto it = capture_to_pool_map.find(graph_id);
@@ -669,13 +745,15 @@ class DeviceCachingAllocator {
   // Called by CUDAGraph::reset
   void notifyCaptureDestroy(MempoolId_t mempool_id) {
     std::lock_guard<std::recursive_mutex> lock(mutex);
-    // The instantiated cudaGraphExec_t has been destroyed. We can't blindly delete and cudaFree
-    // the mempool its capture used, because
+    // The instantiated cudaGraphExec_t has been destroyed. We can't blindly
+    // delete and cudaFree the mempool its capture used, because
     //  1. other graph(s) might share the same pool
-    //  2. the user might still hold references to output tensors allocated during capture.
-    // To handle 1 and 2, we track the number of graphs using this particular mempool.
-    // When the count reaches 0, we tell free_cached_blocks it may now cudaFree blocks from
-    // this graph's pool when it discovers they're unused (unsplit).
+    //  2. the user might still hold references to output tensors allocated
+    //  during capture.
+    // To handle 1 and 2, we track the number of graphs using this particular
+    // mempool. When the count reaches 0, we tell free_cached_blocks it may now
+    // cudaFree blocks from this graph's pool when it discovers they're unused
+    // (unsplit).
     auto it = graph_pools.find(mempool_id);
     TORCH_INTERNAL_ASSERT(it != graph_pools.end());
     auto uc = --(it->second->use_count);
@@ -683,31 +761,40 @@ class DeviceCachingAllocator {
     if (uc == 0) {
       // Allows free_cached_blocks to begin cudaFreeing this pool's memory,
       // and makes sure this pool wasn't somehow made freeable already.
-      bool inserted = graph_pools_freeable.insert({mempool_id, it->second.get()}).second;
+      bool inserted =
+          graph_pools_freeable.insert({mempool_id, it->second.get()}).second;
       TORCH_INTERNAL_ASSERT(inserted);
     }
   }
 
  private:
-
   // All private methods do not acquire the allocator mutex.
 
   std::vector<const Block*> get_all_blocks() const {
     std::vector<const Block*> blocks;
-    blocks.insert(blocks.end(), small_blocks.blocks.begin(), small_blocks.blocks.end());
-    blocks.insert(blocks.end(), large_blocks.blocks.begin(), large_blocks.blocks.end());
+    blocks.insert(
+        blocks.end(), small_blocks.blocks.begin(), small_blocks.blocks.end());
+    blocks.insert(
+        blocks.end(), large_blocks.blocks.begin(), large_blocks.blocks.end());
     for (const auto& gp : graph_pools) {
-      blocks.insert(blocks.end(), gp.second->small_blocks.blocks.begin(), gp.second->small_blocks.blocks.end());
-      blocks.insert(blocks.end(), gp.second->large_blocks.blocks.begin(), gp.second->large_blocks.blocks.end());
+      blocks.insert(
+          blocks.end(),
+          gp.second->small_blocks.blocks.begin(),
+          gp.second->small_blocks.blocks.end());
+      blocks.insert(
+          blocks.end(),
+          gp.second->large_blocks.blocks.begin(),
+          gp.second->large_blocks.blocks.end());
     }
     blocks.insert(blocks.end(), active_blocks.begin(), active_blocks.end());
     return blocks;
   }
 
   /** moves a block into a pool of cached free blocks */
-  void free_block(Block* block)
-  {
-    TORCH_INTERNAL_ASSERT(!block->allocated && block->event_count == 0 && block->stream_uses.empty());
+  void free_block(Block* block) {
+    TORCH_INTERNAL_ASSERT(
+        !block->allocated && block->event_count == 0 &&
+        block->stream_uses.empty());
 
     size_t original_block_size = block->size;
 
@@ -717,7 +804,8 @@ class DeviceCachingAllocator {
 
     const std::array<Block*, 2> merge_candidates = {block->prev, block->next};
     for (Block* merge_candidate : merge_candidates) {
-      const int64_t subsumed_size = try_merge_blocks(block, merge_candidate, pool);
+      const int64_t subsumed_size =
+          try_merge_blocks(block, merge_candidate, pool);
       if (subsumed_size > 0) {
         net_change_inactive_split_blocks -= 1;
         net_change_inactive_split_size -= subsumed_size;
@@ -725,7 +813,8 @@ class DeviceCachingAllocator {
     }
 
     active_blocks.erase(block);
-    // Makes sure the Block* isn't already present in the pool we're freeing it back into.
+    // Makes sure the Block* isn't already present in the pool we're freeing it
+    // back into.
     bool inserted = pool.blocks.insert(block).second;
     TORCH_INTERNAL_ASSERT(inserted);
 
@@ -737,16 +826,19 @@ class DeviceCachingAllocator {
     StatTypes stat_types;
     stat_types[static_cast<size_t>(StatType::AGGREGATE)] = true;
     stat_types[static_cast<size_t>(get_stat_type_for_pool(pool))] = true;
-    update_stat_array(stats.inactive_split, net_change_inactive_split_blocks, stat_types);
-    update_stat_array(stats.inactive_split_bytes, net_change_inactive_split_size, stat_types);
+    update_stat_array(
+        stats.inactive_split, net_change_inactive_split_blocks, stat_types);
+    update_stat_array(
+        stats.inactive_split_bytes, net_change_inactive_split_size, stat_types);
     update_stat_array(stats.active, -1, stat_types);
     update_stat_array(stats.active_bytes, -original_block_size, stat_types);
   }
 
-  /** combine previously split blocks. returns the size of the subsumed block, or 0 on failure. */
-  size_t try_merge_blocks(Block* dst, Block* src, BlockPool& pool)
-  {
-    if (!src || src->allocated || src->event_count > 0 || !src->stream_uses.empty()) {
+  /** combine previously split blocks. returns the size of the subsumed block,
+   * or 0 on failure. */
+  size_t try_merge_blocks(Block* dst, Block* src, BlockPool& pool) {
+    if (!src || src->allocated || src->event_count > 0 ||
+        !src->stream_uses.empty()) {
       return 0;
     }
 
@@ -776,15 +868,18 @@ class DeviceCachingAllocator {
 
   BlockPool& get_pool(size_t size, cudaStream_t stream) {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
-    // captures_underway is a conservative guess that the current stream may be capturing.
-    // It's only > 0 if some thread has begun and not yet ended a capture, so it's usually 0,
-    // and we can short-circuit cudaStreamCaptureStatus (which does a TLS lookup).
+    // captures_underway is a conservative guess that the current stream may be
+    // capturing. It's only > 0 if some thread has begun and not yet ended a
+    // capture, so it's usually 0, and we can short-circuit
+    // cudaStreamCaptureStatus (which does a TLS lookup).
     if (C10_UNLIKELY(captures_underway)) {
       CaptureId_t id;
       cudaStreamCaptureStatus status;
       C10_CUDA_CHECK(cudaStreamGetCaptureInfo(stream, &status, &id));
       if (status != cudaStreamCaptureStatus::cudaStreamCaptureStatusNone) {
-        TORCH_INTERNAL_ASSERT(status != cudaStreamCaptureStatus::cudaStreamCaptureStatusInvalidated);
+        TORCH_INTERNAL_ASSERT(
+            status !=
+            cudaStreamCaptureStatus::cudaStreamCaptureStatusInvalidated);
         // Retrieves the private pool assigned to this capture.
         auto it0 = capture_to_pool_map.find(id);
         TORCH_INTERNAL_ASSERT(it0 != capture_to_pool_map.end());
@@ -811,9 +906,8 @@ class DeviceCachingAllocator {
 
   bool should_split(const Block* block, size_t size) {
     size_t remaining = block->size - size;
-    return (block->pool->is_small) ?
-           (remaining >= kMinBlockSize) :
-           (remaining > kSmallSize);
+    return (block->pool->is_small) ? (remaining >= kMinBlockSize)
+                                   : (remaining > kSmallSize);
   }
 
   static size_t get_allocation_size(size_t size) {
@@ -840,7 +934,7 @@ class DeviceCachingAllocator {
     bool freed_memory = false;
     for (const auto& name : FreeCudaMemoryCallbacksRegistry()->Keys()) {
       freed_memory |=
-        FreeCudaMemoryCallbacksRegistry()->Create(name)->Execute();
+          FreeCudaMemoryCallbacksRegistry()->Create(name)->Execute();
     }
     return freed_memory;
   }
@@ -856,22 +950,27 @@ class DeviceCachingAllocator {
       stats.num_alloc_retries += 1;
     }
 
-    if (set_fraction && total_allocated_memory + size > allowed_memory_maximum) {
+    if (set_fraction &&
+        total_allocated_memory + size > allowed_memory_maximum) {
       p.err = cudaErrorMemoryAllocation;
       return false;
     } else {
       p.err = cudaMallocMaybeCapturing(&ptr, size);
       if (p.err != cudaSuccess) {
         if (p.err == cudaErrorMemoryAllocation) {
-          // If this is the first attempt (!isRetry), we can forgive and clear CUDA's
+          // If this is the first attempt (!isRetry), we can forgive and clear
+          // CUDA's
           //   internal error state.
-          // If this is the second attempt (isRetry), malloc's TORCH_CHECK_WITH will take
-          //   over to throw a helpful exception. The user can choose to catch the exception,
-          //   free some stuff in their script, and attempt their allocation again.
-          //   In this case, we can also forgive and clear CUDA's internal error state.
+          // If this is the second attempt (isRetry), malloc's TORCH_CHECK_WITH
+          // will take
+          //   over to throw a helpful exception. The user can choose to catch
+          //   the exception, free some stuff in their script, and attempt their
+          //   allocation again. In this case, we can also forgive and clear
+          //   CUDA's internal error state.
           cudaGetLastError();
         } else {
-          // If the error's unrelated to memory allocation, we should throw immediately.
+          // If the error's unrelated to memory allocation, we should throw
+          // immediately.
           C10_CUDA_CHECK(p.err);
         }
         return false;
@@ -893,8 +992,7 @@ class DeviceCachingAllocator {
     return true;
   }
 
-  bool free_cached_blocks()
-  {
+  bool free_cached_blocks() {
     // First ensure that all blocks that can't currently be allocated due to
     // outstanding events are returned to the pool.
     synchronize_and_free_events();
@@ -903,7 +1001,8 @@ class DeviceCachingAllocator {
     free_blocks(large_blocks);
     free_blocks(small_blocks);
 
-    for (auto it = graph_pools_freeable.begin(); it != graph_pools_freeable.end(); ) {
+    for (auto it = graph_pools_freeable.begin();
+         it != graph_pools_freeable.end();) {
       // See notifyCaptureDestroy for the strategy here.
       TORCH_INTERNAL_ASSERT(it->second->use_count == 0);
       free_blocks(it->second->small_blocks);
@@ -920,8 +1019,7 @@ class DeviceCachingAllocator {
     return true;
   }
 
-  void free_blocks(BlockPool& pool)
-  {
+  void free_blocks(BlockPool& pool) {
     // Frees all non-split blocks
     auto it = pool.blocks.begin();
     while (it != pool.blocks.end()) {
@@ -986,8 +1084,7 @@ class DeviceCachingAllocator {
     cuda_events.clear();
   }
 
-  void insert_events(Block* block)
-  {
+  void insert_events(Block* block) {
     int prev_device;
     C10_CUDA_CHECK(cudaGetDevice(&prev_device));
 
@@ -1016,8 +1113,7 @@ class DeviceCachingAllocator {
     }
   }
 
-  void process_events()
-  {
+  void process_events() {
     insert_events_deferred_until_no_capture();
 
     // Process outstanding cudaEvents. Events that are completed are removed
@@ -1050,8 +1146,7 @@ class DeviceCachingAllocator {
   }
 
   // Accumulates sizes of all memory blocks for given device in given pool
-  void cache_info_aux(const BlockPool& pool, size_t* total, size_t* largest)
-  {
+  void cache_info_aux(const BlockPool& pool, size_t* total, size_t* largest) {
     for (const auto& block : pool.blocks) {
       size_t blocksize = block->size;
       *total += blocksize;
@@ -1063,9 +1158,7 @@ class DeviceCachingAllocator {
 };
 
 class THCCachingAllocator {
-
  private:
-
   std::mutex mutex;
 
   // allocated blocks by device pointer
@@ -1080,14 +1173,13 @@ class THCCachingAllocator {
   }
 
  public:
-
   std::vector<std::unique_ptr<DeviceCachingAllocator>> device_allocator;
 
   std::mutex* getCudaFreeMutex() const {
     return &cuda_free_mutex;
   }
 
-  Block* get_allocated_block(void *ptr, bool remove=false) {
+  Block* get_allocated_block(void* ptr, bool remove = false) {
     std::lock_guard<std::mutex> lock(mutex);
     auto it = allocated_blocks.find(ptr);
     if (it == allocated_blocks.end()) {
@@ -1105,7 +1197,8 @@ class THCCachingAllocator {
     if (size < device_count) {
       device_allocator.resize(device_count);
       for (int i = size; i < device_count; i++) {
-        device_allocator[i] = std::unique_ptr<DeviceCachingAllocator>(new DeviceCachingAllocator());
+        device_allocator[i] = std::unique_ptr<DeviceCachingAllocator>(
+            new DeviceCachingAllocator());
       }
     }
   }
@@ -1140,14 +1233,14 @@ class THCCachingAllocator {
         device,
         ": did you call init?");
     TORCH_INTERNAL_ASSERT(
-        0 <= fraction  && fraction <= 1,
+        0 <= fraction && fraction <= 1,
         "invalid fraction:",
         fraction,
         ". Please set within (0, 1).");
     int activated_device;
-    cudaGetDevice (&activated_device);
+    cudaGetDevice(&activated_device);
     if (activated_device != device) {
-        cudaSetDevice(device);
+      cudaSetDevice(device);
     }
     device_allocator[device]->setMemoryFraction(fraction);
   }
@@ -1158,8 +1251,7 @@ class THCCachingAllocator {
       device_allocator[i]->emptyCache();
   }
 
-  void* getBaseAllocation(void* ptr, size_t* outSize)
-  {
+  void* getBaseAllocation(void* ptr, size_t* outSize) {
     Block* block = get_allocated_block(ptr);
     if (!block) {
       TORCH_CHECK(false, "invalid device pointer: ", ptr);
@@ -1230,7 +1322,8 @@ struct CudaCachingAllocator : public Allocator {
       return {r, r, &uncached_delete, Device(DeviceType::CUDA, device)};
     }
     if (size != 0) {
-      caching_allocator.malloc(&r, device, size, cuda::getCurrentCUDAStream(device));
+      caching_allocator.malloc(
+          &r, device, size, cuda::getCurrentCUDAStream(device));
     }
     return {r, r, &raw_delete, Device(DeviceType::CUDA, device)};
   }
@@ -1245,8 +1338,7 @@ struct CudaCachingAllocator : public Allocator {
 
 CudaCachingAllocator device_allocator;
 
-Allocator* get(void)
-{
+Allocator* get(void) {
   return &device_allocator;
 }
 
@@ -1263,21 +1355,19 @@ void emptyCache(void) {
 }
 
 void cacheInfo(int dev_id, size_t* cachedAndFree, size_t* largestBlock) {
-  caching_allocator.device_allocator[dev_id]->cacheInfo(cachedAndFree, largestBlock);
+  caching_allocator.device_allocator[dev_id]->cacheInfo(
+      cachedAndFree, largestBlock);
 }
 
-void* getBaseAllocation(void *ptr, size_t *size)
-{
+void* getBaseAllocation(void* ptr, size_t* size) {
   return caching_allocator.getBaseAllocation(ptr, size);
 }
 
-void recordStream(const DataPtr& ptr, cuda::CUDAStream stream)
-{
+void recordStream(const DataPtr& ptr, cuda::CUDAStream stream) {
   caching_allocator.recordStream(ptr, stream);
 }
 
-std::mutex* getFreeMutex()
-{
+std::mutex* getFreeMutex() {
   return caching_allocator.getCudaFreeMutex();
 }
 
@@ -1306,11 +1396,13 @@ std::vector<SegmentInfo> snapshot() {
 }
 
 // CUDAGraph interactions
-void notifyCaptureBegin(int device,
-                        CaptureId_t graph_id,
-                        MempoolId_t mempool_id) {
+void notifyCaptureBegin(
+    int device,
+    CaptureId_t graph_id,
+    MempoolId_t mempool_id) {
   assertValidDevice(device);
-  caching_allocator.device_allocator[device]->notifyCaptureBegin(graph_id, mempool_id);
+  caching_allocator.device_allocator[device]->notifyCaptureBegin(
+      graph_id, mempool_id);
 }
 
 void notifyCaptureEnd(int device, CaptureId_t graph_id) {
@@ -1328,21 +1420,21 @@ void notifyCaptureDestroy(int device, MempoolId_t mempool_id) {
 // is called by the receiving process to map the CUDA memory from the sending
 // process into its own address space.
 //
-// CUDA IPC only allows sharing a big memory block associated with a cudaIpcMemHandle_t
-// and it can be opened only **once** per context per process. There can be
-// multiple types of storage in the same IPC mem block, so we must cache the
-// device ptr to construct typed storage as it comes.
+// CUDA IPC only allows sharing a big memory block associated with a
+// cudaIpcMemHandle_t and it can be opened only **once** per context per
+// process. There can be multiple types of storage in the same IPC mem block, so
+// we must cache the device ptr to construct typed storage as it comes.
 //
-// ipcMemHandle_to_devptr maps a cudaIpcMemHandle_t to a device pointer in the process
-// that can be used to access the memory block in the sender process.
-// It only saves a weak_ptr of the device pointer in the map, the shared_ptr
-// will be used to reconstruct all storages in this CudaMalloc allocation.
-// And it will deleted in cudaIpcCloseMemHandle when its reference count is 0.
+// ipcMemHandle_to_devptr maps a cudaIpcMemHandle_t to a device pointer in the
+// process that can be used to access the memory block in the sender process. It
+// only saves a weak_ptr of the device pointer in the map, the shared_ptr will
+// be used to reconstruct all storages in this CudaMalloc allocation. And it
+// will deleted in cudaIpcCloseMemHandle when its reference count is 0.
 //
 namespace {
-  std::mutex IpcMutex;
-  std::unordered_map<std::string, std::weak_ptr<void>> ipcMemHandle_to_devptr;
-}
+std::mutex IpcMutex;
+std::unordered_map<std::string, std::weak_ptr<void>> ipcMemHandle_to_devptr;
+} // namespace
 
 std::shared_ptr<void> getIpcDevPtr(std::string handle) {
   std::lock_guard<std::mutex> lock(IpcMutex);
@@ -1350,23 +1442,24 @@ std::shared_ptr<void> getIpcDevPtr(std::string handle) {
   auto iter = ipcMemHandle_to_devptr.find(handle);
   if (iter != ipcMemHandle_to_devptr.end()) {
     auto devptr = iter->second.lock();
-    if (devptr) return devptr;
+    if (devptr)
+      return devptr;
   }
   // This ipcMemHandle hasn't been opened, or already expired, open it to
   // enable IPC access to that mem block.
-  void *dev = nullptr;
+  void* dev = nullptr;
   auto ipc_handle = reinterpret_cast<const cudaIpcMemHandle_t*>(handle.c_str());
-  C10_CUDA_CHECK(cudaIpcOpenMemHandle(&dev, *ipc_handle, cudaIpcMemLazyEnablePeerAccess));
+  C10_CUDA_CHECK(
+      cudaIpcOpenMemHandle(&dev, *ipc_handle, cudaIpcMemLazyEnablePeerAccess));
   // devPtr has to be deleted in same device when created.
   int curr_device;
   C10_CUDA_CHECK(cudaGetDevice(&curr_device));
-  auto sp = std::shared_ptr<void>(
-      dev,
-      [handle, curr_device](void *ptr) {
-        cuda::CUDAGuard device_guard(curr_device);
-        std::lock_guard<std::mutex> deleter_lock(IpcMutex);
-        C10_CUDA_CHECK(cudaIpcCloseMemHandle(ptr));
-        ipcMemHandle_to_devptr.erase(handle);});
+  auto sp = std::shared_ptr<void>(dev, [handle, curr_device](void* ptr) {
+    cuda::CUDAGuard device_guard(curr_device);
+    std::lock_guard<std::mutex> deleter_lock(IpcMutex);
+    C10_CUDA_CHECK(cudaIpcCloseMemHandle(ptr));
+    ipcMemHandle_to_devptr.erase(handle);
+  });
   std::weak_ptr<void> wp = sp;
   // To eliminate an additional search, we can use insert().
   // It doesn't overwrite when key already exists(ptr expired).
@@ -1384,7 +1477,8 @@ void* raw_alloc(size_t nbytes) {
   int device;
   C10_CUDA_CHECK(cudaGetDevice(&device));
   void* r = nullptr;
-  caching_allocator.malloc(&r, device, nbytes, cuda::getCurrentCUDAStream(device));
+  caching_allocator.malloc(
+      &r, device, nbytes, cuda::getCurrentCUDAStream(device));
   return r;
 }
 
@@ -1405,4 +1499,5 @@ void raw_delete(void* ptr) {
 
 } // namespace CUDACachingAllocator
 
-}} // namespace c10::cuda
+} // namespace cuda
+} // namespace c10
diff --git a/c10/cuda/CUDACachingAllocator.h b/c10/cuda/CUDACachingAllocator.h
index 4b28b1ad40e..51f2c87e628 100644
--- a/c10/cuda/CUDACachingAllocator.h
+++ b/c10/cuda/CUDACachingAllocator.h
@@ -1,9 +1,9 @@
 #ifndef THC_DEVICE_ALLOCATOR_INC
 #define THC_DEVICE_ALLOCATOR_INC
-#include <c10/cuda/CUDAGraphsC10Utils.h>
-#include <c10/cuda/CUDAStream.h>
 #include <c10/core/Allocator.h>
+#include <c10/cuda/CUDAGraphsC10Utils.h>
 #include <c10/cuda/CUDAMacros.h>
+#include <c10/cuda/CUDAStream.h>
 #include <c10/util/Registry.h>
 
 #include <array>
@@ -19,7 +19,7 @@ class C10_CUDA_API CUDAOutOfMemoryError : public c10::Error {
 // block inside of already allocated area.
 class C10_CUDA_API FreeMemoryCallback {
  public:
-  virtual ~FreeMemoryCallback() {};
+  virtual ~FreeMemoryCallback(){};
   virtual bool Execute() = 0;
 };
 
@@ -55,7 +55,7 @@ enum struct StatType : uint64_t {
   AGGREGATE = 0,
   SMALL_POOL = 1,
   LARGE_POOL = 2,
-  NUM_TYPES = 3  // remember to update this whenever a new stat type is added
+  NUM_TYPES = 3 // remember to update this whenever a new stat type is added
 };
 
 typedef std::array<Stat, static_cast<size_t>(StatType::NUM_TYPES)> StatArray;
@@ -68,7 +68,8 @@ struct DeviceStats {
   StatArray segment;
   // COUNT: number of active memory blocks (allocated or used by stream)
   StatArray active;
-  // COUNT: number of inactive, split memory blocks (unallocated but can't be released via cudaFree)
+  // COUNT: number of inactive, split memory blocks (unallocated but can't be
+  // released via cudaFree)
   StatArray inactive_split;
 
   // SUM: bytes requested by client code
@@ -80,14 +81,16 @@ struct DeviceStats {
   // SUM: bytes within inactive, split memory blocks
   StatArray inactive_split_bytes;
 
-  // COUNT: total number of failed calls to CUDA malloc necessitating cache flushes.
+  // COUNT: total number of failed calls to CUDA malloc necessitating cache
+  // flushes.
   int64_t num_alloc_retries = 0;
 
   // COUNT: total number of OOMs (i.e. failed calls to CUDA after cache flush)
   int64_t num_ooms = 0;
 };
 
-// Struct containing info of an allocation block (i.e. a fractional part of a cudaMalloc)..
+// Struct containing info of an allocation block (i.e. a fractional part of a
+// cudaMalloc)..
 struct BlockInfo {
   int64_t size = 0;
   bool allocated = false;
@@ -113,8 +116,11 @@ C10_CUDA_API Allocator* get();
 C10_CUDA_API void init(int device_count);
 C10_CUDA_API void setMemoryFraction(double fraction, int device);
 C10_CUDA_API void emptyCache();
-C10_CUDA_API void cacheInfo(int dev_id, size_t* cachedAndFree, size_t* largestBlock);
-C10_CUDA_API void* getBaseAllocation(void *ptr, size_t *size);
+C10_CUDA_API void cacheInfo(
+    int dev_id,
+    size_t* cachedAndFree,
+    size_t* largestBlock);
+C10_CUDA_API void* getBaseAllocation(void* ptr, size_t* size);
 C10_CUDA_API void recordStream(const DataPtr&, CUDAStream stream);
 C10_CUDA_API DeviceStats getDeviceStats(int device);
 C10_CUDA_API void resetAccumulatedStats(int device);
@@ -122,9 +128,10 @@ C10_CUDA_API void resetPeakStats(int device);
 C10_CUDA_API std::vector<SegmentInfo> snapshot();
 
 // CUDAGraph interactions
-C10_CUDA_API void notifyCaptureBegin(int device,
-                                     CaptureId_t graph_id,
-                                     MempoolId_t mempool_id);
+C10_CUDA_API void notifyCaptureBegin(
+    int device,
+    CaptureId_t graph_id,
+    MempoolId_t mempool_id);
 C10_CUDA_API void notifyCaptureEnd(int device, CaptureId_t graph_id);
 C10_CUDA_API void notifyCaptureDestroy(int device, MempoolId_t mempool_id);
 
@@ -133,6 +140,7 @@ C10_CUDA_API std::mutex* getFreeMutex();
 C10_CUDA_API std::shared_ptr<void> getIpcDevPtr(std::string handle);
 } // namespace CUDACachingAllocator
 
-}} // namespace c10::cuda
+} // namespace cuda
+} // namespace c10
 
 #endif
diff --git a/c10/cuda/CUDAException.h b/c10/cuda/CUDAException.h
index 5d1a473b559..d438e4eb816 100644
--- a/c10/cuda/CUDAException.h
+++ b/c10/cuda/CUDAException.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <c10/util/Exception.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/Exception.h>
 #include <cuda.h>
 
 // Note [CHECK macro]
@@ -21,7 +21,7 @@
     }                                                                \
   } while (0)
 
-  #define C10_CUDA_CHECK_WARN(EXPR)                            \
+#define C10_CUDA_CHECK_WARN(EXPR)                              \
   do {                                                         \
     cudaError_t __err = EXPR;                                  \
     if (__err != cudaSuccess) {                                \
diff --git a/c10/cuda/CUDAFunctions.cpp b/c10/cuda/CUDAFunctions.cpp
index 9a68c3e2246..16730d81de3 100644
--- a/c10/cuda/CUDAFunctions.cpp
+++ b/c10/cuda/CUDAFunctions.cpp
@@ -101,7 +101,9 @@ DeviceIndex device_count() noexcept {
   static int count = []() {
     try {
       auto result = device_count_impl(/*fail_if_no_driver=*/false);
-      TORCH_INTERNAL_ASSERT(result <= std::numeric_limits<DeviceIndex>::max(), "Too many CUDA devices, DeviceIndex overflowed");
+      TORCH_INTERNAL_ASSERT(
+          result <= std::numeric_limits<DeviceIndex>::max(),
+          "Too many CUDA devices, DeviceIndex overflowed");
       return result;
     } catch (const c10::Error& ex) {
       // We don't want to fail, but still log the warning
diff --git a/c10/cuda/CUDAGraphsC10Utils.h b/c10/cuda/CUDAGraphsC10Utils.h
index 2239d3b0292..79d727feeb1 100644
--- a/c10/cuda/CUDAGraphsC10Utils.h
+++ b/c10/cuda/CUDAGraphsC10Utils.h
@@ -27,7 +27,7 @@ struct C10_CUDA_API CUDAStreamCaptureModeGuard {
     C10_CUDA_CHECK_WARN(cudaThreadExchangeStreamCaptureMode(&strictness_));
   }
 
-  private:
+ private:
   cudaStreamCaptureMode strictness_;
 };
 #endif
@@ -35,15 +35,18 @@ struct C10_CUDA_API CUDAStreamCaptureModeGuard {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
 // Protects against enum cudaStreamCaptureStatus implementation changes.
 // Some compilers seem not to like static_assert without the messages.
-static_assert(int(cudaStreamCaptureStatus::cudaStreamCaptureStatusNone) == 0,
-              "unexpected int(cudaStreamCaptureStatusNone) value");
-static_assert(int(cudaStreamCaptureStatus::cudaStreamCaptureStatusActive) == 1,
-              "unexpected int(cudaStreamCaptureStatusActive) value");
-static_assert(int(cudaStreamCaptureStatus::cudaStreamCaptureStatusInvalidated) == 2,
-              "unexpected int(cudaStreamCaptureStatusInvalidated) value");
+static_assert(
+    int(cudaStreamCaptureStatus::cudaStreamCaptureStatusNone) == 0,
+    "unexpected int(cudaStreamCaptureStatusNone) value");
+static_assert(
+    int(cudaStreamCaptureStatus::cudaStreamCaptureStatusActive) == 1,
+    "unexpected int(cudaStreamCaptureStatusActive) value");
+static_assert(
+    int(cudaStreamCaptureStatus::cudaStreamCaptureStatusInvalidated) == 2,
+    "unexpected int(cudaStreamCaptureStatusInvalidated) value");
 #endif
 
-enum class CaptureStatus: int {
+enum class CaptureStatus : int {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
   None = int(cudaStreamCaptureStatus::cudaStreamCaptureStatusNone),
   Active = int(cudaStreamCaptureStatus::cudaStreamCaptureStatusActive),
@@ -54,7 +57,7 @@ enum class CaptureStatus: int {
 };
 
 inline std::ostream& operator<<(std::ostream& os, CaptureStatus status) {
-  switch(status) {
+  switch (status) {
     case CaptureStatus::None:
       os << "cudaStreamCaptureStatusNone";
       break;
@@ -67,9 +70,8 @@ inline std::ostream& operator<<(std::ostream& os, CaptureStatus status) {
       break;
 #endif
     default:
-      TORCH_INTERNAL_ASSERT(false,
-                            "Unknown CUDA graph CaptureStatus",
-                            int(status));
+      TORCH_INTERNAL_ASSERT(
+          false, "Unknown CUDA graph CaptureStatus", int(status));
   }
   return os;
 }
@@ -78,13 +80,13 @@ inline std::ostream& operator<<(std::ostream& os, CaptureStatus status) {
 inline CaptureStatus currentStreamCaptureStatusMayInitCtx() {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
   cudaStreamCaptureStatus is_capturing;
-  C10_CUDA_CHECK(cudaStreamIsCapturing(c10::cuda::getCurrentCUDAStream(),
-                                      &is_capturing));
+  C10_CUDA_CHECK(
+      cudaStreamIsCapturing(c10::cuda::getCurrentCUDAStream(), &is_capturing));
   return CaptureStatus(is_capturing);
 #else
   return CaptureStatus::None;
 #endif
 }
 
-} // namespace c10
 } // namespace cuda
+} // namespace c10
diff --git a/c10/cuda/CUDAGuard.h b/c10/cuda/CUDAGuard.h
index f5ec3434388..905dcf9c6ff 100644
--- a/c10/cuda/CUDAGuard.h
+++ b/c10/cuda/CUDAGuard.h
@@ -1,16 +1,18 @@
 #pragma once
 
-#include <c10/cuda/impl/CUDAGuardImpl.h>
-#include <c10/cuda/CUDAMacros.h>
 #include <c10/core/DeviceType.h>
 #include <c10/core/impl/InlineDeviceGuard.h>
 #include <c10/core/impl/InlineStreamGuard.h>
+#include <c10/cuda/CUDAMacros.h>
+#include <c10/cuda/impl/CUDAGuardImpl.h>
 
 #include <cstddef>
 
-namespace c10 { namespace cuda {
+namespace c10 {
+namespace cuda {
 
-// This code is kind of boilerplatey.  See Note [Whither the DeviceGuard boilerplate]
+// This code is kind of boilerplatey.  See Note [Whither the DeviceGuard
+// boilerplate]
 
 /// A variant of DeviceGuard that is specialized for CUDA.  It accepts
 /// integer indices (interpreting them as CUDA devices) and is a little
@@ -38,22 +40,32 @@ struct CUDAGuard {
 
   /// Sets the CUDA device to the given device.  Errors if the given device
   /// is not a CUDA device.
-  void set_device(Device device) { guard_.set_device(device); }
+  void set_device(Device device) {
+    guard_.set_device(device);
+  }
 
   /// Sets the CUDA device to the given device.  Errors if the given device
   /// is not a CUDA device.  (This method is provided for uniformity with
   /// DeviceGuard).
-  void reset_device(Device device) { guard_.reset_device(device); }
+  void reset_device(Device device) {
+    guard_.reset_device(device);
+  }
 
   /// Sets the CUDA device to the given device index.
-  void set_index(DeviceIndex device_index) { guard_.set_index(device_index); }
+  void set_index(DeviceIndex device_index) {
+    guard_.set_index(device_index);
+  }
 
   /// Returns the device that was set upon construction of the guard
-  Device original_device() const { return guard_.original_device(); }
+  Device original_device() const {
+    return guard_.original_device();
+  }
 
-  /// Returns the last device that was set via `set_device`, if any, otherwise the
-  /// device passed during construction.
-  Device current_device() const { return guard_.current_device(); }
+  /// Returns the last device that was set via `set_device`, if any, otherwise
+  /// the device passed during construction.
+  Device current_device() const {
+    return guard_.current_device();
+  }
 
  private:
   /// The guard for the current device.
@@ -67,11 +79,13 @@ struct OptionalCUDAGuard {
   explicit OptionalCUDAGuard() : guard_() {}
 
   /// Set the current CUDA device to the passed Device, if it is not nullopt.
-  explicit OptionalCUDAGuard(optional<Device> device_opt) : guard_(device_opt) {}
+  explicit OptionalCUDAGuard(optional<Device> device_opt)
+      : guard_(device_opt) {}
 
   /// Set the current CUDA device to the passed device index, if it is not
   /// nullopt
-  explicit OptionalCUDAGuard(optional<DeviceIndex> device_index_opt) : guard_(device_index_opt) {}
+  explicit OptionalCUDAGuard(optional<DeviceIndex> device_index_opt)
+      : guard_(device_index_opt) {}
 
   // Copy is not allowed
   OptionalCUDAGuard(const OptionalCUDAGuard&) = delete;
@@ -84,31 +98,45 @@ struct OptionalCUDAGuard {
   OptionalCUDAGuard& operator=(OptionalCUDAGuard&& other) = delete;
 
   /// Sets the CUDA device to the given device, initializing the guard if it
-  /// is not already initialized.  Errors if the given device is not a CUDA device.
-  void set_device(Device device) { guard_.set_device(device); }
+  /// is not already initialized.  Errors if the given device is not a CUDA
+  /// device.
+  void set_device(Device device) {
+    guard_.set_device(device);
+  }
 
   /// Sets the CUDA device to the given device, initializing the guard if it is
   /// not already initialized.  Errors if the given device is not a CUDA device.
   /// (This method is provided for uniformity with OptionalDeviceGuard).
-  void reset_device(Device device) { guard_.reset_device(device); }
+  void reset_device(Device device) {
+    guard_.reset_device(device);
+  }
 
   /// Sets the CUDA device to the given device index, initializing the guard if
   /// it is not already initialized.
-  void set_index(DeviceIndex device_index) { guard_.set_index(device_index); }
+  void set_index(DeviceIndex device_index) {
+    guard_.set_index(device_index);
+  }
 
   /// Returns the device that was set immediately prior to initialization of the
   /// guard, or nullopt if the guard is uninitialized.
-  optional<Device> original_device() const { return guard_.original_device(); }
+  optional<Device> original_device() const {
+    return guard_.original_device();
+  }
 
   /// Returns the most recent device that was set using this device guard,
   /// either from construction, or via set_device, if the guard is initialized,
   /// or nullopt if the guard is uninitialized.
-  optional<Device> current_device() const { return guard_.current_device(); }
+  optional<Device> current_device() const {
+    return guard_.current_device();
+  }
 
-  /// Restore the original CUDA device, resetting this guard to uninitialized state.
-  void reset() { guard_.reset(); }
+  /// Restore the original CUDA device, resetting this guard to uninitialized
+  /// state.
+  void reset() {
+    guard_.reset();
+  }
 
-private:
+ private:
   c10::impl::InlineOptionalDeviceGuard<impl::CUDAGuardImpl> guard_;
 };
 
@@ -118,17 +146,17 @@ struct CUDAStreamGuard {
   /// No default constructor, see Note [Omitted default constructor from RAII]
   explicit CUDAStreamGuard() = delete;
 
-  /// Set the current CUDA device to the device associated with the passed stream,
-  /// and set the current CUDA stream on that device to the passed stream.
-  /// Errors if the Stream is not a CUDA stream.
+  /// Set the current CUDA device to the device associated with the passed
+  /// stream, and set the current CUDA stream on that device to the passed
+  /// stream. Errors if the Stream is not a CUDA stream.
   explicit CUDAStreamGuard(Stream stream) : guard_(stream) {}
 
   /// Copy is disallowed
   CUDAStreamGuard(const CUDAStreamGuard&) = delete;
   CUDAStreamGuard& operator=(const CUDAStreamGuard&) = delete;
 
-  /// Move is disallowed, as CUDAStreamGuard does not have an uninitialized state,
-  /// which is required for moves on types with nontrivial destructors.
+  /// Move is disallowed, as CUDAStreamGuard does not have an uninitialized
+  /// state, which is required for moves on types with nontrivial destructors.
   CUDAStreamGuard(CUDAStreamGuard&& other) = delete;
   CUDAStreamGuard& operator=(CUDAStreamGuard&& other) = delete;
 
@@ -144,9 +172,12 @@ struct CUDAStreamGuard {
   /// WARNING: reset_stream does NOT preserve previously set streams on
   /// different devices.  If you need to set streams on multiple devices
   /// on CUDA, use CUDAMultiStreamGuard instead.
-  void reset_stream(Stream stream) { guard_.reset_stream(stream); }
+  void reset_stream(Stream stream) {
+    guard_.reset_stream(stream);
+  }
 
-  /// Returns the CUDA stream that was set at the time the guard was constructed.
+  /// Returns the CUDA stream that was set at the time the guard was
+  /// constructed.
   CUDAStream original_stream() const {
     return CUDAStream(CUDAStream::UNCHECKED, guard_.original_stream());
   }
@@ -159,31 +190,36 @@ struct CUDAStreamGuard {
 
   /// Returns the most recent CUDA device that was set using this device guard,
   /// either from construction, or via set_device/reset_device/set_index.
-  Device current_device() const { return guard_.current_device(); }
+  Device current_device() const {
+    return guard_.current_device();
+  }
 
   /// Returns the CUDA device that was set at the most recent reset_stream(),
   /// or otherwise the device at construction time.
-  Device original_device() const { return guard_.original_device(); }
+  Device original_device() const {
+    return guard_.original_device();
+  }
 
-private:
+ private:
   c10::impl::InlineStreamGuard<impl::CUDAGuardImpl> guard_;
 };
 
-/// A variant of OptionalStreamGuard that is specialized for CUDA.  See CUDAGuard
-/// for when you can use this.
+/// A variant of OptionalStreamGuard that is specialized for CUDA.  See
+/// CUDAGuard for when you can use this.
 struct OptionalCUDAStreamGuard {
   /// Create an uninitialized guard.
   explicit OptionalCUDAStreamGuard() : guard_() {}
 
-  /// Set the current CUDA device to the device associated with the passed stream,
-  /// and set the current CUDA stream on that device to the passed stream.
-  /// Errors if the Stream is not a CUDA stream.
+  /// Set the current CUDA device to the device associated with the passed
+  /// stream, and set the current CUDA stream on that device to the passed
+  /// stream. Errors if the Stream is not a CUDA stream.
   explicit OptionalCUDAStreamGuard(Stream stream) : guard_(stream) {}
 
   /// Set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream,
   /// if the passed stream is not nullopt.
-  explicit OptionalCUDAStreamGuard(optional<Stream> stream_opt) : guard_(stream_opt) {}
+  explicit OptionalCUDAStreamGuard(optional<Stream> stream_opt)
+      : guard_(stream_opt) {}
 
   /// Copy is disallowed
   OptionalCUDAStreamGuard(const OptionalCUDAStreamGuard&) = delete;
@@ -200,10 +236,12 @@ struct OptionalCUDAStreamGuard {
   /// set the current device to the device associated with the passed stream,
   /// and set the current stream on that device to the passed stream.
   /// Initializes the guard if it was not previously initialized.
-  void reset_stream(Stream stream) { guard_.reset_stream(stream); }
+  void reset_stream(Stream stream) {
+    guard_.reset_stream(stream);
+  }
 
-  /// Returns the CUDA stream that was set at the time the guard was most recently
-  /// initialized, or nullopt if the guard is uninitialized.
+  /// Returns the CUDA stream that was set at the time the guard was most
+  /// recently initialized, or nullopt if the guard is uninitialized.
   optional<CUDAStream> original_stream() const {
     auto r = guard_.original_stream();
     if (r.has_value()) {
@@ -214,8 +252,8 @@ struct OptionalCUDAStreamGuard {
   }
 
   /// Returns the most recent CUDA stream that was set using this stream guard,
-  /// either from construction, or via reset_stream, if the guard is initialized,
-  /// or nullopt if the guard is uninitialized.
+  /// either from construction, or via reset_stream, if the guard is
+  /// initialized, or nullopt if the guard is uninitialized.
   optional<CUDAStream> current_stream() const {
     auto r = guard_.current_stream();
     if (r.has_value()) {
@@ -225,17 +263,20 @@ struct OptionalCUDAStreamGuard {
     }
   }
 
-  /// Restore the original CUDA device and stream, resetting this guard to uninitialized state.
-  void reset() { guard_.reset(); }
+  /// Restore the original CUDA device and stream, resetting this guard to
+  /// uninitialized state.
+  void reset() {
+    guard_.reset();
+  }
 
-private:
+ private:
   c10::impl::InlineOptionalStreamGuard<impl::CUDAGuardImpl> guard_;
 };
 
 /// A variant of MultiStreamGuard that is specialized for CUDA.
 struct CUDAMultiStreamGuard {
   explicit CUDAMultiStreamGuard(ArrayRef<CUDAStream> streams)
-    : guard_(unwrapStreams(streams)) {}
+      : guard_(unwrapStreams(streams)) {}
 
   /// Copy is disallowed
   CUDAMultiStreamGuard(const CUDAMultiStreamGuard&) = delete;
@@ -247,7 +288,7 @@ struct CUDAMultiStreamGuard {
   // See Note [Move assignment for RAII guards is tricky]
   CUDAMultiStreamGuard& operator=(CUDAMultiStreamGuard&& other) = delete;
 
-private:
+ private:
   c10::impl::InlineMultiStreamGuard<impl::CUDAGuardImpl> guard_;
 
   static std::vector<Stream> unwrapStreams(ArrayRef<CUDAStream> cudaStreams) {
diff --git a/c10/cuda/CUDAStream.cpp b/c10/cuda/CUDAStream.cpp
index a3edfabae9f..c32580bf799 100644
--- a/c10/cuda/CUDAStream.cpp
+++ b/c10/cuda/CUDAStream.cpp
@@ -1,6 +1,6 @@
-#include <c10/cuda/CUDAStream.h>
 #include <c10/cuda/CUDAFunctions.h>
 #include <c10/cuda/CUDAGuard.h>
+#include <c10/cuda/CUDAStream.h>
 #include <c10/util/Exception.h>
 #include <c10/util/irange.h>
 
@@ -204,7 +204,7 @@ static void initGlobalStreamState() {
       "). Increase that and recompile.");
 
   // Initializes default streams
-  for (const auto i: c10::irange(num_gpus)) {
+  for (const auto i : c10::irange(num_gpus)) {
     default_streams[i].device_index = i;
     low_priority_counters[i] = 0;
     high_priority_counters[i] = 0;
@@ -218,7 +218,7 @@ static void initDeviceStreamState(DeviceIndex device_index) {
   // with it.
   CUDAGuard device_guard{device_index};
 
-  for (const auto i: c10::irange(kStreamsPerPool)) {
+  for (const auto i : c10::irange(kStreamsPerPool)) {
     auto& lowpri_stream = low_priority_streams[device_index][i];
     auto& hipri_stream = high_priority_streams[device_index][i];
 
@@ -244,7 +244,7 @@ static void initCUDAStreamsOnce() {
   // Inits current streams (thread local) to default streams
   current_streams =
       (LeakyStreamInternals**)malloc(num_gpus * sizeof(LeakyStreamInternals*));
-  for (const auto i: c10::irange(num_gpus)) {
+  for (const auto i : c10::irange(num_gpus)) {
     current_streams[i] = &default_streams[i];
   }
 }
diff --git a/c10/cuda/CUDAStream.h b/c10/cuda/CUDAStream.h
index 05eddf5ce12..2e00ecc4a02 100644
--- a/c10/cuda/CUDAStream.h
+++ b/c10/cuda/CUDAStream.h
@@ -5,53 +5,53 @@
 
 #include <cuda_runtime_api.h>
 
+#include <c10/core/DeviceGuard.h>
+#include <c10/core/Stream.h>
 #include <c10/cuda/CUDAException.h>
 #include <c10/cuda/CUDAMacros.h>
-#include <c10/core/DeviceGuard.h>
 #include <c10/util/Exception.h>
-#include <c10/core/Stream.h>
 
 /*
-* Stream pool note.
-*
-* A CUDAStream is an abstraction of an actual cuStream on the GPU. CUDAStreams
-* are backed by cuStreams, but they use several pools to minimize the costs
-* associated with creating, retaining, and destroying cuStreams.
-*
-* There are three pools per device, and a device's pools are lazily created.
-*
-* The first pool contains only the default stream. When the default stream
-* is requested it's returned.
-*
-* The second pool is the "low priority" or "default priority" streams. In
-* HIP builds there is no distinction between streams in this pool and streams
-* in the third pool (below). There are 32 of these streams per device, and
-* when a stream is requested one of these streams is returned round-robin.
-* That is, the first stream requested is at index 0, the second at index 1...
-* to index 31, then index 0 again.
-*
-* This means that if 33 low priority streams are requested, the first and
-* last streams requested are actually the same stream (under the covers)
-* and kernels enqueued on them cannot run concurrently.
-*
-* The third pool is the "high priority" streams. The third pool acts like
-* the second pool except the streams are created with a higher priority.
-*
-* These pools suggest that stream users should prefer many short-lived streams,
-* as the cost of acquiring and releasing streams is effectively zero. If
-* many longer-lived streams are required in performance critical scenarios
-* then the functionality here may need to be extended to allow, for example,
-* "reserving" a subset of the pool so that other streams do not accidentally
-* overlap the performance critical streams.
-*
-* Note: although the notion of "current stream for device" is thread local
-* (every OS thread has a separate current stream, as one might expect),
-* the stream pool is global across all threads; stream 0 is always stream 0
-* no matter which thread you use it on.  Multiple threads can synchronize
-* on the same stream.  Although the CUDA documentation is not very clear
-* on the matter, streams are thread safe; e.g., it is safe to enqueue
-* a kernel on the same stream from two different threads.
-*/
+ * Stream pool note.
+ *
+ * A CUDAStream is an abstraction of an actual cuStream on the GPU. CUDAStreams
+ * are backed by cuStreams, but they use several pools to minimize the costs
+ * associated with creating, retaining, and destroying cuStreams.
+ *
+ * There are three pools per device, and a device's pools are lazily created.
+ *
+ * The first pool contains only the default stream. When the default stream
+ * is requested it's returned.
+ *
+ * The second pool is the "low priority" or "default priority" streams. In
+ * HIP builds there is no distinction between streams in this pool and streams
+ * in the third pool (below). There are 32 of these streams per device, and
+ * when a stream is requested one of these streams is returned round-robin.
+ * That is, the first stream requested is at index 0, the second at index 1...
+ * to index 31, then index 0 again.
+ *
+ * This means that if 33 low priority streams are requested, the first and
+ * last streams requested are actually the same stream (under the covers)
+ * and kernels enqueued on them cannot run concurrently.
+ *
+ * The third pool is the "high priority" streams. The third pool acts like
+ * the second pool except the streams are created with a higher priority.
+ *
+ * These pools suggest that stream users should prefer many short-lived streams,
+ * as the cost of acquiring and releasing streams is effectively zero. If
+ * many longer-lived streams are required in performance critical scenarios
+ * then the functionality here may need to be extended to allow, for example,
+ * "reserving" a subset of the pool so that other streams do not accidentally
+ * overlap the performance critical streams.
+ *
+ * Note: although the notion of "current stream for device" is thread local
+ * (every OS thread has a separate current stream, as one might expect),
+ * the stream pool is global across all threads; stream 0 is always stream 0
+ * no matter which thread you use it on.  Multiple threads can synchronize
+ * on the same stream.  Although the CUDA documentation is not very clear
+ * on the matter, streams are thread safe; e.g., it is safe to enqueue
+ * a kernel on the same stream from two different threads.
+ */
 
 namespace c10 {
 namespace cuda {
@@ -61,8 +61,7 @@ namespace cuda {
 // functionality (conversion to cudaStream_t), and a guarantee that
 // the wrapped c10::Stream really is a CUDA stream.
 class C10_CUDA_API CUDAStream {
-public:
-
+ public:
   enum Unchecked { UNCHECKED };
 
   /// Construct a CUDAStream from a Stream.  This construction is checked,
@@ -85,21 +84,31 @@ public:
   }
 
   /// Implicit conversion to cudaStream_t.
-  operator cudaStream_t() const { return stream(); }
+  operator cudaStream_t() const {
+    return stream();
+  }
 
   /// Implicit conversion to Stream (a.k.a., forget that the stream is a
   /// CUDA stream).
-  operator Stream() const { return unwrap(); }
+  operator Stream() const {
+    return unwrap();
+  }
 
   /// Get the CUDA device index that this stream is associated with.
-  DeviceIndex device_index() const { return stream_.device_index(); }
+  DeviceIndex device_index() const {
+    return stream_.device_index();
+  }
 
   /// Get the full Device that this stream is associated with.  The Device
   /// is guaranteed to be a CUDA device.
-  Device device() const { return Device(DeviceType::CUDA, device_index()); }
+  Device device() const {
+    return Device(DeviceType::CUDA, device_index());
+  }
 
   /// Return the stream ID corresponding to this particular stream.
-  StreamId id() const { return stream_.id(); }
+  StreamId id() const {
+    return stream_.id();
+  }
 
   bool query() const {
     DeviceGuard guard{stream_.device()};
@@ -120,17 +129,19 @@ public:
   }
 
   int priority() const {
-      DeviceGuard guard{stream_.device()};
-      int priority = 0;
-      C10_CUDA_CHECK(cudaStreamGetPriority(stream(), &priority));
-      return priority;
+    DeviceGuard guard{stream_.device()};
+    int priority = 0;
+    C10_CUDA_CHECK(cudaStreamGetPriority(stream(), &priority));
+    return priority;
   }
 
   /// Explicit conversion to cudaStream_t.
   cudaStream_t stream() const;
 
   /// Explicit conversion to Stream.
-  Stream unwrap() const { return stream_; }
+  Stream unwrap() const {
+    return stream_;
+  }
 
   /// Reversibly pack a CUDAStream into a uint64_t representation.  This may
   /// be helpful when storing a CUDAStream in a C struct, where you cannot
@@ -150,22 +161,24 @@ public:
   }
 
   static std::tuple<int, int> priority_range() {
-      // Note: this returns the range of priority **supported by PyTorch**, not
-      // the range of priority **supported by CUDA**. The former is a subset of
-      // the latter. Currently PyTorch only supports 0 and -1, which are "low" and
-      // "high" priority.
-      int least_priority, greatest_priority;
-      C10_CUDA_CHECK(
+    // Note: this returns the range of priority **supported by PyTorch**, not
+    // the range of priority **supported by CUDA**. The former is a subset of
+    // the latter. Currently PyTorch only supports 0 and -1, which are "low" and
+    // "high" priority.
+    int least_priority, greatest_priority;
+    C10_CUDA_CHECK(
         cudaDeviceGetStreamPriorityRange(&least_priority, &greatest_priority));
-      TORCH_INTERNAL_ASSERT(least_priority >= 0, "Unexpected CUDA stream priority range");
-      TORCH_INTERNAL_ASSERT(greatest_priority <= -1, "Unexpected CUDA stream priority range");
-      return std::make_tuple(0, -1);
+    TORCH_INTERNAL_ASSERT(
+        least_priority >= 0, "Unexpected CUDA stream priority range");
+    TORCH_INTERNAL_ASSERT(
+        greatest_priority <= -1, "Unexpected CUDA stream priority range");
+    return std::make_tuple(0, -1);
   }
 
   // Deleted for now; use CUDAEvent::block instead
   // void synchronize_with(const CUDAEvent& event) const;
 
-private:
+ private:
   Stream stream_;
 };
 
@@ -214,13 +227,13 @@ TORCH_API void setCurrentCUDAStream(CUDAStream stream);
 C10_API std::ostream& operator<<(std::ostream& stream, const CUDAStream& s);
 
 } // namespace cuda
-} // namespace at
+} // namespace c10
 
 namespace std {
-  template <>
-  struct hash<c10::cuda::CUDAStream> {
-    size_t operator()(c10::cuda::CUDAStream s) const noexcept {
-      return std::hash<c10::Stream>{}(s.unwrap());
-    }
-  };
+template <>
+struct hash<c10::cuda::CUDAStream> {
+  size_t operator()(c10::cuda::CUDAStream s) const noexcept {
+    return std::hash<c10::Stream>{}(s.unwrap());
+  }
+};
 } // namespace std
diff --git a/c10/cuda/impl/CUDAGuardImpl.cpp b/c10/cuda/impl/CUDAGuardImpl.cpp
index b0be6791bd0..6bed0c0c69d 100644
--- a/c10/cuda/impl/CUDAGuardImpl.cpp
+++ b/c10/cuda/impl/CUDAGuardImpl.cpp
@@ -8,4 +8,6 @@ constexpr DeviceType CUDAGuardImpl::static_type;
 
 C10_REGISTER_GUARD_IMPL(CUDA, CUDAGuardImpl);
 
-}}} // namespace c10::cuda::detail
+} // namespace impl
+} // namespace cuda
+} // namespace c10
diff --git a/c10/cuda/impl/CUDAGuardImpl.h b/c10/cuda/impl/CUDAGuardImpl.h
index 02a8596c7ba..e938fb0101f 100644
--- a/c10/cuda/impl/CUDAGuardImpl.h
+++ b/c10/cuda/impl/CUDAGuardImpl.h
@@ -4,10 +4,10 @@
 #include <c10/macros/Macros.h>
 #include <c10/util/Exception.h>
 
-#include <c10/cuda/CUDAException.h>
-#include <c10/cuda/CUDAStream.h>
-#include <c10/cuda/CUDAFunctions.h>
 #include <c10/cuda/CUDACachingAllocator.h>
+#include <c10/cuda/CUDAException.h>
+#include <c10/cuda/CUDAFunctions.h>
+#include <c10/cuda/CUDAStream.h>
 
 #include <cuda_runtime_api.h>
 
@@ -82,9 +82,7 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
   }
 
   // Event-related functions
-  void createEvent(
-    cudaEvent_t* cuda_event,
-    const EventFlag flag) const {
+  void createEvent(cudaEvent_t* cuda_event, const EventFlag flag) const {
     // Maps PyTorch's Event::Flag to CUDA flag
     auto cuda_flag = cudaEventDefault;
     switch (flag) {
@@ -103,10 +101,10 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
     C10_CUDA_CHECK(cudaEventCreateWithFlags(cuda_event, cuda_flag));
   }
 
-  void destroyEvent(
-    void* event,
-    const DeviceIndex device_index) const noexcept override {
-    if (!event) return;
+  void destroyEvent(void* event, const DeviceIndex device_index)
+      const noexcept override {
+    if (!event)
+      return;
     auto cuda_event = static_cast<cudaEvent_t>(event);
     int orig_device;
     C10_CUDA_CHECK_WARN(cudaGetDevice(&orig_device));
@@ -116,16 +114,17 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
   }
 
   void record(
-    void** event,
-    const Stream& stream,
-    const DeviceIndex device_index,
-    const EventFlag flag) const override {
-    TORCH_CHECK(device_index == -1 || device_index == stream.device_index(),
-      "Event device index ",
-      device_index,
-      " does not match recording stream's device index ",
-      stream.device_index(),
-      ".");
+      void** event,
+      const Stream& stream,
+      const DeviceIndex device_index,
+      const EventFlag flag) const override {
+    TORCH_CHECK(
+        device_index == -1 || device_index == stream.device_index(),
+        "Event device index ",
+        device_index,
+        " does not match recording stream's device index ",
+        stream.device_index(),
+        ".");
 
     cudaEvent_t cuda_event = static_cast<cudaEvent_t>(*event);
     CUDAStream cuda_stream{stream};
@@ -135,7 +134,8 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
     setDevice(stream.device());
 
     // Creates the event (lazily)
-    if (!cuda_event) createEvent(&cuda_event, flag);
+    if (!cuda_event)
+      createEvent(&cuda_event, flag);
     C10_CUDA_CHECK(cudaEventRecord(cuda_event, cuda_stream));
     // Makes the void* point to the (possibly just allocated) CUDA event
     *event = cuda_event;
@@ -144,24 +144,24 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
     setDevice(orig_device);
   }
 
-  void block(
-    void* event,
-    const Stream& stream) const override {
-    if (!event) return;
+  void block(void* event, const Stream& stream) const override {
+    if (!event)
+      return;
     cudaEvent_t cuda_event = static_cast<cudaEvent_t>(event);
     CUDAStream cuda_stream{stream};
     const auto orig_device = getDevice();
     setDevice(stream.device());
     C10_CUDA_CHECK(cudaStreamWaitEvent(
-      cuda_stream,
-      cuda_event,
-      /*flags (must be zero)=*/ 0));
+        cuda_stream,
+        cuda_event,
+        /*flags (must be zero)=*/0));
     setDevice(orig_device);
   }
 
   // May be called from any device
   bool queryEvent(void* event) const override {
-    if (!event) return true;
+    if (!event)
+      return true;
     cudaEvent_t cuda_event = static_cast<cudaEvent_t>(event);
     const cudaError_t err = cudaEventQuery(cuda_event);
     if (err != cudaErrorNotReady) {
@@ -170,12 +170,13 @@ struct CUDAGuardImpl final : public c10::impl::DeviceGuardImplInterface {
     return (err == cudaSuccess);
   }
 
-  void recordDataPtrOnStream(
-    const c10::DataPtr& data_ptr,
-    const Stream& stream) const override {
+  void recordDataPtrOnStream(const c10::DataPtr& data_ptr, const Stream& stream)
+      const override {
     CUDAStream cuda_stream{stream};
     CUDACachingAllocator::recordStream(data_ptr, cuda_stream);
   }
 };
 
-}}} // namespace c10::cuda::impl
+} // namespace impl
+} // namespace cuda
+} // namespace c10
diff --git a/c10/cuda/impl/CUDATest.cpp b/c10/cuda/impl/CUDATest.cpp
index 3746d14ae51..fb58d1c3a0f 100644
--- a/c10/cuda/impl/CUDATest.cpp
+++ b/c10/cuda/impl/CUDATest.cpp
@@ -29,4 +29,6 @@ int c10_cuda_private_test() {
   return 2;
 }
 
-}}} // namespace c10::cuda::impl
+} // namespace impl
+} // namespace cuda
+} // namespace c10
diff --git a/c10/cuda/impl/CUDATest.h b/c10/cuda/impl/CUDATest.h
index ccfe38e0209..593905d1567 100644
--- a/c10/cuda/impl/CUDATest.h
+++ b/c10/cuda/impl/CUDATest.h
@@ -8,4 +8,6 @@ namespace impl {
 
 C10_CUDA_API int c10_cuda_test();
 
-}}} /// namespace c10::cuda::impl
+}
+} // namespace cuda
+} // namespace c10
diff --git a/c10/macros/Export.h b/c10/macros/Export.h
index 7319081ef34..b439e74b37e 100644
--- a/c10/macros/Export.h
+++ b/c10/macros/Export.h
@@ -102,17 +102,17 @@
 // two pieces with confusing names?
 // Once upon a time, there _was_ only TORCH_CUDA_API. All was happy until we
 // tried to compile PyTorch for CUDA 11.1, which ran into relocation marker
-// issues when linking big binaries. (https://github.com/pytorch/pytorch/issues/39968)
-// We had two choices:
+// issues when linking big binaries.
+// (https://github.com/pytorch/pytorch/issues/39968) We had two choices:
 //    (1) Stop supporting so many GPU architectures
 //    (2) Do something else
 // We chose #2 and decided to split the behemoth that was torch_cuda into two
 // smaller libraries, one with most of the core kernel functions (torch_cuda_cu)
-// and the other that had..well..everything else (torch_cuda_cpp). The idea was this:
-// instead of linking our static libraries (like the hefty libcudnn_static.a) with
-// another huge library, torch_cuda, and run into pesky relocation marker issues,
-// we could link our static libraries to a smaller part of torch_cuda (torch_cuda_cpp)
-// and avoid the issues.
+// and the other that had..well..everything else (torch_cuda_cpp). The idea was
+// this: instead of linking our static libraries (like the hefty
+// libcudnn_static.a) with another huge library, torch_cuda, and run into pesky
+// relocation marker issues, we could link our static libraries to a smaller
+// part of torch_cuda (torch_cuda_cpp) and avoid the issues.
 
 // libtorch_cuda_cu.so
 #ifdef TORCH_CUDA_CU_BUILD_MAIN_LIB
@@ -128,7 +128,8 @@
 #define TORCH_CUDA_CPP_API C10_IMPORT
 #endif
 
-// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the same api)
+// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the
+// same api)
 #ifdef TORCH_CUDA_BUILD_MAIN_LIB
 #define TORCH_CUDA_CPP_API C10_EXPORT
 #define TORCH_CUDA_CU_API C10_EXPORT
diff --git a/c10/macros/Macros.h b/c10/macros/Macros.h
index 7c1ba643f81..4d869b6aa6b 100644
--- a/c10/macros/Macros.h
+++ b/c10/macros/Macros.h
@@ -24,16 +24,17 @@
 #include <c10/macros/Export.h>
 
 #if defined(__clang__)
-  #define __ubsan_ignore_float_divide_by_zero__ __attribute__((no_sanitize("float-divide-by-zero")))
-  #define __ubsan_ignore_undefined__ __attribute__((no_sanitize("undefined")))
-  #define __ubsan_ignore_signed_int_overflow__ __attribute__((no_sanitize("signed-integer-overflow")))
+#define __ubsan_ignore_float_divide_by_zero__ \
+  __attribute__((no_sanitize("float-divide-by-zero")))
+#define __ubsan_ignore_undefined__ __attribute__((no_sanitize("undefined")))
+#define __ubsan_ignore_signed_int_overflow__ \
+  __attribute__((no_sanitize("signed-integer-overflow")))
 #else
-  #define __ubsan_ignore_float_divide_by_zero__
-  #define __ubsan_ignore_undefined__
-  #define __ubsan_ignore_signed_int_overflow__
+#define __ubsan_ignore_float_divide_by_zero__
+#define __ubsan_ignore_undefined__
+#define __ubsan_ignore_signed_int_overflow__
 #endif
 
-
 // Detect address sanitizer as some stuff doesn't work with it
 #undef C10_ASAN_ENABLED
 
@@ -57,7 +58,6 @@
 #define C10_ASAN_ENABLED 0
 #endif
 
-
 // Disable the copy and assignment operator for a class. Note that this will
 // disable the usage of the class in std containers.
 #define C10_DISABLE_COPY_AND_ASSIGN(classname) \
@@ -84,7 +84,6 @@
 #define C10_ANONYMOUS_VARIABLE(str) C10_CONCATENATE(str, __LINE__)
 #endif
 
-
 /// C10_NODISCARD - Warn if a type or return value is discarded.
 
 // Technically, we should check if __cplusplus > 201402L here, because
@@ -108,24 +107,25 @@
 //  - gcc 8.3: https://godbolt.org/z/4tLMQS (always advertises support)
 #define C10_NODISCARD
 #if defined(__has_cpp_attribute)
-# if __has_cpp_attribute(nodiscard)
-#  undef C10_NODISCARD
-#  define C10_NODISCARD [[nodiscard]]
-# endif
+#if __has_cpp_attribute(nodiscard)
+#undef C10_NODISCARD
+#define C10_NODISCARD [[nodiscard]]
+#endif
 // Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
 // error when __has_cpp_attribute is given a scoped attribute in C mode.
 #elif __cplusplus && defined(__has_cpp_attribute)
-# if __has_cpp_attribute(clang::warn_unused_result)
-// TODO: It's possible this is still triggering https://github.com/pytorch/pytorch/issues/13118
-// on Windows; if it is, better fix it.
-#  undef C10_NODISCARD
-#  define C10_NODISCARD [[clang::warn_unused_result]]
-# endif
+#if __has_cpp_attribute(clang::warn_unused_result)
+// TODO: It's possible this is still triggering
+// https://github.com/pytorch/pytorch/issues/13118 on Windows; if it is, better
+// fix it.
+#undef C10_NODISCARD
+#define C10_NODISCARD [[clang::warn_unused_result]]
+#endif
 #endif
 
 // suppress an unused variable.
 #if defined(_MSC_VER) && !defined(__clang__)
-#define C10_UNUSED __pragma(warning(suppress: 4100 4101))
+#define C10_UNUSED __pragma(warning(suppress : 4100 4101))
 #else
 #define C10_UNUSED __attribute__((__unused__))
 #endif //_MSC_VER
@@ -135,16 +135,28 @@
 // Simply define the namespace, in case a dependent library want to refer to
 // the c10 namespace but not any nontrivial files.
 namespace c10 {} // namespace c10
-namespace c10 { namespace cuda {} }
-namespace c10 { namespace hip {} }
+namespace c10 {
+namespace cuda {}
+} // namespace c10
+namespace c10 {
+namespace hip {}
+} // namespace c10
 
 // Since C10 is the core library for caffe2 (and aten), we will simply reroute
 // all abstractions defined in c10 to be available in caffe2 as well.
 // This is only for backwards compatibility. Please use the symbols from the
 // c10 namespace where possible.
-namespace caffe2 { using namespace c10; }
-namespace at { using namespace c10; }
-namespace at { namespace cuda { using namespace c10::cuda; }}
+namespace caffe2 {
+using namespace c10;
+}
+namespace at {
+using namespace c10;
+}
+namespace at {
+namespace cuda {
+using namespace c10::cuda;
+}
+} // namespace at
 
 // WARNING!!! THIS IS A GIANT HACK!!!
 // This line means you cannot simultaneously include c10/hip
@@ -154,7 +166,11 @@ namespace at { namespace cuda { using namespace c10::cuda; }}
 // from at::cuda.  This namespace makes that happen.  When
 // HIPIFY is no longer out-of-place, we can switch the cuda
 // here to hip and everyone is happy.
-namespace at { namespace cuda { using namespace c10::hip; }}
+namespace at {
+namespace cuda {
+using namespace c10::hip;
+}
+} // namespace at
 
 // C10_LIKELY/C10_UNLIKELY
 //
@@ -169,11 +185,11 @@ namespace at { namespace cuda { using namespace c10::hip; }}
 // without it.
 //
 #if defined(__GNUC__) || defined(__ICL) || defined(__clang__)
-#define C10_LIKELY(expr)    (__builtin_expect(static_cast<bool>(expr), 1))
-#define C10_UNLIKELY(expr)  (__builtin_expect(static_cast<bool>(expr), 0))
+#define C10_LIKELY(expr) (__builtin_expect(static_cast<bool>(expr), 1))
+#define C10_UNLIKELY(expr) (__builtin_expect(static_cast<bool>(expr), 0))
 #else
-#define C10_LIKELY(expr)    (expr)
-#define C10_UNLIKELY(expr)  (expr)
+#define C10_LIKELY(expr) (expr)
+#define C10_UNLIKELY(expr) (expr)
 #endif
 
 /// C10_NOINLINE - Functions whose declaration is annotated with this will not
@@ -209,11 +225,13 @@ namespace at { namespace cuda { using namespace c10::hip; }}
 #define C10_HOST_DEVICE __host__ __device__
 #define C10_DEVICE __device__
 #define C10_HOST __host__
-// constants from (https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#features-and-technical-specifications)
-// The maximum number of threads per multiprocessor is 1024 for Turing architecture (7.5),
-// 1536 for Geforce Ampere (8.6),
-// and 2048 for all other architectures. You'll get warnings if you exceed these constants.
-// Hence, the following macros adjust the input values from the user to resolve potential warnings.
+// constants from
+// (https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#features-and-technical-specifications)
+// The maximum number of threads per multiprocessor is 1024 for Turing
+// architecture (7.5), 1536 for Geforce Ampere (8.6), and 2048 for all other
+// architectures. You'll get warnings if you exceed these constants. Hence, the
+// following macros adjust the input values from the user to resolve potential
+// warnings.
 #if __CUDA_ARCH__ == 750
 constexpr uint32_t CUDA_MAX_THREADS_PER_SM = 1024;
 #elif __CUDA_ARCH__ == 860
@@ -223,25 +241,39 @@ constexpr uint32_t CUDA_MAX_THREADS_PER_SM = 2048;
 #endif
 // CUDA_MAX_THREADS_PER_BLOCK is same for all architectures currently
 constexpr uint32_t CUDA_MAX_THREADS_PER_BLOCK = 1024;
-// CUDA_THREADS_PER_BLOCK_FALLBACK is the "canonical fallback" choice of block size.
-// 256 is a good number for this fallback and should give good occupancy and
-// versatility across all architectures.
+// CUDA_THREADS_PER_BLOCK_FALLBACK is the "canonical fallback" choice of block
+// size. 256 is a good number for this fallback and should give good occupancy
+// and versatility across all architectures.
 constexpr uint32_t CUDA_THREADS_PER_BLOCK_FALLBACK = 256;
 // NOTE: if you are thinking of constexpr-ify the inputs to launch bounds, it
 //       turns out that although __launch_bounds__ can take constexpr, it
 //       can't take a constexpr that has anything to do with templates.
 //       Currently we use launch_bounds that depend on template arguments in
-//       Loops.cuh, Reduce.cuh and LossCTC.cuh. Hence, C10_MAX_THREADS_PER_BLOCK and
-//       C10_MIN_BLOCKS_PER_SM are kept as macros.
-// Suppose you were planning to write __launch_bounds__(a, b), based on your performance tuning on a modern GPU.
-// Instead, you should write __launch_bounds__(C10_MAX_THREADS_PER_BLOCK(a), C10_MIN_BLOCKS_PER_SM(a, b)),
+//       Loops.cuh, Reduce.cuh and LossCTC.cuh. Hence, C10_MAX_THREADS_PER_BLOCK
+//       and C10_MIN_BLOCKS_PER_SM are kept as macros.
+// Suppose you were planning to write __launch_bounds__(a, b), based on your
+// performance tuning on a modern GPU. Instead, you should write
+// __launch_bounds__(C10_MAX_THREADS_PER_BLOCK(a), C10_MIN_BLOCKS_PER_SM(a, b)),
 // which will also properly respect limits on old architectures.
-#define C10_MAX_THREADS_PER_BLOCK(val) (((val) <= CUDA_MAX_THREADS_PER_BLOCK) ? (val) : CUDA_THREADS_PER_BLOCK_FALLBACK)
-#define C10_MIN_BLOCKS_PER_SM(threads_per_block, blocks_per_sm) ((((threads_per_block)*(blocks_per_sm) <= CUDA_MAX_THREADS_PER_SM) ? (blocks_per_sm) : ((CUDA_MAX_THREADS_PER_SM + (threads_per_block) - 1) / (threads_per_block))))
+#define C10_MAX_THREADS_PER_BLOCK(val)           \
+  (((val) <= CUDA_MAX_THREADS_PER_BLOCK) ? (val) \
+                                         : CUDA_THREADS_PER_BLOCK_FALLBACK)
+#define C10_MIN_BLOCKS_PER_SM(threads_per_block, blocks_per_sm)        \
+  ((((threads_per_block) * (blocks_per_sm) <= CUDA_MAX_THREADS_PER_SM) \
+        ? (blocks_per_sm)                                              \
+        : ((CUDA_MAX_THREADS_PER_SM + (threads_per_block)-1) /         \
+           (threads_per_block))))
 // C10_LAUNCH_BOUNDS is analogous to __launch_bounds__
-#define C10_LAUNCH_BOUNDS_0 __launch_bounds__(256, 4) // default launch bounds that should give good occupancy and versatility across all architectures.
-#define C10_LAUNCH_BOUNDS_1(max_threads_per_block) __launch_bounds__((C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))))
-#define C10_LAUNCH_BOUNDS_2(max_threads_per_block, min_blocks_per_sm) __launch_bounds__((C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))), (C10_MIN_BLOCKS_PER_SM((max_threads_per_block), (min_blocks_per_sm))))
+#define C10_LAUNCH_BOUNDS_0 \
+  __launch_bounds__(        \
+      256, 4) // default launch bounds that should give good occupancy and
+              // versatility across all architectures.
+#define C10_LAUNCH_BOUNDS_1(max_threads_per_block) \
+  __launch_bounds__((C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))))
+#define C10_LAUNCH_BOUNDS_2(max_threads_per_block, min_blocks_per_sm) \
+  __launch_bounds__(                                                  \
+      (C10_MAX_THREADS_PER_BLOCK((max_threads_per_block))),           \
+      (C10_MIN_BLOCKS_PER_SM((max_threads_per_block), (min_blocks_per_sm))))
 #else
 #define C10_HOST_DEVICE
 #define C10_HOST
@@ -273,14 +305,12 @@ constexpr uint32_t CUDA_THREADS_PER_BLOCK_FALLBACK = 256;
 #elif defined(_MSC_VER)
 #if defined(NDEBUG)
 extern "C" {
-  C10_IMPORT
+C10_IMPORT
 #if defined(__CUDA_ARCH__) || defined(__HIP_ARCH__) || defined(__HIP__)
-    __host__ __device__
+__host__ __device__
 #endif // __CUDA_ARCH__
- void _wassert(
-    wchar_t const* _Message,
-    wchar_t const* _File,
-    unsigned _Line);
+    void
+    _wassert(wchar_t const* _Message, wchar_t const* _File, unsigned _Line);
 }
 #endif
 #define CUDA_KERNEL_ASSERT(cond)                                                                 \
@@ -304,8 +334,8 @@ __host__ __device__
 #endif // NDEBUG
 #define CUDA_KERNEL_ASSERT(cond)                                         \
   if (C10_UNLIKELY(!(cond))) {                                           \
-    __assert_fail(#cond, __FILE__, static_cast<unsigned int>(__LINE__),  \
-                  __func__);                                             \
+    __assert_fail(                                                       \
+        #cond, __FILE__, static_cast<unsigned int>(__LINE__), __func__); \
   }
 #endif // __APPLE__
 
diff --git a/c10/mobile/CPUCachingAllocator.h b/c10/mobile/CPUCachingAllocator.h
index c80fee0682e..d5f4303e1b3 100644
--- a/c10/mobile/CPUCachingAllocator.h
+++ b/c10/mobile/CPUCachingAllocator.h
@@ -19,16 +19,15 @@
  *    See below for more information.
  * Why?
  *    It has been observed that some mobile platforms, such as pixel 3, return
- *    memory aggressively to the system. This results in page faults in some cases
- *    and ends up hurting performance. This caching allocator aims to address that.
- *    Furthermore it also allows users to specify their own allocator by implementing
- *    allocate/free virtual interfaces.
- * What are the cons?
- *    There are some cons that were observed where use of caching allocator led to
- *    worse performance on some platforms. Reason being that the caching mechanism
- *    used by this allocator left us worse off compared to the corresponding platform's
- *    tuned memory allocator. In that case it seemed better to not use this allocator.
- *    Note there are some ideas to fix this in the works.
+ *    memory aggressively to the system. This results in page faults in some
+ * cases and ends up hurting performance. This caching allocator aims to address
+ * that. Furthermore it also allows users to specify their own allocator by
+ * implementing allocate/free virtual interfaces. What are the cons? There are
+ * some cons that were observed where use of caching allocator led to worse
+ * performance on some platforms. Reason being that the caching mechanism used
+ * by this allocator left us worse off compared to the corresponding platform's
+ *    tuned memory allocator. In that case it seemed better to not use this
+ * allocator. Note there are some ideas to fix this in the works.
  *
  * Usage:
  * Usage pattern:
@@ -53,42 +52,44 @@ class C10_API CPUCachingAllocator {
    * What it does not do:
    * No speculative allocation for any future allocations.
    */
-  private:
-    inline void* allocate_and_cache(const size_t bytes);
-    void free_cached();
-  protected:
-    // Invariants.
-    // 1. If memory is ever allocated via this allocator then
-    //    the pointer will exist in allocation_map_, unless the allocator
-    //    returned the memory to OS via free_cached.
-    //  1.1. Therefore even when the said memory is "freed" via this
-    //       allocator (and thus cached), it will continue to stay
-    //       in allocation_map_. Furthermore it will also exist in
-    //       available_map_. Thus an allocated memory pointer can be in both
-    //       allocation_map_ and available_map_ simultaneously.
-    // 2. Memory pointer maybe removed from allocation_map_, when it
-    //    is freed outside of the scope of this allocator, but was allocated
-    //    by this allocator.
-    // 3. Available map only contains that memory which was allocated
-    //    by this allocator and subsequently freed by this allocator.
-    // As a result of above invariants, allocated memory ptr cannot be in
-    // available_map_ unless it is in allocation_map_ as well.
-    ska::flat_hash_map<size_t, c10::SmallVector<void*, 16>> available_map_;
-    static ska::flat_hash_map<void*, size_t> allocation_map_;
-    // Since allocation_map, which is a global instance, is mutated/read via
-    // all public APIs we need a global mutex.
-    static std::mutex mutex_;
-  public:
-    static void record_free(void* ptr);
-    virtual ~CPUCachingAllocator();
-    // Checks the cache to see if allocation of size bytes can be found.
-    // If so return cached memory, else
-    // allocates memory, records it for caching and returns.
-    virtual void* allocate(const size_t bytes);
-    // Checks if the memory being freed is was marked for allocation by
-    // an earlier call to allocate. If so cache the allocation.
-    // Otherwise free.
-    virtual void free(void* ptr);
+ private:
+  inline void* allocate_and_cache(const size_t bytes);
+  void free_cached();
+
+ protected:
+  // Invariants.
+  // 1. If memory is ever allocated via this allocator then
+  //    the pointer will exist in allocation_map_, unless the allocator
+  //    returned the memory to OS via free_cached.
+  //  1.1. Therefore even when the said memory is "freed" via this
+  //       allocator (and thus cached), it will continue to stay
+  //       in allocation_map_. Furthermore it will also exist in
+  //       available_map_. Thus an allocated memory pointer can be in both
+  //       allocation_map_ and available_map_ simultaneously.
+  // 2. Memory pointer maybe removed from allocation_map_, when it
+  //    is freed outside of the scope of this allocator, but was allocated
+  //    by this allocator.
+  // 3. Available map only contains that memory which was allocated
+  //    by this allocator and subsequently freed by this allocator.
+  // As a result of above invariants, allocated memory ptr cannot be in
+  // available_map_ unless it is in allocation_map_ as well.
+  ska::flat_hash_map<size_t, c10::SmallVector<void*, 16>> available_map_;
+  static ska::flat_hash_map<void*, size_t> allocation_map_;
+  // Since allocation_map, which is a global instance, is mutated/read via
+  // all public APIs we need a global mutex.
+  static std::mutex mutex_;
+
+ public:
+  static void record_free(void* ptr);
+  virtual ~CPUCachingAllocator();
+  // Checks the cache to see if allocation of size bytes can be found.
+  // If so return cached memory, else
+  // allocates memory, records it for caching and returns.
+  virtual void* allocate(const size_t bytes);
+  // Checks if the memory being freed is was marked for allocation by
+  // an earlier call to allocate. If so cache the allocation.
+  // Otherwise free.
+  virtual void free(void* ptr);
 };
 
 CPUCachingAllocator* GetDefaultCPUCachingAllocator();
@@ -97,11 +98,12 @@ bool ThreadLocalCachingAllocatorEnabled();
 CPUCachingAllocator* GetThreadLocalCachingAllocator();
 
 class C10_API WithCPUCachingAllocatorGuard {
-  public:
-    WithCPUCachingAllocatorGuard(CPUCachingAllocator* allocator);
-    ~WithCPUCachingAllocatorGuard();
-  private:
-    CPUCachingAllocator* prev_caching_allocator_ptr_{nullptr};
+ public:
+  WithCPUCachingAllocatorGuard(CPUCachingAllocator* allocator);
+  ~WithCPUCachingAllocatorGuard();
+
+ private:
+  CPUCachingAllocator* prev_caching_allocator_ptr_{nullptr};
 };
 
 } // namespace c10
diff --git a/c10/mobile/CPUProfilingAllocator.cpp b/c10/mobile/CPUProfilingAllocator.cpp
index 5e8eb7df85a..1fc53860f0d 100644
--- a/c10/mobile/CPUProfilingAllocator.cpp
+++ b/c10/mobile/CPUProfilingAllocator.cpp
@@ -19,27 +19,23 @@ struct MemBlock {
   }
 };
 
-enum class EventType {
-  Allocate = 0,
-  Free,
-  Invalid
-};
+enum class EventType { Allocate = 0, Free, Invalid };
 
 struct MemEvent {
   uint64_t time;
   uint64_t allocation_id;
   uint64_t size;
   EventType type{EventType::Invalid};
-  MemEvent(uint64_t t, uint64_t id, uint64_t s, EventType e) :
-    time(t), allocation_id(id), size(s), type(e) {}
+  MemEvent(uint64_t t, uint64_t id, uint64_t s, EventType e)
+      : time(t), allocation_id(id), size(s), type(e) {}
 };
 
 bool overlaps(const MemBlock& a, const MemBlock& b) {
   // two blocks dont overlap if
   // |---a--------|--------------b--------|
   // strat_a     end_a <= start_b       end_b
-  return
-    !((a.end_offset <= b.start_offset) || (b.end_offset <= a.start_offset));
+  return !(
+      (a.end_offset <= b.start_offset) || (b.end_offset <= a.start_offset));
 }
 
 bool validate_allocation_plan(
@@ -72,7 +68,8 @@ bool validate_allocation_plan(
       allocations.emplace(mem_block);
     } else if (event.type == EventType::Free) {
       auto it = allocations.find(mem_block);
-      TORCH_CHECK((*it).end_offset == end_offset,
+      TORCH_CHECK(
+          (*it).end_offset == end_offset,
           "Enf offset of allocation being freed must match the one recorded.");
       TORCH_CHECK(
           it != allocations.end(),
@@ -98,13 +95,15 @@ std::vector<MemEvent> create_and_sort_mem_events(
       continue;
     }
     events.emplace_back(i, i, allocation_sizes[i], EventType::Allocate);
-    events.emplace_back(allocation_lifetimes[i], i, allocation_sizes[i], EventType::Free);
+    events.emplace_back(
+        allocation_lifetimes[i], i, allocation_sizes[i], EventType::Free);
   }
   std::sort(
       events.begin(),
       events.end(),
-      [](const MemEvent& a,
-         const MemEvent& b) -> bool {return a.time < b.time;});
+      [](const MemEvent& a, const MemEvent& b) -> bool {
+        return a.time < b.time;
+      });
   return events;
 }
 
@@ -132,8 +131,10 @@ std::vector<uint64_t> formulate_greedy_allocation_plan(
   std::map<uint64_t, uint64_t> free_size_to_offset;
   // This provides fast lookup when we want to insert freed block
   // back, especially when we want to merge blocks.
-  ska::flat_hash_map<uint64_t, std::map<uint64_t, uint64_t>::iterator> free_start_offset_to_size_iter;
-  ska::flat_hash_map<uint64_t, std::map<uint64_t, uint64_t>::iterator> free_end_offset_to_size_iter;
+  ska::flat_hash_map<uint64_t, std::map<uint64_t, uint64_t>::iterator>
+      free_start_offset_to_size_iter;
+  ska::flat_hash_map<uint64_t, std::map<uint64_t, uint64_t>::iterator>
+      free_end_offset_to_size_iter;
   // Upon free end_ptr = offset + size
   // If end_ptr exists merge freed allocation
   // Also find corresponding offset in size_to_offset
@@ -146,7 +147,8 @@ std::vector<uint64_t> formulate_greedy_allocation_plan(
 
   std::vector<uint64_t> allocation_offsets(
       allocation_sizes.size(), std::numeric_limits<uint64_t>::max());
-  auto mem_events = create_and_sort_mem_events(allocation_sizes, allocation_lifetimes);
+  auto mem_events =
+      create_and_sort_mem_events(allocation_sizes, allocation_lifetimes);
   uint64_t max_offset{0};
   for (const auto& mem_event : mem_events) {
     // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -221,13 +223,14 @@ std::vector<uint64_t> formulate_greedy_allocation_plan(
         free_start_offset_to_size_iter.erase(freed_offset);
       }
       auto freed_block_it =
-        free_size_to_offset.emplace(freed_size, freed_offset).first;
+          free_size_to_offset.emplace(freed_size, freed_offset).first;
       free_start_offset_to_size_iter.emplace(freed_offset, freed_block_it);
       free_end_offset_to_size_iter.emplace(
           freed_offset + freed_size, freed_block_it);
     }
   }
-  TORCH_CHECK(validate_allocation_plan(mem_events, allocation_offsets),
+  TORCH_CHECK(
+      validate_allocation_plan(mem_events, allocation_offsets),
       "ProfilingAllocator: Allocation plan invalid.");
   return allocation_offsets;
 }
@@ -241,7 +244,8 @@ void AllocationPlan::clear() {
 }
 
 void AllocationPlanner::record_allocation(
-    const uint64_t size, const void* ptr) {
+    const uint64_t size,
+    const void* ptr) {
   if (validation_mode_) {
     validation_success = validation_success && validate_allocation(size, ptr);
     return;
@@ -264,13 +268,15 @@ void AllocationPlanner::record_free(const void* ptr) {
     return;
   }
   auto id = it->second;
-  TORCH_CHECK(id < allocation_plan_->allocation_lifetimes.size(),
+  TORCH_CHECK(
+      id < allocation_plan_->allocation_lifetimes.size(),
       "Allocation must have been recorded during record_allocation.");
   allocation_plan_->allocation_lifetimes[id] = allocation_id_;
 }
 
 bool AllocationPlanner::validate_allocation(
-    const uint64_t size, const void* ptr) {
+    const uint64_t size,
+    const void* ptr) {
   if (allocation_id_ >= allocation_plan_->allocation_sizes.size() ||
       allocation_plan_->allocation_sizes[allocation_id_] != size) {
     TORCH_WARN(
@@ -286,7 +292,7 @@ bool AllocationPlanner::validate_allocation(
 
     return false;
   }
-  allocation_ptr_to_id_[ptr] =  allocation_id_;
+  allocation_ptr_to_id_[ptr] = allocation_id_;
   allocation_id_++;
   return true;
 }
@@ -298,24 +304,27 @@ bool AllocationPlanner::validate_free(const void* ptr) {
     return true;
   }
   auto id = (*it).second;
-  TORCH_CHECK(id < allocation_plan_->allocation_lifetimes.size(),
+  TORCH_CHECK(
+      id < allocation_plan_->allocation_lifetimes.size(),
       "Allocation must have been recorded during validate_allocation.");
   auto lifetime_id = allocation_plan_->allocation_lifetimes[id];
   return (lifetime_id == allocation_id_);
 }
 
 void AllocationPlanner::formulate_plan() {
-  allocation_plan_->allocation_offsets =
-    formulate_greedy_allocation_plan(
-        allocation_plan_->allocation_sizes, allocation_plan_->allocation_lifetimes);
+  allocation_plan_->allocation_offsets = formulate_greedy_allocation_plan(
+      allocation_plan_->allocation_sizes,
+      allocation_plan_->allocation_lifetimes);
   allocation_plan_->total_size = 0;
   for (const auto i : c10::irange(allocation_plan_->allocation_sizes.size())) {
     if (allocation_plan_->allocation_lifetimes[i] ==
         std::numeric_limits<uint64_t>::max()) {
       continue;
     }
-    auto limit = allocation_plan_->allocation_offsets[i] + allocation_plan_->allocation_sizes[i];
-    allocation_plan_->total_size = std::max(allocation_plan_->total_size, limit);
+    auto limit = allocation_plan_->allocation_offsets[i] +
+        allocation_plan_->allocation_sizes[i];
+    allocation_plan_->total_size =
+        std::max(allocation_plan_->total_size, limit);
   }
 }
 
@@ -344,7 +353,8 @@ void CPUProfilingAllocator::unset_plan() {
 }
 
 void* CPUProfilingAllocator::allocate(const size_t bytes) {
-  TORCH_CHECK(bytes == plan_->allocation_sizes[allocation_id_],
+  TORCH_CHECK(
+      bytes == plan_->allocation_sizes[allocation_id_],
       "Got allocation request that does not match with the plan.");
   if (plan_->allocation_lifetimes[allocation_id_] ==
       std::numeric_limits<uint64_t>::max()) {
@@ -352,9 +362,8 @@ void* CPUProfilingAllocator::allocate(const size_t bytes) {
     allocation_id_++;
     return c10::alloc_cpu(bytes);
   }
-  void* ptr =
-    reinterpret_cast<uint8_t*>(blob_) +
-    plan_->allocation_offsets[allocation_id_];
+  void* ptr = reinterpret_cast<uint8_t*>(blob_) +
+      plan_->allocation_offsets[allocation_id_];
   allocation_ptr_to_id_[ptr] = allocation_id_;
   allocation_id_++;
   return ptr;
@@ -364,8 +373,8 @@ void CPUProfilingAllocator::free(void* const ptr) {
   auto it = allocation_ptr_to_id_.find(ptr);
   if (it == allocation_ptr_to_id_.end()) {
     // Either
-    // 1. Allocation that was made outside the validation scope is being freed here
-    // or
+    // 1. Allocation that was made outside the validation scope is being freed
+    // here or
     // 2. Allocation that is not managed by profiling allocator is being freed.
     //    Example of the second type
     //    Tensor out;
@@ -380,7 +389,8 @@ void CPUProfilingAllocator::free(void* const ptr) {
     return;
   }
   auto id = it->second;
-  TORCH_CHECK(id < plan_->allocation_lifetimes.size(),
+  TORCH_CHECK(
+      id < plan_->allocation_lifetimes.size(),
       "Freeing allocation that is not accordingly to the plan.");
   auto lifetime_id = plan_->allocation_lifetimes[id];
   TORCH_CHECK(
@@ -397,10 +407,10 @@ CPUProfilingAllocator::~CPUProfilingAllocator() {
   c10::free_cpu(blob_);
 }
 
-WithProfileAllocationsGuard::WithProfileAllocationsGuard(
-    AllocationPlan* plan) {
+WithProfileAllocationsGuard::WithProfileAllocationsGuard(AllocationPlan* plan) {
   // Nesting of allocation profiling does not seem meaningful.
-  TORCH_CHECK(allocation_planner == nullptr,
+  TORCH_CHECK(
+      allocation_planner == nullptr,
       "Nesting profiling allocations is not supported.");
   planner_ = std::make_unique<AllocationPlanner>(plan);
   planner_->clear();
@@ -413,9 +423,11 @@ WithProfileAllocationsGuard::~WithProfileAllocationsGuard() {
 }
 
 WithValidateAllocationPlanGuard::WithValidateAllocationPlanGuard(
-    AllocationPlan* plan, bool* success) {
+    AllocationPlan* plan,
+    bool* success) {
   // Nesting of allocation profiling does not seem meaningful.
-  TORCH_CHECK(allocation_planner == nullptr,
+  TORCH_CHECK(
+      allocation_planner == nullptr,
       "Nesting profiling allocations is not supported.");
   planner_ = std::make_unique<AllocationPlanner>(plan, true);
   success_ = success;
@@ -432,9 +444,11 @@ AllocationPlanner* GetThreadLocalAllocationPlanner() {
 }
 
 WithProfilingAllocatorGuard::WithProfilingAllocatorGuard(
-    CPUProfilingAllocator* allocator, const AllocationPlan* plan) {
+    CPUProfilingAllocator* allocator,
+    const AllocationPlan* plan) {
   // Nesting of profiling allocator is not supported.
-  TORCH_CHECK(profiling_allocator == nullptr,
+  TORCH_CHECK(
+      profiling_allocator == nullptr,
       "Nesting profiling allocators is not supported.");
   profiling_allocator = allocator;
   profiling_allocator->set_plan(plan);
diff --git a/c10/mobile/CPUProfilingAllocator.h b/c10/mobile/CPUProfilingAllocator.h
index 4a7e79fe285..5112691a62d 100644
--- a/c10/mobile/CPUProfilingAllocator.h
+++ b/c10/mobile/CPUProfilingAllocator.h
@@ -16,29 +16,30 @@ namespace c10 {
  * Given a sequence of allocations in a thread, AllocationPlan records
  * 1. size of each allocation
  * 2. Lifetime of each allocation.
- * 3. allocation offsets: Memory offset for each allocation in a single blob of memory
+ * 3. allocation offsets: Memory offset for each allocation in a single blob of
+ * memory
  * 4. Total size of a blob of memory required to satisfy all the allocations.
  */
 class C10_API AllocationPlan {
-  private:
-    // Records size of each allocation by their sequential allocation ids.
-    std::vector<uint64_t> allocation_sizes;
-    // This maps one allocation id (X) to another allocation id (Y).
-    // Allocation X is alive until allocation Y. From allocation Y onwards
-    // allocation X is not referenced.
-    // Thus Y is the id of the first allocation after X is freed.
-    // NB: When an allocation is recorded, along with recording its size,
-    // we also set the lifetime to be numeric_limits::max()
-    // This is to track allocations that are made during the scope of
-    // profiling but were not freed until after the scope ended.
-    // Such allocations are not managed by profiling allocator.
-    std::vector<uint64_t> allocation_lifetimes;
-    // Maps an allocation to some offset in a blob of memory.
-    std::vector<uint64_t> allocation_offsets;
-    uint64_t total_size{0};
-    void clear();
-    friend class AllocationPlanner;
-    friend class CPUProfilingAllocator;
+ private:
+  // Records size of each allocation by their sequential allocation ids.
+  std::vector<uint64_t> allocation_sizes;
+  // This maps one allocation id (X) to another allocation id (Y).
+  // Allocation X is alive until allocation Y. From allocation Y onwards
+  // allocation X is not referenced.
+  // Thus Y is the id of the first allocation after X is freed.
+  // NB: When an allocation is recorded, along with recording its size,
+  // we also set the lifetime to be numeric_limits::max()
+  // This is to track allocations that are made during the scope of
+  // profiling but were not freed until after the scope ended.
+  // Such allocations are not managed by profiling allocator.
+  std::vector<uint64_t> allocation_lifetimes;
+  // Maps an allocation to some offset in a blob of memory.
+  std::vector<uint64_t> allocation_offsets;
+  uint64_t total_size{0};
+  void clear();
+  friend class AllocationPlanner;
+  friend class CPUProfilingAllocator;
 };
 
 /*
@@ -46,43 +47,45 @@ class C10_API AllocationPlan {
  * used to establish lifetime of allocations.
  */
 class C10_API AllocationPlanner {
-  private:
-    AllocationPlan* allocation_plan_{nullptr};
-    // Maps allocated ptr to its allocation id.
-    // This is used when freeing the memory to lookup the allocation id
-    // in order to establish the lifetime of a particular allocation.
-    ska::flat_hash_map<const void*, uint64_t> allocation_ptr_to_id_;
-    uint64_t allocation_id_{0};
-    bool validation_mode_{false};
+ private:
+  AllocationPlan* allocation_plan_{nullptr};
+  // Maps allocated ptr to its allocation id.
+  // This is used when freeing the memory to lookup the allocation id
+  // in order to establish the lifetime of a particular allocation.
+  ska::flat_hash_map<const void*, uint64_t> allocation_ptr_to_id_;
+  uint64_t allocation_id_{0};
+  bool validation_mode_{false};
 
-    bool validate_allocation(const uint64_t size, const void* ptr);
-    bool validate_free(const void* ptr);
-  public:
-    bool validation_success{true};
+  bool validate_allocation(const uint64_t size, const void* ptr);
+  bool validate_free(const void* ptr);
 
-    AllocationPlanner() = delete;
-    AllocationPlanner(AllocationPlan* plan, bool validate = false) :
-      allocation_plan_(plan), validation_mode_(validate) {}
-    void record_allocation(const uint64_t size, const void* ptr);
-    void record_free(const void* ptr);
-    void formulate_plan();
-    void clear();
+ public:
+  bool validation_success{true};
+
+  AllocationPlanner() = delete;
+  AllocationPlanner(AllocationPlan* plan, bool validate = false)
+      : allocation_plan_(plan), validation_mode_(validate) {}
+  void record_allocation(const uint64_t size, const void* ptr);
+  void record_free(const void* ptr);
+  void formulate_plan();
+  void clear();
 };
 
 // NOT THREAD SAFE profiling allocator.
 class C10_API CPUProfilingAllocator {
-  private:
-    const AllocationPlan* plan_{nullptr};
-    uint64_t allocation_id_{0};
-    uint64_t current_size_{0};
-    void* blob_{nullptr};
-    ska::flat_hash_map<const void*, uint64_t> allocation_ptr_to_id_;
-  public:
-    ~CPUProfilingAllocator();
-    void set_plan(const AllocationPlan* plan);
-    void unset_plan();
-    void* allocate(const size_t bytes);
-    void free(void* const ptr);
+ private:
+  const AllocationPlan* plan_{nullptr};
+  uint64_t allocation_id_{0};
+  uint64_t current_size_{0};
+  void* blob_{nullptr};
+  ska::flat_hash_map<const void*, uint64_t> allocation_ptr_to_id_;
+
+ public:
+  ~CPUProfilingAllocator();
+  void set_plan(const AllocationPlan* plan);
+  void unset_plan();
+  void* allocate(const size_t bytes);
+  void free(void* const ptr);
 };
 
 /*
@@ -95,11 +98,12 @@ class C10_API CPUProfilingAllocator {
  * plan now contains allocation plan.
  */
 class C10_API WithProfileAllocationsGuard {
-  public:
-    WithProfileAllocationsGuard(AllocationPlan* plan);
-    ~WithProfileAllocationsGuard();
-  private:
-    std::unique_ptr<AllocationPlanner> planner_;
+ public:
+  WithProfileAllocationsGuard(AllocationPlan* plan);
+  ~WithProfileAllocationsGuard();
+
+ private:
+  std::unique_ptr<AllocationPlanner> planner_;
 };
 
 /*
@@ -115,12 +119,13 @@ class C10_API WithProfileAllocationsGuard {
  * else for some inputs allocation pattern changed.
  */
 class C10_API WithValidateAllocationPlanGuard {
-  public:
-    WithValidateAllocationPlanGuard(AllocationPlan* plan, bool* success);
-    ~WithValidateAllocationPlanGuard();
-  private:
-    std::unique_ptr<AllocationPlanner> planner_;
-    bool* success_;
+ public:
+  WithValidateAllocationPlanGuard(AllocationPlan* plan, bool* success);
+  ~WithValidateAllocationPlanGuard();
+
+ private:
+  std::unique_ptr<AllocationPlanner> planner_;
+  bool* success_;
 };
 
 AllocationPlanner* GetThreadLocalAllocationPlanner();
@@ -138,10 +143,11 @@ AllocationPlanner* GetThreadLocalAllocationPlanner();
  * }
  */
 class C10_API WithProfilingAllocatorGuard {
-  public:
-    WithProfilingAllocatorGuard(
-        CPUProfilingAllocator* allocator, const AllocationPlan* plan);
-    ~WithProfilingAllocatorGuard();
+ public:
+  WithProfilingAllocatorGuard(
+      CPUProfilingAllocator* allocator,
+      const AllocationPlan* plan);
+  ~WithProfilingAllocatorGuard();
 };
 
 CPUProfilingAllocator* GetThreadLocalProfilingAllocator();
diff --git a/c10/test/core/CompileTimeFunctionPointer_test.cpp b/c10/test/core/CompileTimeFunctionPointer_test.cpp
index 64de518cc4f..3caf8cc4915 100644
--- a/c10/test/core/CompileTimeFunctionPointer_test.cpp
+++ b/c10/test/core/CompileTimeFunctionPointer_test.cpp
@@ -5,63 +5,71 @@ namespace test_is_compile_time_function_pointer {
 static_assert(!c10::is_compile_time_function_pointer<void()>::value, "");
 
 void dummy() {}
-static_assert(c10::is_compile_time_function_pointer<TORCH_FN_TYPE(dummy)>::value, "");
-}
+static_assert(
+    c10::is_compile_time_function_pointer<TORCH_FN_TYPE(dummy)>::value,
+    "");
+} // namespace test_is_compile_time_function_pointer
 
 namespace test_access_through_type {
-    void dummy() {}
-    using dummy_ptr = TORCH_FN_TYPE(dummy);
-    static_assert(c10::is_compile_time_function_pointer<dummy_ptr>::value, "");
-    static_assert(dummy_ptr::func_ptr() == &dummy, "");
-    static_assert(std::is_same<void(), dummy_ptr::FuncType>::value, "");
-}
+void dummy() {}
+using dummy_ptr = TORCH_FN_TYPE(dummy);
+static_assert(c10::is_compile_time_function_pointer<dummy_ptr>::value, "");
+static_assert(dummy_ptr::func_ptr() == &dummy, "");
+static_assert(std::is_same<void(), dummy_ptr::FuncType>::value, "");
+} // namespace test_access_through_type
 
 namespace test_access_through_value {
-    void dummy() {}
-    constexpr auto dummy_ptr = TORCH_FN(dummy);
-    static_assert(dummy_ptr.func_ptr() == &dummy, "");
-    static_assert(std::is_same<void(), decltype(dummy_ptr)::FuncType>::value, "");
-}
+void dummy() {}
+constexpr auto dummy_ptr = TORCH_FN(dummy);
+static_assert(dummy_ptr.func_ptr() == &dummy, "");
+static_assert(std::is_same<void(), decltype(dummy_ptr)::FuncType>::value, "");
+} // namespace test_access_through_value
 
 namespace test_access_through_type_also_works_if_specified_as_pointer {
-    void dummy() {}
-    using dummy_ptr = TORCH_FN_TYPE(&dummy);
-    static_assert(c10::is_compile_time_function_pointer<dummy_ptr>::value, "");
-    static_assert(dummy_ptr::func_ptr() == &dummy, "");
-    static_assert(std::is_same<void(), dummy_ptr::FuncType>::value, "");
-}
+void dummy() {}
+using dummy_ptr = TORCH_FN_TYPE(&dummy);
+static_assert(c10::is_compile_time_function_pointer<dummy_ptr>::value, "");
+static_assert(dummy_ptr::func_ptr() == &dummy, "");
+static_assert(std::is_same<void(), dummy_ptr::FuncType>::value, "");
+} // namespace test_access_through_type_also_works_if_specified_as_pointer
 
 namespace test_access_through_value_also_works_if_specified_as_pointer {
-    void dummy() {}
-    constexpr auto dummy_ptr = TORCH_FN(&dummy);
-    static_assert(dummy_ptr.func_ptr() == &dummy, "");
-    static_assert(std::is_same<void(), decltype(dummy_ptr)::FuncType>::value, "");
-}
+void dummy() {}
+constexpr auto dummy_ptr = TORCH_FN(&dummy);
+static_assert(dummy_ptr.func_ptr() == &dummy, "");
+static_assert(std::is_same<void(), decltype(dummy_ptr)::FuncType>::value, "");
+} // namespace test_access_through_value_also_works_if_specified_as_pointer
 
 namespace test_run_through_type {
-    int add(int a, int b) {return a + b;}
-    using Add = TORCH_FN_TYPE(add);
-    template<class Func> struct Executor {
-        int execute(int a, int b) {
-            return Func::func_ptr()(a, b);
-        }
-    };
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(CompileTimeFunctionPointerTest, runFunctionThroughType) {
-        Executor<Add> executor;
-        EXPECT_EQ(3, executor.execute(1, 2));
-    }
+int add(int a, int b) {
+  return a + b;
 }
+using Add = TORCH_FN_TYPE(add);
+template <class Func>
+struct Executor {
+  int execute(int a, int b) {
+    return Func::func_ptr()(a, b);
+  }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(CompileTimeFunctionPointerTest, runFunctionThroughType) {
+  Executor<Add> executor;
+  EXPECT_EQ(3, executor.execute(1, 2));
+}
+} // namespace test_run_through_type
 
 namespace test_run_through_value {
-    int add(int a, int b) {return a + b;}
-    template<class Func> int execute(Func, int a, int b) {
-        return Func::func_ptr()(a, b);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(CompileTimeFunctionPointerTest, runFunctionThroughValue) {
-        EXPECT_EQ(3, execute(TORCH_FN(add), 1, 2));
-    }
+int add(int a, int b) {
+  return a + b;
 }
+template <class Func>
+int execute(Func, int a, int b) {
+  return Func::func_ptr()(a, b);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(CompileTimeFunctionPointerTest, runFunctionThroughValue) {
+  EXPECT_EQ(3, execute(TORCH_FN(add), 1, 2));
+}
+} // namespace test_run_through_value
diff --git a/c10/test/core/DispatchKeySet_test.cpp b/c10/test/core/DispatchKeySet_test.cpp
index 1d931df033c..57f4f596b1e 100644
--- a/c10/test/core/DispatchKeySet_test.cpp
+++ b/c10/test/core/DispatchKeySet_test.cpp
@@ -9,7 +9,8 @@ using namespace c10;
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(DispatchKeySet, Empty) {
   DispatchKeySet empty_set;
-  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys); i++) {
+  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
+       i++) {
     auto tid = static_cast<DispatchKey>(i);
     ASSERT_FALSE(empty_set.has(tid));
   }
@@ -21,7 +22,8 @@ TEST(DispatchKeySet, Empty) {
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(DispatchKeySet, Singleton) {
-  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys); i++) {
+  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
+       i++) {
     auto tid = static_cast<DispatchKey>(i);
     DispatchKeySet sing(tid);
     ASSERT_EQ(sing, sing);
@@ -37,8 +39,11 @@ TEST(DispatchKeySet, Singleton) {
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(DispatchKeySet, Doubleton) {
-  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys); i++) {
-    for (uint8_t j = i + 1; j < static_cast<uint8_t>(DispatchKey::NumDispatchKeys); j++) {
+  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
+       i++) {
+    for (uint8_t j = i + 1;
+         j < static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
+         j++) {
       ASSERT_LT(i, j);
       auto tid1 = static_cast<DispatchKey>(i);
       auto tid2 = static_cast<DispatchKey>(j);
@@ -46,7 +51,7 @@ TEST(DispatchKeySet, Doubleton) {
       ASSERT_EQ(doub, DispatchKeySet(tid1) | DispatchKeySet(tid2));
       ASSERT_TRUE(doub.has(tid1));
       ASSERT_TRUE(doub.has(tid2));
-      ASSERT_EQ(doub.highestPriorityTypeId(), tid2);  // relies on i < j
+      ASSERT_EQ(doub.highestPriorityTypeId(), tid2); // relies on i < j
     }
   }
 }
@@ -54,7 +59,8 @@ TEST(DispatchKeySet, Doubleton) {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(DispatchKeySet, Full) {
   DispatchKeySet full(DispatchKeySet::FULL);
-  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys); i++) {
+  for (uint8_t i = 1; i < static_cast<uint8_t>(DispatchKey::NumDispatchKeys);
+       i++) {
     auto tid = static_cast<DispatchKey>(i);
     ASSERT_TRUE(full.has(tid));
   }
@@ -103,13 +109,12 @@ TEST(DispatchKeySet, IteratorFull) {
   ASSERT_EQ(i, static_cast<uint8_t>(DispatchKey::NumDispatchKeys) - 1);
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(DispatchKeySet, IteratorRangeFull) {
   DispatchKeySet full_set(DispatchKeySet::FULL);
   uint8_t i = 0;
 
-  for (DispatchKey dispatch_key: full_set) {
+  for (DispatchKey dispatch_key : full_set) {
     i++;
     ASSERT_TRUE(dispatch_key == static_cast<DispatchKey>(i));
   }
@@ -126,17 +131,20 @@ TEST(DispatchKeySet, SpecificKeys) {
       static_cast<DispatchKey>(10),
       // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
       static_cast<DispatchKey>(15),
-    });
+  });
   std::unordered_set<DispatchKey> visited_keys;
 
-  for(DispatchKey key: keyset) {
+  for (DispatchKey key : keyset) {
     visited_keys.insert(key);
   }
 
   ASSERT_EQ(visited_keys.size(), 3);
-  ASSERT_TRUE(visited_keys.find(static_cast<DispatchKey>(4)) != visited_keys.end());
-  ASSERT_TRUE(visited_keys.find(static_cast<DispatchKey>(10)) != visited_keys.end());
-  ASSERT_TRUE(visited_keys.find(static_cast<DispatchKey>(15)) != visited_keys.end());
+  ASSERT_TRUE(
+      visited_keys.find(static_cast<DispatchKey>(4)) != visited_keys.end());
+  ASSERT_TRUE(
+      visited_keys.find(static_cast<DispatchKey>(10)) != visited_keys.end());
+  ASSERT_TRUE(
+      visited_keys.find(static_cast<DispatchKey>(15)) != visited_keys.end());
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -145,9 +153,8 @@ TEST(DispatchKeySet, FailAtEndIterator) {
   uint64_t raw_repr = full_set.raw_repr();
 
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-  EXPECT_THROW(DispatchKeySet::iterator(
-                   &raw_repr,
-                   static_cast<uint8_t>(DispatchKey::NumDispatchKeys) + 1
-               ),
-               c10::Error);
+  EXPECT_THROW(
+      DispatchKeySet::iterator(
+          &raw_repr, static_cast<uint8_t>(DispatchKey::NumDispatchKeys) + 1),
+      c10::Error);
 }
diff --git a/c10/test/core/impl/InlineDeviceGuard_test.cpp b/c10/test/core/impl/InlineDeviceGuard_test.cpp
index f74648bc359..f0b88acc5f2 100644
--- a/c10/test/core/impl/InlineDeviceGuard_test.cpp
+++ b/c10/test/core/impl/InlineDeviceGuard_test.cpp
@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
-#include <c10/core/impl/InlineDeviceGuard.h>
 #include <c10/core/impl/FakeGuardImpl.h>
+#include <c10/core/impl/InlineDeviceGuard.h>
 
 using namespace c10;
 using namespace c10::impl;
@@ -55,8 +55,8 @@ TEST(InlineDeviceGuard, Constructor) {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(InlineDeviceGuard, ConstructorError) {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-  EXPECT_ANY_THROW(InlineDeviceGuard<FakeGuardImpl<DeviceType::CUDA>>
-                   g(Device(DeviceType::HIP, 1)));
+  EXPECT_ANY_THROW(InlineDeviceGuard<FakeGuardImpl<DeviceType::CUDA>> g(
+      Device(DeviceType::HIP, 1)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -110,7 +110,8 @@ TEST(InlineDeviceGuard, SetIndex) {
   ASSERT_EQ(TestGuardImpl::getDeviceIndex(), i2);
 }
 
-// -- InlineOptionalDeviceGuard --------------------------------------------------
+// -- InlineOptionalDeviceGuard
+// --------------------------------------------------
 
 using MaybeTestGuard = InlineOptionalDeviceGuard<TestGuardImpl>;
 
diff --git a/c10/test/core/impl/InlineStreamGuard_test.cpp b/c10/test/core/impl/InlineStreamGuard_test.cpp
index d3f8def9a5c..ef811b7e4ac 100644
--- a/c10/test/core/impl/InlineStreamGuard_test.cpp
+++ b/c10/test/core/impl/InlineStreamGuard_test.cpp
@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
-#include <c10/core/impl/InlineStreamGuard.h>
 #include <c10/core/impl/FakeGuardImpl.h>
+#include <c10/core/impl/InlineStreamGuard.h>
 
 using namespace c10;
 using namespace c10::impl;
@@ -40,7 +40,6 @@ TEST(InlineStreamGuard, Constructor) {
   ASSERT_EQ(TestGuardImpl::getCurrentStreamIdFor(0), 0);
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(InlineStreamGuard, ResetStreamSameSameDevice) {
   TestGuardImpl::setDeviceIndex(0);
@@ -101,7 +100,8 @@ TEST(InlineStreamGuard, ResetStreamDifferentDevice) {
   ASSERT_EQ(TestGuardImpl::getCurrentStreamIdFor(0), 0);
 }
 
-// -- OptionalInlineStreamGuard -------------------------------------------------------
+// -- OptionalInlineStreamGuard
+// -------------------------------------------------------
 
 using OptionalTestGuard = InlineOptionalStreamGuard<TestGuardImpl>;
 
@@ -180,7 +180,8 @@ TEST(InlineOptionalStreamGuard, ResetStreamDifferentDevice) {
   ASSERT_EQ(TestGuardImpl::getCurrentStreamIdFor(0), 0);
 }
 
-// -- InlineMultiStreamGuard -------------------------------------------------------
+// -- InlineMultiStreamGuard
+// -------------------------------------------------------
 
 using MultiTestGuard = InlineMultiStreamGuard<TestGuardImpl>;
 
diff --git a/c10/test/core/impl/SizesAndStrides_test.cpp b/c10/test/core/impl/SizesAndStrides_test.cpp
index 744c83da76f..4df51271883 100644
--- a/c10/test/core/impl/SizesAndStrides_test.cpp
+++ b/c10/test/core/impl/SizesAndStrides_test.cpp
@@ -6,12 +6,16 @@
 using namespace c10;
 using namespace c10::impl;
 
-static void checkData(const SizesAndStrides& sz, IntArrayRef sizes, IntArrayRef strides) {
-  EXPECT_EQ(sizes.size(), strides.size()) << "bad test case: size() of sizes and strides don't match";
+static void checkData(
+    const SizesAndStrides& sz,
+    IntArrayRef sizes,
+    IntArrayRef strides) {
+  EXPECT_EQ(sizes.size(), strides.size())
+      << "bad test case: size() of sizes and strides don't match";
   EXPECT_EQ(sz.size(), sizes.size());
 
   int idx = 0;
-  for (auto x: sizes) {
+  for (auto x : sizes) {
     EXPECT_EQ(sz.size_at_unchecked(idx), x) << "index: " << idx;
     EXPECT_EQ(sz.size_at(idx), x) << "index: " << idx;
     EXPECT_EQ(sz.sizes_data()[idx], x) << "index: " << idx;
@@ -21,7 +25,7 @@ static void checkData(const SizesAndStrides& sz, IntArrayRef sizes, IntArrayRef
   EXPECT_EQ(sz.sizes_arrayref(), sizes);
 
   idx = 0;
-  for (auto x: strides) {
+  for (auto x : strides) {
     EXPECT_EQ(sz.stride_at_unchecked(idx), x) << "index: " << idx;
     EXPECT_EQ(sz.stride_at(idx), x) << "index: " << idx;
     EXPECT_EQ(sz.strides_data()[idx], x) << "index: " << idx;
diff --git a/c10/test/util/Array_test.cpp b/c10/test/util/Array_test.cpp
index 8f7365fe0d7..be265132d43 100644
--- a/c10/test/util/Array_test.cpp
+++ b/c10/test/util/Array_test.cpp
@@ -6,90 +6,92 @@ using c10::guts::to_array;
 
 namespace {
 namespace test_equals {
-  static_assert(array<int, 0>{{}} == array<int, 0>{{}}, "");
-  static_assert(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 3, 4}}, "");
-  static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{1, 3, 4}}), "");
-  static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 1, 4}}), "");
-  static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 3, 1}}), "");
-}
+static_assert(array<int, 0>{{}} == array<int, 0>{{}}, "");
+static_assert(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 3, 4}}, "");
+static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{1, 3, 4}}), "");
+static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 1, 4}}), "");
+static_assert(!(array<int, 3>{{2, 3, 4}} == array<int, 3>{{2, 3, 1}}), "");
+} // namespace test_equals
 
 namespace test_notequals {
-  static_assert(!(array<int, 0>{{}} != array<int, 0>{{}}), "");
-  static_assert(!(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 3, 4}}), "");
-  static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{1, 3, 4}}, "");
-  static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 1, 4}}, "");
-  static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 3, 1}}, "");
-}
+static_assert(!(array<int, 0>{{}} != array<int, 0>{{}}), "");
+static_assert(!(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 3, 4}}), "");
+static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{1, 3, 4}}, "");
+static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 1, 4}}, "");
+static_assert(array<int, 3>{{2, 3, 4}} != array<int, 3>{{2, 3, 1}}, "");
+} // namespace test_notequals
 
 namespace test_lessthan {
-  static_assert(!(array<int, 0>{{}} < array<int, 0>{{}}), "");
-  static_assert(!(array<int, 1>{{2}} < array<int, 1>{{1}}), "");
-  static_assert(array<int, 1>{{1}} < array<int, 1>{{2}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{2, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{0, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 3, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 1, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 4}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 2}}), "");
-}
+static_assert(!(array<int, 0>{{}} < array<int, 0>{{}}), "");
+static_assert(!(array<int, 1>{{2}} < array<int, 1>{{1}}), "");
+static_assert(array<int, 1>{{1}} < array<int, 1>{{2}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{2, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{0, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 3, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 1, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 4}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} < array<int, 3>{{1, 2, 2}}), "");
+} // namespace test_lessthan
 
 namespace test_greaterthan {
-  static_assert(!(array<int, 0>{{}} > array<int, 0>{{}}), "");
-  static_assert(!(array<int, 1>{{1}} > array<int, 1>{{2}}), "");
-  static_assert(array<int, 1>{{2}} > array<int, 1>{{1}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} > array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{2, 2, 3}} > array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{0, 2, 3}} > array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 3, 3}} > array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 1, 3}} > array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 4}} > array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 2}} > array<int, 3>{{1, 2, 3}}), "");
-}
+static_assert(!(array<int, 0>{{}} > array<int, 0>{{}}), "");
+static_assert(!(array<int, 1>{{1}} > array<int, 1>{{2}}), "");
+static_assert(array<int, 1>{{2}} > array<int, 1>{{1}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} > array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{2, 2, 3}} > array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{0, 2, 3}} > array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 3, 3}} > array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 1, 3}} > array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 4}} > array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 2}} > array<int, 3>{{1, 2, 3}}), "");
+} // namespace test_greaterthan
 
 namespace test_lessequals {
-  static_assert(array<int, 0>{{}} <= array<int, 0>{{}}, "");
-  static_assert(!(array<int, 1>{{2}} <= array<int, 1>{{1}}), "");
-  static_assert(array<int, 1>{{1}} <= array<int, 1>{{2}}, "");
-  static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 3}}, "");
-  static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{2, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{0, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 3, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 1, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 4}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 2}}), "");
-}
+static_assert(array<int, 0>{{}} <= array<int, 0>{{}}, "");
+static_assert(!(array<int, 1>{{2}} <= array<int, 1>{{1}}), "");
+static_assert(array<int, 1>{{1}} <= array<int, 1>{{2}}, "");
+static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 3}}, "");
+static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{2, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{0, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 3, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 1, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 4}}, "");
+static_assert(!(array<int, 3>{{1, 2, 3}} <= array<int, 3>{{1, 2, 2}}), "");
+} // namespace test_lessequals
 
 namespace test_greaterequals {
-  static_assert(array<int, 0>{{}} >= array<int, 0>{{}}, "");
-  static_assert(!(array<int, 1>{{1}} >= array<int, 1>{{2}}), "");
-  static_assert(array<int, 1>{{2}} >= array<int, 1>{{1}}, "");
-  static_assert(array<int, 3>{{1, 2, 3}} >= array<int, 3>{{1, 2, 3}}, "");
-  static_assert(array<int, 3>{{2, 2, 3}} >= array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{0, 2, 3}} >= array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 3, 3}} >= array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 1, 3}} >= array<int, 3>{{1, 2, 3}}), "");
-  static_assert(array<int, 3>{{1, 2, 4}} >= array<int, 3>{{1, 2, 3}}, "");
-  static_assert(!(array<int, 3>{{1, 2, 2}} >= array<int, 3>{{1, 2, 3}}), "");
-}
+static_assert(array<int, 0>{{}} >= array<int, 0>{{}}, "");
+static_assert(!(array<int, 1>{{1}} >= array<int, 1>{{2}}), "");
+static_assert(array<int, 1>{{2}} >= array<int, 1>{{1}}, "");
+static_assert(array<int, 3>{{1, 2, 3}} >= array<int, 3>{{1, 2, 3}}, "");
+static_assert(array<int, 3>{{2, 2, 3}} >= array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{0, 2, 3}} >= array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 3, 3}} >= array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 1, 3}} >= array<int, 3>{{1, 2, 3}}), "");
+static_assert(array<int, 3>{{1, 2, 4}} >= array<int, 3>{{1, 2, 3}}, "");
+static_assert(!(array<int, 3>{{1, 2, 2}} >= array<int, 3>{{1, 2, 3}}), "");
+} // namespace test_greaterequals
 
 namespace test_tail {
-    static_assert(array < int, 2 > {{3, 4}} == tail(array < int, 3 > {{2, 3, 4}}), "");
-    static_assert(array < int, 0 > {{}} == tail(array < int, 1 > {{3}}), "");
-}
+static_assert(array<int, 2>{{3, 4}} == tail(array<int, 3>{{2, 3, 4}}), "");
+static_assert(array<int, 0>{{}} == tail(array<int, 1>{{3}}), "");
+} // namespace test_tail
 
 namespace test_prepend {
-    static_assert(array < int, 3 > {{2, 3, 4}} == prepend(2, array < int, 2 > {{3, 4}}), "");
-    static_assert(array < int, 1 > {{3}} == prepend(3, array < int, 0 > {{}}), "");
-}
+static_assert(
+    array<int, 3>{{2, 3, 4}} == prepend(2, array<int, 2>{{3, 4}}),
+    "");
+static_assert(array<int, 1>{{3}} == prepend(3, array<int, 0>{{}}), "");
+} // namespace test_prepend
 
 namespace test_to_std_array {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
-    constexpr int obj2[3] = {3, 5, 6};
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    static_assert(array < int, 3 > {{3, 5, 6}} == to_array(obj2), "");
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    static_assert(array < int, 3 > {{3, 5, 6}} == to_array<int, 3>({3, 5, 6}), "");
-}
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
+constexpr int obj2[3] = {3, 5, 6};
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+static_assert(array<int, 3>{{3, 5, 6}} == to_array(obj2), "");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+static_assert(array<int, 3>{{3, 5, 6}} == to_array<int, 3>({3, 5, 6}), "");
+} // namespace test_to_std_array
 
-}
+} // namespace
diff --git a/c10/test/util/C++17_test.cpp b/c10/test/util/C++17_test.cpp
index 5f6cde46e9a..5a10d12f56c 100644
--- a/c10/test/util/C++17_test.cpp
+++ b/c10/test/util/C++17_test.cpp
@@ -12,7 +12,7 @@ static_assert(min(5, 3) == 3, "");
 static_assert(min(3, 3) == 3, "");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
 static_assert(min(3.0, 3.1) == 3.0, "");
-}
+} // namespace test_min
 
 namespace test_max {
 using c10::guts::max;
@@ -23,7 +23,7 @@ static_assert(max(5, 3) == 5, "");
 static_assert(max(3, 3) == 3, "");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
 static_assert(max(3.0, 3.1) == 3.1, "");
-}
+} // namespace test_max
 
 namespace test_if_constexpr {
 
@@ -31,129 +31,125 @@ using c10::guts::if_constexpr;
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, whenIsTrue_thenReturnsTrueCase) {
-    EXPECT_EQ(4, if_constexpr<true>([](auto) { return 4; }, [](auto) { return 5; }));
+  EXPECT_EQ(
+      4, if_constexpr<true>([](auto) { return 4; }, [](auto) { return 5; }));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, whenIsFalse_thenReturnsFalseCase) {
-    EXPECT_EQ(5, if_constexpr<false>([](auto) { return 4; }, [](auto) { return 5; }));
+  EXPECT_EQ(
+      5, if_constexpr<false>([](auto) { return 4; }, [](auto) { return 5; }));
 }
 
 struct MovableOnly final {
-    int value;
+  int value;
 
-    MovableOnly(int v) : value(v) {}
-    MovableOnly(MovableOnly&&) = default;
-    MovableOnly(const MovableOnly&) = delete;
-    MovableOnly& operator=(MovableOnly&&) = default;
-    MovableOnly& operator=(const MovableOnly&) = delete;
+  MovableOnly(int v) : value(v) {}
+  MovableOnly(MovableOnly&&) = default;
+  MovableOnly(const MovableOnly&) = delete;
+  MovableOnly& operator=(MovableOnly&&) = default;
+  MovableOnly& operator=(const MovableOnly&) = delete;
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, worksWithMovableOnlyTypes_withIdentityArg) {
-    EXPECT_EQ(
-        4,
-        if_constexpr<true>([](auto) { return MovableOnly(4); }, [](auto) { return MovableOnly(5); })
-            .value);
-    EXPECT_EQ(
-        5,
-        if_constexpr<false>([](auto) { return MovableOnly(4); }, [](auto) { return MovableOnly(5); })
-            .value);
+  EXPECT_EQ(
+      4,
+      if_constexpr<true>(
+          [](auto) { return MovableOnly(4); },
+          [](auto) { return MovableOnly(5); })
+          .value);
+  EXPECT_EQ(
+      5,
+      if_constexpr<false>(
+          [](auto) { return MovableOnly(4); },
+          [](auto) { return MovableOnly(5); })
+          .value);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, worksWithMovableOnlyTypes_withoutIdentityArg) {
-    EXPECT_EQ(
-        4,
-        if_constexpr<true>([] { return MovableOnly(4); }, [] { return MovableOnly(5); })
-            .value);
-    EXPECT_EQ(
-        5,
-        if_constexpr<false>([] { return MovableOnly(4); }, [] { return MovableOnly(5); })
-            .value);
+  EXPECT_EQ(
+      4,
+      if_constexpr<true>(
+          [] { return MovableOnly(4); }, [] { return MovableOnly(5); })
+          .value);
+  EXPECT_EQ(
+      5,
+      if_constexpr<false>(
+          [] { return MovableOnly(4); }, [] { return MovableOnly(5); })
+          .value);
 }
 
 struct MyClass1 {
-    int value;
+  int value;
 };
 
 struct MyClass2 {
-    int val;
+  int val;
 };
 
-template<class T>
+template <class T>
 int func(T t) {
-    return if_constexpr<std::is_same<T, MyClass1>::value>(
-        [&](auto _) { return _(t).value; }, // this code is invalid for T == MyClass2
-        [&](auto _) { return _(t).val; } // this code is invalid for T == MyClass1
-    );
+  return if_constexpr<std::is_same<T, MyClass1>::value>(
+      [&](auto _) {
+        return _(t).value;
+      }, // this code is invalid for T == MyClass2
+      [&](auto _) { return _(t).val; } // this code is invalid for T == MyClass1
+  );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, otherCaseCanHaveInvalidCode) {
-    EXPECT_EQ(8, func(MyClass1{/* .value =  */ 8}));
-    EXPECT_EQ(4, func(MyClass2{/* .val =  */ 4}));
+  EXPECT_EQ(8, func(MyClass1{/* .value =  */ 8}));
+  EXPECT_EQ(4, func(MyClass2{/* .val =  */ 4}));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, worksWithoutElseCase_withIdentityArg) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    int var = 5;
-    if_constexpr<false>(
-        [&](auto) { var = 3; }
-    );
-    EXPECT_EQ(5, var);
-    if_constexpr<true>(
-        [&](auto) { var = 3; }
-    );
-    EXPECT_EQ(3, var);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  int var = 5;
+  if_constexpr<false>([&](auto) { var = 3; });
+  EXPECT_EQ(5, var);
+  if_constexpr<true>([&](auto) { var = 3; });
+  EXPECT_EQ(3, var);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, worksWithoutElseCase_withoutIdentityArg) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    int var = 5;
-    if_constexpr<false>(
-        [&] { var = 3; }
-    );
-    EXPECT_EQ(5, var);
-    if_constexpr<true>(
-        [&] { var = 3; }
-    );
-    EXPECT_EQ(3, var);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  int var = 5;
+  if_constexpr<false>([&] { var = 3; });
+  EXPECT_EQ(5, var);
+  if_constexpr<true>([&] { var = 3; });
+  EXPECT_EQ(3, var);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, returnTypeCanDiffer_withIdentityArg) {
-    auto a_string = if_constexpr<false>(
-        [&](auto) -> int64_t { return 3; },
-        [&](auto) -> std::string { return "3"; }
-    );
-    static_assert(std::is_same<std::string, decltype(a_string)>::value, "");
+  auto a_string = if_constexpr<false>(
+      [&](auto) -> int64_t { return 3; },
+      [&](auto) -> std::string { return "3"; });
+  static_assert(std::is_same<std::string, decltype(a_string)>::value, "");
 
-    // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
-    auto an_int = if_constexpr<true>(
-        [&](auto) -> int64_t { return 3; },
-        [&](auto) -> std::string { return "3"; }
-    );
-    static_assert(std::is_same<int64_t, decltype(an_int)>::value, "");
+  // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
+  auto an_int = if_constexpr<true>(
+      [&](auto) -> int64_t { return 3; },
+      [&](auto) -> std::string { return "3"; });
+  static_assert(std::is_same<int64_t, decltype(an_int)>::value, "");
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(if_constexpr, returnTypeCanDiffer_withoutIdentityArg) {
-    auto a_string = if_constexpr<false>(
-        [&] () -> int64_t { return 3; },
-        [&] () -> std::string { return "3"; }
-    );
-    static_assert(std::is_same<std::string, decltype(a_string)>::value, "");
+  auto a_string = if_constexpr<false>(
+      [&]() -> int64_t { return 3; }, [&]() -> std::string { return "3"; });
+  static_assert(std::is_same<std::string, decltype(a_string)>::value, "");
 
-    // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
-    auto an_int = if_constexpr<true>(
-        [&] () -> int64_t { return 3; },
-        [&] () -> std::string { return "3"; }
-    );
-    static_assert(std::is_same<int64_t, decltype(an_int)>::value, "");
+  // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
+  auto an_int = if_constexpr<true>(
+      [&]() -> int64_t { return 3; }, [&]() -> std::string { return "3"; });
+  static_assert(std::is_same<int64_t, decltype(an_int)>::value, "");
 }
 
-}
-}
+} // namespace test_if_constexpr
+} // namespace
diff --git a/c10/test/util/LeftRight_test.cpp b/c10/test/util/LeftRight_test.cpp
index 7cdd06f9b8a..e113e9cb65f 100644
--- a/c10/test/util/LeftRight_test.cpp
+++ b/c10/test/util/LeftRight_test.cpp
@@ -10,259 +10,257 @@ TEST(LeftRightTest, givenInt_whenWritingAndReading_thenChangesArePresent) {
   LeftRight<int> obj;
 
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-  obj.write([] (int& obj) {obj = 5;});
-  int read = obj.read([] (const int& obj) {return obj;});
+  obj.write([](int& obj) { obj = 5; });
+  int read = obj.read([](const int& obj) { return obj; });
   EXPECT_EQ(5, read);
 
   // check changes are also present in background copy
-  obj.write([] (int&) {}); // this switches to the background copy
-  read = obj.read([] (const int& obj) {return obj;});
+  obj.write([](int&) {}); // this switches to the background copy
+  read = obj.read([](const int& obj) { return obj; });
   EXPECT_EQ(5, read);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, givenVector_whenWritingAndReading_thenChangesArePresent) {
-    LeftRight<vector<int>> obj;
+  LeftRight<vector<int>> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    obj.write([] (vector<int>& obj) {obj.push_back(5);});
-    vector<int> read = obj.read([] (const vector<int>& obj) {return obj;});
-    EXPECT_EQ((vector<int>{5}), read);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  obj.write([](vector<int>& obj) { obj.push_back(5); });
+  vector<int> read = obj.read([](const vector<int>& obj) { return obj; });
+  EXPECT_EQ((vector<int>{5}), read);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    obj.write([] (vector<int>& obj) {obj.push_back(6);});
-    read = obj.read([] (const vector<int>& obj) {return obj;});
-    EXPECT_EQ((vector<int>{5, 6}), read);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  obj.write([](vector<int>& obj) { obj.push_back(6); });
+  read = obj.read([](const vector<int>& obj) { return obj; });
+  EXPECT_EQ((vector<int>{5, 6}), read);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, givenVector_whenWritingReturnsValue_thenValueIsReturned) {
-    LeftRight<vector<int>> obj;
+  LeftRight<vector<int>> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto a = obj.write([] (vector<int>&) -> int {return 5;});
-    static_assert(std::is_same<int, decltype(a)>::value, "");
-    EXPECT_EQ(5, a);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto a = obj.write([](vector<int>&) -> int { return 5; });
+  static_assert(std::is_same<int, decltype(a)>::value, "");
+  EXPECT_EQ(5, a);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, readsCanBeConcurrent) {
-    LeftRight<int> obj;
-    std::atomic<int> num_running_readers{0};
+  LeftRight<int> obj;
+  std::atomic<int> num_running_readers{0};
 
-    std::thread reader1([&] () {
-       obj.read([&] (const int&) {
-           ++num_running_readers;
-           while(num_running_readers.load() < 2) {}
-       });
+  std::thread reader1([&]() {
+    obj.read([&](const int&) {
+      ++num_running_readers;
+      while (num_running_readers.load() < 2) {
+      }
     });
+  });
 
-    std::thread reader2([&] () {
-        obj.read([&] (const int&) {
-            ++num_running_readers;
-            while(num_running_readers.load() < 2) {}
-        });
+  std::thread reader2([&]() {
+    obj.read([&](const int&) {
+      ++num_running_readers;
+      while (num_running_readers.load() < 2) {
+      }
     });
+  });
 
-    // the threads only finish after both entered the read function.
-    // if LeftRight didn't allow concurrency, this would cause a deadlock.
-    reader1.join();
-    reader2.join();
+  // the threads only finish after both entered the read function.
+  // if LeftRight didn't allow concurrency, this would cause a deadlock.
+  reader1.join();
+  reader2.join();
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, writesCanBeConcurrentWithReads_readThenWrite) {
-    LeftRight<int> obj;
-    std::atomic<bool> reader_running{false};
-    std::atomic<bool> writer_running{false};
+  LeftRight<int> obj;
+  std::atomic<bool> reader_running{false};
+  std::atomic<bool> writer_running{false};
 
-    std::thread reader([&] () {
-        obj.read([&] (const int&) {
-            reader_running = true;
-            while(!writer_running.load()) {}
-        });
+  std::thread reader([&]() {
+    obj.read([&](const int&) {
+      reader_running = true;
+      while (!writer_running.load()) {
+      }
     });
+  });
 
-    std::thread writer([&] () {
-        // run read first, write second
-        while (!reader_running.load()) {}
+  std::thread writer([&]() {
+    // run read first, write second
+    while (!reader_running.load()) {
+    }
 
-        obj.write([&] (int&) {
-            writer_running = true;
-        });
-    });
+    obj.write([&](int&) { writer_running = true; });
+  });
 
-    // the threads only finish after both entered the read function.
-    // if LeftRight didn't allow concurrency, this would cause a deadlock.
-    reader.join();
-    writer.join();
+  // the threads only finish after both entered the read function.
+  // if LeftRight didn't allow concurrency, this would cause a deadlock.
+  reader.join();
+  writer.join();
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, writesCanBeConcurrentWithReads_writeThenRead) {
-    LeftRight<int> obj;
-    std::atomic<bool> writer_running{false};
-    std::atomic<bool> reader_running{false};
+  LeftRight<int> obj;
+  std::atomic<bool> writer_running{false};
+  std::atomic<bool> reader_running{false};
 
-    std::thread writer([&] () {
-        obj.read([&] (const int&) {
-            writer_running = true;
-            while(!reader_running.load()) {}
-        });
+  std::thread writer([&]() {
+    obj.read([&](const int&) {
+      writer_running = true;
+      while (!reader_running.load()) {
+      }
     });
+  });
 
-    std::thread reader([&] () {
-        // run write first, read second
-        while (!writer_running.load()) {}
+  std::thread reader([&]() {
+    // run write first, read second
+    while (!writer_running.load()) {
+    }
 
-        obj.read([&] (const int&) {
-            reader_running = true;
-        });
-    });
+    obj.read([&](const int&) { reader_running = true; });
+  });
 
-    // the threads only finish after both entered the read function.
-    // if LeftRight didn't allow concurrency, this would cause a deadlock.
-    writer.join();
-    reader.join();
+  // the threads only finish after both entered the read function.
+  // if LeftRight didn't allow concurrency, this would cause a deadlock.
+  writer.join();
+  reader.join();
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, writesCannotBeConcurrentWithWrites) {
-    LeftRight<int> obj;
-    std::atomic<bool> first_writer_started{false};
-    std::atomic<bool> first_writer_finished{false};
+  LeftRight<int> obj;
+  std::atomic<bool> first_writer_started{false};
+  std::atomic<bool> first_writer_finished{false};
 
-    std::thread writer1([&] () {
-        obj.write([&] (int&) {
-            first_writer_started = true;
-            // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-            std::this_thread::sleep_for(std::chrono::milliseconds(50));
-            first_writer_finished = true;
-        });
+  std::thread writer1([&]() {
+    obj.write([&](int&) {
+      first_writer_started = true;
+      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
+      first_writer_finished = true;
     });
+  });
 
-    std::thread writer2([&] () {
-        // make sure the other writer runs first
-        while (!first_writer_started.load()) {}
+  std::thread writer2([&]() {
+    // make sure the other writer runs first
+    while (!first_writer_started.load()) {
+    }
 
-        obj.write([&] (int&) {
-            // expect the other writer finished before this one starts
-            EXPECT_TRUE(first_writer_finished.load());
-        });
+    obj.write([&](int&) {
+      // expect the other writer finished before this one starts
+      EXPECT_TRUE(first_writer_finished.load());
     });
+  });
 
-    writer1.join();
-    writer2.join();
+  writer1.join();
+  writer2.join();
 }
 
 namespace {
 class MyException : public std::exception {};
-}
+} // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, whenReadThrowsException_thenThrowsThrough) {
-    LeftRight<int> obj;
+  LeftRight<int> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-    EXPECT_THROW(
-        obj.read([](const int&) {throw MyException();}),
-        MyException
-    );
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
+  EXPECT_THROW(obj.read([](const int&) { throw MyException(); }), MyException);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, whenWriteThrowsException_thenThrowsThrough) {
-    LeftRight<int> obj;
+  LeftRight<int> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-    EXPECT_THROW(
-        obj.write([](int&) {throw MyException();}),
-        MyException
-    );
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
+  EXPECT_THROW(obj.write([](int&) { throw MyException(); }), MyException);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(LeftRightTest, givenInt_whenWriteThrowsExceptionOnFirstCall_thenResetsToOldState) {
-    LeftRight<int> obj;
+TEST(
+    LeftRightTest,
+    givenInt_whenWriteThrowsExceptionOnFirstCall_thenResetsToOldState) {
+  LeftRight<int> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    obj.write([](int& obj) {obj = 5;});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  obj.write([](int& obj) { obj = 5; });
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-    EXPECT_THROW(
-        obj.write([](int& obj) {
-            obj = 6;
-            throw MyException();
-        }),
-        MyException
-    );
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
+  EXPECT_THROW(
+      obj.write([](int& obj) {
+        obj = 6;
+        throw MyException();
+      }),
+      MyException);
 
-    // check reading it returns old value
-    int read = obj.read([] (const int& obj) {return obj;});
-    EXPECT_EQ(5, read);
+  // check reading it returns old value
+  int read = obj.read([](const int& obj) { return obj; });
+  EXPECT_EQ(5, read);
 
-    // check changes are also present in background copy
-    obj.write([] (int&) {}); // this switches to the background copy
-    read = obj.read([] (const int& obj) {return obj;});
-    EXPECT_EQ(5, read);
+  // check changes are also present in background copy
+  obj.write([](int&) {}); // this switches to the background copy
+  read = obj.read([](const int& obj) { return obj; });
+  EXPECT_EQ(5, read);
 }
 
 // note: each write is executed twice, on the foreground and background copy.
 // We need to test a thrown exception in either call is handled correctly.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(LeftRightTest, givenInt_whenWriteThrowsExceptionOnSecondCall_thenKeepsNewState) {
-    LeftRight<int> obj;
+TEST(
+    LeftRightTest,
+    givenInt_whenWriteThrowsExceptionOnSecondCall_thenKeepsNewState) {
+  LeftRight<int> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    obj.write([](int& obj) {obj = 5;});
-    bool write_called = false;
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  obj.write([](int& obj) { obj = 5; });
+  bool write_called = false;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-    EXPECT_THROW(
-        obj.write([&](int& obj) {
-            obj = 6;
-            if (write_called) {
-                // this is the second time the write callback is executed
-                throw MyException();
-            } else {
-                write_called = true;
-            }
-        }),
-        MyException
-    );
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
+  EXPECT_THROW(
+      obj.write([&](int& obj) {
+        obj = 6;
+        if (write_called) {
+          // this is the second time the write callback is executed
+          throw MyException();
+        } else {
+          write_called = true;
+        }
+      }),
+      MyException);
 
-    // check reading it returns new value
-    int read = obj.read([] (const int& obj) {return obj;});
-    EXPECT_EQ(6, read);
+  // check reading it returns new value
+  int read = obj.read([](const int& obj) { return obj; });
+  EXPECT_EQ(6, read);
 
-    // check changes are also present in background copy
-    obj.write([] (int&) {}); // this switches to the background copy
-    read = obj.read([] (const int& obj) {return obj;});
-    EXPECT_EQ(6, read);
+  // check changes are also present in background copy
+  obj.write([](int&) {}); // this switches to the background copy
+  read = obj.read([](const int& obj) { return obj; });
+  EXPECT_EQ(6, read);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LeftRightTest, givenVector_whenWriteThrowsException_thenResetsToOldState) {
-    LeftRight<vector<int>> obj;
+  LeftRight<vector<int>> obj;
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    obj.write([](vector<int>& obj) {obj.push_back(5);});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  obj.write([](vector<int>& obj) { obj.push_back(5); });
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
-    EXPECT_THROW(
-            obj.write([](vector<int>& obj) {
-                obj.push_back(6);
-                throw MyException();
-            }),
-            MyException
-    );
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
+  EXPECT_THROW(
+      obj.write([](vector<int>& obj) {
+        obj.push_back(6);
+        throw MyException();
+      }),
+      MyException);
 
-    // check reading it returns old value
-    vector<int> read = obj.read([] (const vector<int>& obj) {return obj;});
-    EXPECT_EQ((vector<int>{5}), read);
+  // check reading it returns old value
+  vector<int> read = obj.read([](const vector<int>& obj) { return obj; });
+  EXPECT_EQ((vector<int>{5}), read);
 
-    // check changes are also present in background copy
-    obj.write([] (vector<int>&) {}); // this switches to the background copy
-    read = obj.read([] (const vector<int>& obj) {return obj;});
-    EXPECT_EQ((vector<int>{5}), read);
+  // check changes are also present in background copy
+  obj.write([](vector<int>&) {}); // this switches to the background copy
+  read = obj.read([](const vector<int>& obj) { return obj; });
+  EXPECT_EQ((vector<int>{5}), read);
 }
diff --git a/c10/test/util/Metaprogramming_test.cpp b/c10/test/util/Metaprogramming_test.cpp
index f6cfa715be2..bcce22d634b 100644
--- a/c10/test/util/Metaprogramming_test.cpp
+++ b/c10/test/util/Metaprogramming_test.cpp
@@ -1,580 +1,820 @@
-#include <c10/util/Metaprogramming.h>
 #include <c10/test/util/Macros.h>
+#include <c10/util/Metaprogramming.h>
 #include <gtest/gtest.h>
 #include <cstdlib>
 
-
 using namespace c10::guts;
 
 namespace {
 
 namespace test_function_traits {
-    static_assert(std::is_same<void, typename function_traits<void(int, float)>::return_type>::value, "");
-    static_assert(std::is_same<int, typename function_traits<int(int, float)>::return_type>::value, "");
-    static_assert(std::is_same<typelist::typelist<int, float>, typename function_traits<void(int, float)>::parameter_types>::value, "");
-    static_assert(std::is_same<typelist::typelist<int, float>, typename function_traits<int(int, float)>::parameter_types>::value, "");
+static_assert(
+    std::is_same<
+        void,
+        typename function_traits<void(int, float)>::return_type>::value,
+    "");
+static_assert(
+    std::is_same<int, typename function_traits<int(int, float)>::return_type>::
+        value,
+    "");
+static_assert(
+    std::is_same<
+        typelist::typelist<int, float>,
+        typename function_traits<void(int, float)>::parameter_types>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist::typelist<int, float>,
+        typename function_traits<int(int, float)>::parameter_types>::value,
+    "");
 
-    static_assert(std::is_same<bool, typename make_function_traits_t<bool, typelist::typelist<int, float>>::return_type>::value, "");
-    static_assert(std::is_same<void, typename make_function_traits_t<void, typelist::typelist<int, float>>::return_type>::value, "");
-    static_assert(std::is_same<typelist::typelist<int, float>, typename make_function_traits_t<bool, typelist::typelist<int, float>>::parameter_types>::value, "");
-    static_assert(std::is_same<typelist::typelist<int, float>, typename make_function_traits_t<void, typelist::typelist<int, float>>::parameter_types>::value, "");
-    static_assert(std::is_same<bool(int, float), typename make_function_traits_t<bool, typelist::typelist<int, float>>::func_type>::value, "");
-    static_assert(std::is_same<void(int, float), typename make_function_traits_t<void, typelist::typelist<int, float>>::func_type>::value, "");
-}
+static_assert(
+    std::is_same<
+        bool,
+        typename make_function_traits_t<bool, typelist::typelist<int, float>>::
+            return_type>::value,
+    "");
+static_assert(
+    std::is_same<
+        void,
+        typename make_function_traits_t<void, typelist::typelist<int, float>>::
+            return_type>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist::typelist<int, float>,
+        typename make_function_traits_t<bool, typelist::typelist<int, float>>::
+            parameter_types>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist::typelist<int, float>,
+        typename make_function_traits_t<void, typelist::typelist<int, float>>::
+            parameter_types>::value,
+    "");
+static_assert(
+    std::is_same<
+        bool(int, float),
+        typename make_function_traits_t<bool, typelist::typelist<int, float>>::
+            func_type>::value,
+    "");
+static_assert(
+    std::is_same<
+        void(int, float),
+        typename make_function_traits_t<void, typelist::typelist<int, float>>::
+            func_type>::value,
+    "");
+} // namespace test_function_traits
 
 struct MovableOnly {
-    constexpr MovableOnly(int val_): val(val_) {/* no default constructor */}
-    MovableOnly(const MovableOnly&) = delete;
-    MovableOnly(MovableOnly&&) = default;
-    MovableOnly& operator=(const MovableOnly&) = delete;
-    MovableOnly& operator=(MovableOnly&&) = default;
+  constexpr MovableOnly(int val_) : val(val_) { /* no default constructor */
+  }
+  MovableOnly(const MovableOnly&) = delete;
+  MovableOnly(MovableOnly&&) = default;
+  MovableOnly& operator=(const MovableOnly&) = delete;
+  MovableOnly& operator=(MovableOnly&&) = default;
 
-    friend bool operator==(const MovableOnly& lhs, const MovableOnly& rhs) {return lhs.val == rhs.val;}
-private:
-    int val;
+  friend bool operator==(const MovableOnly& lhs, const MovableOnly& rhs) {
+    return lhs.val == rhs.val;
+  }
+
+ private:
+  int val;
 };
 
-template<class T> using is_my_movable_only_class = std::is_same<MovableOnly, std::remove_cv_t<std::remove_reference_t<T>>>;
+template <class T>
+using is_my_movable_only_class =
+    std::is_same<MovableOnly, std::remove_cv_t<std::remove_reference_t<T>>>;
 
 struct CopyCounting {
-    int move_count;
-    int copy_count;
+  int move_count;
+  int copy_count;
 
-    CopyCounting(): move_count(0), copy_count(0) {}
-    CopyCounting(const CopyCounting& rhs): move_count(rhs.move_count), copy_count(rhs.copy_count + 1) {}
-    CopyCounting(CopyCounting&& rhs): move_count(rhs.move_count + 1), copy_count(rhs.copy_count) {}
-    CopyCounting& operator=(const CopyCounting& rhs) {
-        move_count = rhs.move_count;
-        copy_count = rhs.copy_count + 1;
-        return *this;
-    }
-    CopyCounting& operator=(CopyCounting&& rhs) {
-        move_count = rhs.move_count + 1;
-        copy_count = rhs.copy_count;
-        return *this;
-    }
+  CopyCounting() : move_count(0), copy_count(0) {}
+  CopyCounting(const CopyCounting& rhs)
+      : move_count(rhs.move_count), copy_count(rhs.copy_count + 1) {}
+  CopyCounting(CopyCounting&& rhs)
+      : move_count(rhs.move_count + 1), copy_count(rhs.copy_count) {}
+  CopyCounting& operator=(const CopyCounting& rhs) {
+    move_count = rhs.move_count;
+    copy_count = rhs.copy_count + 1;
+    return *this;
+  }
+  CopyCounting& operator=(CopyCounting&& rhs) {
+    move_count = rhs.move_count + 1;
+    copy_count = rhs.copy_count;
+    return *this;
+  }
 };
 
-template<class T> using is_my_copy_counting_class = std::is_same<CopyCounting, std::remove_cv_t<std::remove_reference_t<T>>>;
+template <class T>
+using is_my_copy_counting_class =
+    std::is_same<CopyCounting, std::remove_cv_t<std::remove_reference_t<T>>>;
 
 namespace test_extract_arg_by_filtered_index {
-    class MyClass {};
+class MyClass {};
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto a1 = extract_arg_by_filtered_index<std::is_integral, 0>(3, "bla", MyClass(), 4, nullptr, 5);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto a2 = extract_arg_by_filtered_index<std::is_integral, 1>(3, "bla", MyClass(), 4, nullptr, 5);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto a3 = extract_arg_by_filtered_index<std::is_integral, 2>(3, "bla", MyClass(), 4, nullptr, 5);
-        EXPECT_EQ(3, a1);
-        EXPECT_EQ(4, a2);
-        EXPECT_EQ(5, a3);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_singleInput) {
-        auto a1 = extract_arg_by_filtered_index<std::is_integral, 0>(3);
-        EXPECT_EQ(3, a1);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_movableOnly) {
-        MovableOnly a1 = extract_arg_by_filtered_index<is_my_movable_only_class, 0>(3, MovableOnly(3), "test", MovableOnly(1));
-        MovableOnly a2 = extract_arg_by_filtered_index<is_my_movable_only_class, 1>(3, MovableOnly(3), "test", MovableOnly(1));
-        EXPECT_EQ(MovableOnly(3), a1);
-        EXPECT_EQ(MovableOnly(1), a2);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_onlyCopiesIfNecessary) {
-        CopyCounting source;
-        CopyCounting source2;
-        CopyCounting a1 = extract_arg_by_filtered_index<is_my_copy_counting_class, 0>(3, CopyCounting(), "test", source, std::move(source2));
-        // NOLINTNEXTLINE(bugprone-use-after-move)
-        CopyCounting a2 = extract_arg_by_filtered_index<is_my_copy_counting_class, 1>(3, CopyCounting(), "test", source, std::move(source2));
-        // NOLINTNEXTLINE(bugprone-use-after-move)
-        CopyCounting a3 = extract_arg_by_filtered_index<is_my_copy_counting_class, 2>(3, CopyCounting(), "test", source, std::move(source2));
-        EXPECT_EQ(1, a1.move_count);
-        EXPECT_EQ(0, a1.copy_count);
-        EXPECT_EQ(0, a2.move_count);
-        EXPECT_EQ(1, a3.move_count);
-        EXPECT_EQ(0, a3.copy_count);
-        EXPECT_EQ(1, a2.copy_count);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_onlyMovesIfNecessary) {
-        CopyCounting source;
-        CopyCounting source2;
-        CopyCounting&& a1 = extract_arg_by_filtered_index<is_my_copy_counting_class , 0>(3, std::move(source), "test", std::move(source2));
-        // NOLINTNEXTLINE(bugprone-use-after-move)
-        CopyCounting a2 = extract_arg_by_filtered_index<is_my_copy_counting_class , 1>(3, std::move(source), "test", std::move(source2));
-        EXPECT_EQ(0, a1.move_count);
-        EXPECT_EQ(0, a1.copy_count);
-        EXPECT_EQ(1, a2.move_count);
-        EXPECT_EQ(0, a2.copy_count);
-    }
-
-    template<class T> using is_true = std::true_type;
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_keepsLValueReferencesIntact) {
-        MyClass obj;
-        MyClass& a1 = extract_arg_by_filtered_index<is_true, 1>(3, obj, "test", obj);
-        EXPECT_EQ(&obj, &a1);
-    }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, ExtractArgByFilteredIndex) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto a1 = extract_arg_by_filtered_index<std::is_integral, 0>(
+      3, "bla", MyClass(), 4, nullptr, 5);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto a2 = extract_arg_by_filtered_index<std::is_integral, 1>(
+      3, "bla", MyClass(), 4, nullptr, 5);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto a3 = extract_arg_by_filtered_index<std::is_integral, 2>(
+      3, "bla", MyClass(), 4, nullptr, 5);
+  EXPECT_EQ(3, a1);
+  EXPECT_EQ(4, a2);
+  EXPECT_EQ(5, a3);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_singleInput) {
+  auto a1 = extract_arg_by_filtered_index<std::is_integral, 0>(3);
+  EXPECT_EQ(3, a1);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_movableOnly) {
+  MovableOnly a1 = extract_arg_by_filtered_index<is_my_movable_only_class, 0>(
+      3, MovableOnly(3), "test", MovableOnly(1));
+  MovableOnly a2 = extract_arg_by_filtered_index<is_my_movable_only_class, 1>(
+      3, MovableOnly(3), "test", MovableOnly(1));
+  EXPECT_EQ(MovableOnly(3), a1);
+  EXPECT_EQ(MovableOnly(1), a2);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_onlyCopiesIfNecessary) {
+  CopyCounting source;
+  CopyCounting source2;
+  CopyCounting a1 = extract_arg_by_filtered_index<is_my_copy_counting_class, 0>(
+      3, CopyCounting(), "test", source, std::move(source2));
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  CopyCounting a2 = extract_arg_by_filtered_index<is_my_copy_counting_class, 1>(
+      3, CopyCounting(), "test", source, std::move(source2));
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  CopyCounting a3 = extract_arg_by_filtered_index<is_my_copy_counting_class, 2>(
+      3, CopyCounting(), "test", source, std::move(source2));
+  EXPECT_EQ(1, a1.move_count);
+  EXPECT_EQ(0, a1.copy_count);
+  EXPECT_EQ(0, a2.move_count);
+  EXPECT_EQ(1, a3.move_count);
+  EXPECT_EQ(0, a3.copy_count);
+  EXPECT_EQ(1, a2.copy_count);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, ExtractArgByFilteredIndex_onlyMovesIfNecessary) {
+  CopyCounting source;
+  CopyCounting source2;
+  CopyCounting&& a1 =
+      extract_arg_by_filtered_index<is_my_copy_counting_class, 0>(
+          3, std::move(source), "test", std::move(source2));
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  CopyCounting a2 = extract_arg_by_filtered_index<is_my_copy_counting_class, 1>(
+      3, std::move(source), "test", std::move(source2));
+  EXPECT_EQ(0, a1.move_count);
+  EXPECT_EQ(0, a1.copy_count);
+  EXPECT_EQ(1, a2.move_count);
+  EXPECT_EQ(0, a2.copy_count);
+}
+
+template <class T>
+using is_true = std::true_type;
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(
+    MetaprogrammingTest,
+    ExtractArgByFilteredIndex_keepsLValueReferencesIntact) {
+  MyClass obj;
+  MyClass& a1 = extract_arg_by_filtered_index<is_true, 1>(3, obj, "test", obj);
+  EXPECT_EQ(&obj, &a1);
+}
+} // namespace test_extract_arg_by_filtered_index
+
 namespace test_filter_map {
-    class MyClass {};
+class MyClass {};
 
-    struct map_to_double {
-      template<class T> constexpr double operator()(T a) const {
-        return static_cast<double>(a);
-      }
-    };
+struct map_to_double {
+  template <class T>
+  constexpr double operator()(T a) const {
+    return static_cast<double>(a);
+  }
+};
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto result = filter_map<double, std::is_integral>(map_to_double(), 3, "bla", MyClass(), 4, nullptr, 5);
-        static_assert(std::is_same<array<double, 3>, decltype(result)>::value, "");
-        constexpr array<double, 3> expected{{3.0, 4.0, 5.0}};
-        EXPECT_EQ(expected, result);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap_emptyInput) {
-        auto result = filter_map<double, std::is_integral>(map_to_double());
-        static_assert(std::is_same<array<double, 0>, decltype(result)>::value, "");
-        constexpr array<double, 0> expected{{}};
-        EXPECT_EQ(expected, result);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap_emptyOutput) {
-        auto result = filter_map<double, std::is_integral>(map_to_double(), "bla", MyClass(), nullptr);
-        static_assert(std::is_same<array<double, 0>, decltype(result)>::value, "");
-        constexpr array<double, 0> expected{{}};
-        EXPECT_EQ(expected, result);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap_movableOnly_byRValue) {
-        struct map_movable_by_rvalue {
-          MovableOnly operator()(MovableOnly&& a) const {
-            return std::move(a);
-          }
-        };
-
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto result = filter_map<MovableOnly, is_my_movable_only_class>(map_movable_by_rvalue(), MovableOnly(5), "bla", nullptr, 3, MovableOnly(2));
-        static_assert(std::is_same<array<MovableOnly, 2>, decltype(result)>::value, "");
-        constexpr array<MovableOnly, 2> expected {{MovableOnly(5), MovableOnly(2)}};
-        EXPECT_EQ(expected, result);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap_movableOnly_byValue) {
-        struct map_movable_by_lvalue {
-          MovableOnly operator()(MovableOnly a) const {
-            return a;
-          }
-        };
-
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto result = filter_map<MovableOnly, is_my_movable_only_class>(map_movable_by_lvalue(), MovableOnly(5), "bla", nullptr, 3, MovableOnly(2));
-        static_assert(std::is_same<array<MovableOnly, 2>, decltype(result)>::value, "");
-        constexpr array<MovableOnly, 2> expected {{MovableOnly(5), MovableOnly(2)}};
-        EXPECT_EQ(expected, result);
-    }
-
-    // See https://github.com/pytorch/pytorch/issues/35546
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, DISABLED_ON_WINDOWS(FilterMap_onlyCopiesIfNecessary)) {
-        struct map_copy_counting_by_copy {
-          CopyCounting operator()(CopyCounting v) const {
-            return v;
-          }
-        };
-
-        CopyCounting source;
-        CopyCounting source2;
-        auto result = filter_map<CopyCounting, is_my_copy_counting_class>(map_copy_counting_by_copy(), CopyCounting(), "bla", nullptr, 3, source, std::move(source2));
-        static_assert(std::is_same<array<CopyCounting, 3>, decltype(result)>::value, "");
-        EXPECT_EQ(0, result[0].copy_count);
-        EXPECT_EQ(2, result[0].move_count);
-        EXPECT_EQ(1, result[1].copy_count);
-        EXPECT_EQ(1, result[1].move_count);
-        EXPECT_EQ(0, result[2].copy_count);
-        EXPECT_EQ(2, result[2].move_count);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, DISABLED_ON_WINDOWS(FilterMap_onlyMovesIfNecessary_1)) {
-        struct map_copy_counting_by_move {
-          CopyCounting operator()(CopyCounting&& v) const {
-            return std::move(v);
-          }
-        };
-
-        CopyCounting source;
-        auto result = filter_map<CopyCounting, is_my_copy_counting_class>(map_copy_counting_by_move(), CopyCounting(), "bla", nullptr, 3, std::move(source));
-        static_assert(std::is_same<array<CopyCounting, 2>, decltype(result)>::value, "");
-        EXPECT_EQ(0, result[0].copy_count);
-        EXPECT_EQ(1, result[0].move_count);
-        EXPECT_EQ(0, result[1].copy_count);
-        EXPECT_EQ(1, result[1].move_count);
-    }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(MetaprogrammingTest, FilterMap_onlyMovesIfNecessary_2) {
-        struct map_copy_counting_by_pointer {
-          const CopyCounting* operator()(const CopyCounting& v) const {
-            return &v;
-          }
-        };
-
-        CopyCounting source1;
-        CopyCounting source2;
-        auto result = filter_map<const CopyCounting*, is_my_copy_counting_class>(map_copy_counting_by_pointer(), "bla", nullptr, 3, source1, std::move(source2));
-        static_assert(std::is_same<array<const CopyCounting*, 2>, decltype(result)>::value, "");
-        EXPECT_EQ(0, result[0]->copy_count);
-        EXPECT_EQ(0, result[0]->move_count);
-        EXPECT_EQ(0, result[1]->copy_count);
-        EXPECT_EQ(0, result[1]->move_count);
-    }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = filter_map<double, std::is_integral>(
+      map_to_double(), 3, "bla", MyClass(), 4, nullptr, 5);
+  static_assert(std::is_same<array<double, 3>, decltype(result)>::value, "");
+  constexpr array<double, 3> expected{{3.0, 4.0, 5.0}};
+  EXPECT_EQ(expected, result);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap_emptyInput) {
+  auto result = filter_map<double, std::is_integral>(map_to_double());
+  static_assert(std::is_same<array<double, 0>, decltype(result)>::value, "");
+  constexpr array<double, 0> expected{{}};
+  EXPECT_EQ(expected, result);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap_emptyOutput) {
+  auto result = filter_map<double, std::is_integral>(
+      map_to_double(), "bla", MyClass(), nullptr);
+  static_assert(std::is_same<array<double, 0>, decltype(result)>::value, "");
+  constexpr array<double, 0> expected{{}};
+  EXPECT_EQ(expected, result);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap_movableOnly_byRValue) {
+  struct map_movable_by_rvalue {
+    MovableOnly operator()(MovableOnly&& a) const {
+      return std::move(a);
+    }
+  };
+
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = filter_map<MovableOnly, is_my_movable_only_class>(
+      map_movable_by_rvalue(),
+      MovableOnly(5),
+      "bla",
+      nullptr,
+      3,
+      MovableOnly(2));
+  static_assert(
+      std::is_same<array<MovableOnly, 2>, decltype(result)>::value, "");
+  constexpr array<MovableOnly, 2> expected{{MovableOnly(5), MovableOnly(2)}};
+  EXPECT_EQ(expected, result);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap_movableOnly_byValue) {
+  struct map_movable_by_lvalue {
+    MovableOnly operator()(MovableOnly a) const {
+      return a;
+    }
+  };
+
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = filter_map<MovableOnly, is_my_movable_only_class>(
+      map_movable_by_lvalue(),
+      MovableOnly(5),
+      "bla",
+      nullptr,
+      3,
+      MovableOnly(2));
+  static_assert(
+      std::is_same<array<MovableOnly, 2>, decltype(result)>::value, "");
+  constexpr array<MovableOnly, 2> expected{{MovableOnly(5), MovableOnly(2)}};
+  EXPECT_EQ(expected, result);
+}
+
+// See https://github.com/pytorch/pytorch/issues/35546
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(
+    MetaprogrammingTest,
+    DISABLED_ON_WINDOWS(FilterMap_onlyCopiesIfNecessary)) {
+  struct map_copy_counting_by_copy {
+    CopyCounting operator()(CopyCounting v) const {
+      return v;
+    }
+  };
+
+  CopyCounting source;
+  CopyCounting source2;
+  auto result = filter_map<CopyCounting, is_my_copy_counting_class>(
+      map_copy_counting_by_copy(),
+      CopyCounting(),
+      "bla",
+      nullptr,
+      3,
+      source,
+      std::move(source2));
+  static_assert(
+      std::is_same<array<CopyCounting, 3>, decltype(result)>::value, "");
+  EXPECT_EQ(0, result[0].copy_count);
+  EXPECT_EQ(2, result[0].move_count);
+  EXPECT_EQ(1, result[1].copy_count);
+  EXPECT_EQ(1, result[1].move_count);
+  EXPECT_EQ(0, result[2].copy_count);
+  EXPECT_EQ(2, result[2].move_count);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(
+    MetaprogrammingTest,
+    DISABLED_ON_WINDOWS(FilterMap_onlyMovesIfNecessary_1)) {
+  struct map_copy_counting_by_move {
+    CopyCounting operator()(CopyCounting&& v) const {
+      return std::move(v);
+    }
+  };
+
+  CopyCounting source;
+  auto result = filter_map<CopyCounting, is_my_copy_counting_class>(
+      map_copy_counting_by_move(),
+      CopyCounting(),
+      "bla",
+      nullptr,
+      3,
+      std::move(source));
+  static_assert(
+      std::is_same<array<CopyCounting, 2>, decltype(result)>::value, "");
+  EXPECT_EQ(0, result[0].copy_count);
+  EXPECT_EQ(1, result[0].move_count);
+  EXPECT_EQ(0, result[1].copy_count);
+  EXPECT_EQ(1, result[1].move_count);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, FilterMap_onlyMovesIfNecessary_2) {
+  struct map_copy_counting_by_pointer {
+    const CopyCounting* operator()(const CopyCounting& v) const {
+      return &v;
+    }
+  };
+
+  CopyCounting source1;
+  CopyCounting source2;
+  auto result = filter_map<const CopyCounting*, is_my_copy_counting_class>(
+      map_copy_counting_by_pointer(),
+      "bla",
+      nullptr,
+      3,
+      source1,
+      std::move(source2));
+  static_assert(
+      std::is_same<array<const CopyCounting*, 2>, decltype(result)>::value, "");
+  EXPECT_EQ(0, result[0]->copy_count);
+  EXPECT_EQ(0, result[0]->move_count);
+  EXPECT_EQ(0, result[1]->copy_count);
+  EXPECT_EQ(0, result[1]->move_count);
+}
+} // namespace test_filter_map
+
 namespace test_tuple_elements {
-  // note: not testing empty selection, as some compilers will raise
-  // "parameter set but not used" in tuple_elements(). a good example
-  // of the friction that comes with using these tools
+// note: not testing empty selection, as some compilers will raise
+// "parameter set but not used" in tuple_elements(). a good example
+// of the friction that comes with using these tools
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleElements_subsetSelection) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_elements(x, std::index_sequence<0, 2>());
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto z = std::make_tuple(0, 2.0);
-    EXPECT_EQ(y, z);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleElements_reorderSelection) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_elements(x, std::index_sequence<0, 2, 1>());
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto z = std::make_tuple(0, 2.0, "HEY");
-    EXPECT_EQ(y, z);
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleElements_subsetSelection) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_elements(x, std::index_sequence<0, 2>());
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto z = std::make_tuple(0, 2.0);
+  EXPECT_EQ(y, z);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleElements_reorderSelection) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_elements(x, std::index_sequence<0, 2, 1>());
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto z = std::make_tuple(0, 2.0, "HEY");
+  EXPECT_EQ(y, z);
+}
+} // namespace test_tuple_elements
+
 namespace test_tuple_take {
-  // note: not testing empty prefix, see note on empty selection above.
+// note: not testing empty prefix, see note on empty selection above.
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleTake_nonemptyPrefix) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_take<decltype(x), 2>(x);
-    auto z = std::make_tuple(0, "HEY");
-    EXPECT_EQ(y, z);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleTake_fullPrefix) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_take<decltype(x), 3>(x);
-    EXPECT_EQ(x, y);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleTake_negative) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_take<decltype(x), -2>(x);
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto z = std::make_tuple("HEY", 2.0);
-    EXPECT_EQ(y, z);
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleTake_nonemptyPrefix) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_take<decltype(x), 2>(x);
+  auto z = std::make_tuple(0, "HEY");
+  EXPECT_EQ(y, z);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleTake_fullPrefix) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_take<decltype(x), 3>(x);
+  EXPECT_EQ(x, y);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleTake_negative) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_take<decltype(x), -2>(x);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto z = std::make_tuple("HEY", 2.0);
+  EXPECT_EQ(y, z);
+}
+} // namespace test_tuple_take
+
 namespace test_tuple_slice {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleSlice_middle) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0, false);
-    auto y = tuple_slice<decltype(x), 1, 2>(x);
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto z = std::make_tuple("HEY", 2.0);
-    EXPECT_EQ(y, z);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleSlice_full) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto x = std::make_tuple(0, "HEY", 2.0);
-    auto y = tuple_slice<decltype(x), 0, 3>(x);
-    EXPECT_EQ(x, y);
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleSlice_middle) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0, false);
+  auto y = tuple_slice<decltype(x), 1, 2>(x);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto z = std::make_tuple("HEY", 2.0);
+  EXPECT_EQ(y, z);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleSlice_full) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto x = std::make_tuple(0, "HEY", 2.0);
+  auto y = tuple_slice<decltype(x), 0, 3>(x);
+  EXPECT_EQ(x, y);
+}
+} // namespace test_tuple_slice
+
 namespace test_tuple_map {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_simple) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_map(std::tuple<int32_t, int32_t, int32_t>(3, 4, 5), [] (int32_t a) -> int16_t {return a+1;});
-    static_assert(std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::value, "");
-    EXPECT_EQ(4, std::get<0>(result));
-    EXPECT_EQ(5, std::get<1>(result));
-    EXPECT_EQ(6, std::get<2>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_mapperTakesDifferentButConvertibleType) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_map(std::tuple<int32_t, int32_t, int32_t>(3, 4, 5), [] (int64_t a) -> int16_t {return a+1;});
-    static_assert(std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::value, "");
-    EXPECT_EQ(4, std::get<0>(result));
-    EXPECT_EQ(5, std::get<1>(result));
-    EXPECT_EQ(6, std::get<2>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_mapperTakesConstRef) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_map(std::tuple<int32_t, int32_t, int32_t>(3, 4, 5), [] (const int32_t& a) -> int16_t {return a+1;});
-    static_assert(std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::value, "");
-    EXPECT_EQ(4, std::get<0>(result));
-    EXPECT_EQ(5, std::get<1>(result));
-    EXPECT_EQ(6, std::get<2>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_mapsToDifferentTypes) {
-    struct Mapper {
-      std::string operator()(int32_t a) const {
-        return std::to_string(a);
-      }
-      int32_t operator()(const std::string& a) const {
-        return atoi(a.c_str());
-      }
-    };
-    auto result = tuple_map(std::tuple<int32_t, std::string>(3, "4"), Mapper());
-    static_assert(std::is_same<std::tuple<std::string, int32_t>, decltype(result)>::value, "");
-    EXPECT_EQ("3", std::get<0>(result));
-    EXPECT_EQ(4, std::get<1>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_differentiatesLRValueReferences) {
-    struct Mapper {
-      std::string operator()(std::string&& a) const {
-        return "moved";
-      }
-      std::string operator()(const std::string& a) const {
-        return "copied";
-      }
-    };
-    std::string str1, str2;
-    auto result = tuple_map(std::tuple<const std::string&, std::string&&>(str1, std::move(str2)), Mapper());
-    static_assert(std::is_same<std::tuple<std::string, std::string>, decltype(result)>::value, "");
-    EXPECT_EQ("copied", std::get<0>(result));
-    EXPECT_EQ("moved", std::get<1>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_canWorkWithMovableOnlyType) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_map(std::tuple<MovableOnly>(MovableOnly(7)), [] (MovableOnly a) { return a; });
-    static_assert(std::is_same<std::tuple<MovableOnly>, decltype(result)>::value, "");
-    EXPECT_EQ(MovableOnly(7), std::get<0>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_doesntUnecessarilyCopyValues) {
-    auto result = tuple_map(std::tuple<CopyCounting>(CopyCounting()), [] (CopyCounting a) { return a; });
-    static_assert(std::is_same<std::tuple<CopyCounting>, decltype(result)>::value, "");
-    EXPECT_EQ(4, std::get<0>(result).move_count);
-    EXPECT_EQ(0, std::get<0>(result).copy_count);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_doesntUnecessarilyMoveValues) {
-    CopyCounting a;
-    auto result = tuple_map(std::tuple<CopyCounting&&>(std::move(a)), [] (CopyCounting&& a) -> CopyCounting&& { return std::move(a); });
-    static_assert(std::is_same<std::tuple<CopyCounting&&>, decltype(result)>::value, "");
-    EXPECT_EQ(&a, &std::get<0>(result));
-    EXPECT_EQ(0, std::get<0>(result).move_count);
-    EXPECT_EQ(0, std::get<0>(result).copy_count);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleMap_canBeUsedWithAutoLambdas) {
-    struct A final {
-      int32_t func() {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        return 5;
-      }
-    };
-    struct B final {
-      std::string func() {
-        return "5";
-      }
-    };
-    auto result = tuple_map(std::make_tuple(A(), B()), [] (auto a) { return a.func(); });
-    static_assert(std::is_same<std::tuple<int32_t, std::string>, decltype(result)>::value, "");
-    EXPECT_EQ(5, std::get<0>(result));
-    EXPECT_EQ("5", std::get<1>(result));
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_simple) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_map(
+      std::tuple<int32_t, int32_t, int32_t>(3, 4, 5),
+      [](int32_t a) -> int16_t { return a + 1; });
+  static_assert(
+      std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::
+          value,
+      "");
+  EXPECT_EQ(4, std::get<0>(result));
+  EXPECT_EQ(5, std::get<1>(result));
+  EXPECT_EQ(6, std::get<2>(result));
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_mapperTakesDifferentButConvertibleType) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_map(
+      std::tuple<int32_t, int32_t, int32_t>(3, 4, 5),
+      [](int64_t a) -> int16_t { return a + 1; });
+  static_assert(
+      std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::
+          value,
+      "");
+  EXPECT_EQ(4, std::get<0>(result));
+  EXPECT_EQ(5, std::get<1>(result));
+  EXPECT_EQ(6, std::get<2>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_mapperTakesConstRef) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_map(
+      std::tuple<int32_t, int32_t, int32_t>(3, 4, 5),
+      [](const int32_t& a) -> int16_t { return a + 1; });
+  static_assert(
+      std::is_same<std::tuple<int16_t, int16_t, int16_t>, decltype(result)>::
+          value,
+      "");
+  EXPECT_EQ(4, std::get<0>(result));
+  EXPECT_EQ(5, std::get<1>(result));
+  EXPECT_EQ(6, std::get<2>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_mapsToDifferentTypes) {
+  struct Mapper {
+    std::string operator()(int32_t a) const {
+      return std::to_string(a);
+    }
+    int32_t operator()(const std::string& a) const {
+      return atoi(a.c_str());
+    }
+  };
+  auto result = tuple_map(std::tuple<int32_t, std::string>(3, "4"), Mapper());
+  static_assert(
+      std::is_same<std::tuple<std::string, int32_t>, decltype(result)>::value,
+      "");
+  EXPECT_EQ("3", std::get<0>(result));
+  EXPECT_EQ(4, std::get<1>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_differentiatesLRValueReferences) {
+  struct Mapper {
+    std::string operator()(std::string&& a) const {
+      return "moved";
+    }
+    std::string operator()(const std::string& a) const {
+      return "copied";
+    }
+  };
+  std::string str1, str2;
+  auto result = tuple_map(
+      std::tuple<const std::string&, std::string&&>(str1, std::move(str2)),
+      Mapper());
+  static_assert(
+      std::is_same<std::tuple<std::string, std::string>, decltype(result)>::
+          value,
+      "");
+  EXPECT_EQ("copied", std::get<0>(result));
+  EXPECT_EQ("moved", std::get<1>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_canWorkWithMovableOnlyType) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_map(
+      std::tuple<MovableOnly>(MovableOnly(7)), [](MovableOnly a) { return a; });
+  static_assert(
+      std::is_same<std::tuple<MovableOnly>, decltype(result)>::value, "");
+  EXPECT_EQ(MovableOnly(7), std::get<0>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_doesntUnecessarilyCopyValues) {
+  auto result = tuple_map(
+      std::tuple<CopyCounting>(CopyCounting()),
+      [](CopyCounting a) { return a; });
+  static_assert(
+      std::is_same<std::tuple<CopyCounting>, decltype(result)>::value, "");
+  EXPECT_EQ(4, std::get<0>(result).move_count);
+  EXPECT_EQ(0, std::get<0>(result).copy_count);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_doesntUnecessarilyMoveValues) {
+  CopyCounting a;
+  auto result = tuple_map(
+      std::tuple<CopyCounting&&>(std::move(a)),
+      [](CopyCounting&& a) -> CopyCounting&& { return std::move(a); });
+  static_assert(
+      std::is_same<std::tuple<CopyCounting&&>, decltype(result)>::value, "");
+  EXPECT_EQ(&a, &std::get<0>(result));
+  EXPECT_EQ(0, std::get<0>(result).move_count);
+  EXPECT_EQ(0, std::get<0>(result).copy_count);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleMap_canBeUsedWithAutoLambdas) {
+  struct A final {
+    int32_t func() {
+      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+      return 5;
+    }
+  };
+  struct B final {
+    std::string func() {
+      return "5";
+    }
+  };
+  auto result =
+      tuple_map(std::make_tuple(A(), B()), [](auto a) { return a.func(); });
+  static_assert(
+      std::is_same<std::tuple<int32_t, std::string>, decltype(result)>::value,
+      "");
+  EXPECT_EQ(5, std::get<0>(result));
+  EXPECT_EQ("5", std::get<1>(result));
+}
+} // namespace test_tuple_map
+
 namespace test_tuple_concat {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_zerotuples) {
-    auto result = tuple_concat();
-    static_assert(std::is_same<std::tuple<>, decltype(result)>::value, "");
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_oneemptytuple) {
-    auto result = tuple_concat(std::tuple<>());
-    static_assert(std::is_same<std::tuple<>, decltype(result)>::value, "");
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_onenonemptytuple) {
-    auto result = tuple_concat(std::tuple<int64_t>(3));
-    static_assert(std::is_same<std::tuple<int64_t>, decltype(result)>::value, "");
-    EXPECT_EQ(3, std::get<0>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_twotuples) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_concat(std::tuple<int64_t, std::string>(3, "4"), std::tuple<double, int16_t>(2.3, 15));
-    static_assert(std::is_same<std::tuple<int64_t, std::string, double, int16_t>, decltype(result)>::value, "");
-    EXPECT_EQ(3, std::get<0>(result));
-    EXPECT_EQ("4", std::get<1>(result));
-    EXPECT_EQ(2.3, std::get<2>(result));
-    EXPECT_EQ(15, std::get<3>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_threetuples) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_concat(std::tuple<int64_t, std::string>(3, "4"), std::tuple<double, int16_t>(2.3, 15), std::tuple<std::string, float>("5", 3.2));
-    static_assert(std::is_same<std::tuple<int64_t, std::string, double, int16_t, std::string, float>, decltype(result)>::value, "");
-    EXPECT_EQ(3, std::get<0>(result));
-    EXPECT_EQ("4", std::get<1>(result));
-    EXPECT_EQ(2.3, std::get<2>(result));
-    EXPECT_EQ(15, std::get<3>(result));
-    EXPECT_EQ("5", std::get<4>(result));
-    EXPECT_EQ(static_cast<float>(3.2), std::get<5>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_emptytupleatbeginning) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_concat(std::tuple<>(), std::tuple<double, int16_t>(2.3, 15), std::tuple<std::string, float>("5", 3.2));
-    static_assert(std::is_same<std::tuple<double, int16_t, std::string, float>, decltype(result)>::value, "");
-    EXPECT_EQ(2.3, std::get<0>(result));
-    EXPECT_EQ(15, std::get<1>(result));
-    EXPECT_EQ("5", std::get<2>(result));
-    EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_emptytupleinmiddle) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_concat(std::tuple<double, int16_t>(2.3, 15), std::tuple<>(), std::tuple<std::string, float>("5", 3.2));
-    static_assert(std::is_same<std::tuple<double, int16_t, std::string, float>, decltype(result)>::value, "");
-    EXPECT_EQ(2.3, std::get<0>(result));
-    EXPECT_EQ(15, std::get<1>(result));
-    EXPECT_EQ("5", std::get<2>(result));
-    EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_emptytupleatend) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto result = tuple_concat(std::tuple<double, int16_t>(2.3, 15), std::tuple<std::string, float>("5", 3.2), std::tuple<>());
-    static_assert(std::is_same<std::tuple<double, int16_t, std::string, float>, decltype(result)>::value, "");
-    EXPECT_EQ(2.3, std::get<0>(result));
-    EXPECT_EQ(15, std::get<1>(result));
-    EXPECT_EQ("5", std::get<2>(result));
-    EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_workswithreferencesandpointers) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    double val1 = 2.3;
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    int16_t val2 = 15;
-    std::string val3 = "hello";
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float val4 = 3.2;
-    auto result = tuple_concat(std::tuple<double&, const int16_t&>(val1, val2), std::tuple<std::string&&, float*>(std::move(val3), &val4));
-    static_assert(std::is_same<std::tuple<double&, const int16_t&, std::string&&, float*>, decltype(result)>::value, "");
-    EXPECT_EQ(2.3, std::get<0>(result));
-    EXPECT_EQ(&val1, &std::get<0>(result));
-    EXPECT_EQ(15, std::get<1>(result));
-    EXPECT_EQ(&val2, &std::get<1>(result));
-    EXPECT_EQ("hello", std::get<2>(result));
-    EXPECT_EQ(&val3, &std::get<2>(result));
-    EXPECT_EQ(static_cast<float>(3.2), *std::get<3>(result));
-    EXPECT_EQ(&val4, std::get<3>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_worksWithMovableOnlyTypes) {
-    auto result = tuple_concat(std::tuple<MovableOnly, MovableOnly>(1, 2), std::tuple<MovableOnly>(3));
-    static_assert(std::is_same<std::tuple<MovableOnly, MovableOnly, MovableOnly>, decltype(result)>::value, "");
-    EXPECT_EQ(MovableOnly(1), std::get<0>(result));
-    EXPECT_EQ(MovableOnly(2), std::get<1>(result));
-    EXPECT_EQ(MovableOnly(3), std::get<2>(result));
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(MetaprogrammingTest, TupleConcat_doesntCopyMoreThanNecessary) {
-    auto result = tuple_concat(std::tuple<CopyCounting, CopyCounting>(CopyCounting(), CopyCounting()), std::tuple<CopyCounting>(CopyCounting()), std::tuple<CopyCounting>(CopyCounting()));
-    static_assert(std::is_same<std::tuple<CopyCounting, CopyCounting, CopyCounting, CopyCounting>, decltype(result)>::value, "");
-    EXPECT_EQ(0, std::get<0>(result).copy_count);
-    EXPECT_EQ(0, std::get<1>(result).copy_count);
-    EXPECT_EQ(0, std::get<2>(result).copy_count);
-    EXPECT_EQ(0, std::get<3>(result).copy_count);
-    EXPECT_EQ(2, std::get<0>(result).move_count);
-    EXPECT_EQ(2, std::get<1>(result).move_count);
-    EXPECT_EQ(2, std::get<2>(result).move_count);
-    EXPECT_EQ(2, std::get<3>(result).move_count);
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_zerotuples) {
+  auto result = tuple_concat();
+  static_assert(std::is_same<std::tuple<>, decltype(result)>::value, "");
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_oneemptytuple) {
+  auto result = tuple_concat(std::tuple<>());
+  static_assert(std::is_same<std::tuple<>, decltype(result)>::value, "");
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_onenonemptytuple) {
+  auto result = tuple_concat(std::tuple<int64_t>(3));
+  static_assert(std::is_same<std::tuple<int64_t>, decltype(result)>::value, "");
+  EXPECT_EQ(3, std::get<0>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_twotuples) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_concat(
+      std::tuple<int64_t, std::string>(3, "4"),
+      std::tuple<double, int16_t>(2.3, 15));
+  static_assert(
+      std::is_same<
+          std::tuple<int64_t, std::string, double, int16_t>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(3, std::get<0>(result));
+  EXPECT_EQ("4", std::get<1>(result));
+  EXPECT_EQ(2.3, std::get<2>(result));
+  EXPECT_EQ(15, std::get<3>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_threetuples) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_concat(
+      std::tuple<int64_t, std::string>(3, "4"),
+      std::tuple<double, int16_t>(2.3, 15),
+      std::tuple<std::string, float>("5", 3.2));
+  static_assert(
+      std::is_same<
+          std::tuple<int64_t, std::string, double, int16_t, std::string, float>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(3, std::get<0>(result));
+  EXPECT_EQ("4", std::get<1>(result));
+  EXPECT_EQ(2.3, std::get<2>(result));
+  EXPECT_EQ(15, std::get<3>(result));
+  EXPECT_EQ("5", std::get<4>(result));
+  EXPECT_EQ(static_cast<float>(3.2), std::get<5>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_emptytupleatbeginning) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_concat(
+      std::tuple<>(),
+      std::tuple<double, int16_t>(2.3, 15),
+      std::tuple<std::string, float>("5", 3.2));
+  static_assert(
+      std::is_same<
+          std::tuple<double, int16_t, std::string, float>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(2.3, std::get<0>(result));
+  EXPECT_EQ(15, std::get<1>(result));
+  EXPECT_EQ("5", std::get<2>(result));
+  EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_emptytupleinmiddle) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_concat(
+      std::tuple<double, int16_t>(2.3, 15),
+      std::tuple<>(),
+      std::tuple<std::string, float>("5", 3.2));
+  static_assert(
+      std::is_same<
+          std::tuple<double, int16_t, std::string, float>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(2.3, std::get<0>(result));
+  EXPECT_EQ(15, std::get<1>(result));
+  EXPECT_EQ("5", std::get<2>(result));
+  EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_emptytupleatend) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto result = tuple_concat(
+      std::tuple<double, int16_t>(2.3, 15),
+      std::tuple<std::string, float>("5", 3.2),
+      std::tuple<>());
+  static_assert(
+      std::is_same<
+          std::tuple<double, int16_t, std::string, float>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(2.3, std::get<0>(result));
+  EXPECT_EQ(15, std::get<1>(result));
+  EXPECT_EQ("5", std::get<2>(result));
+  EXPECT_EQ(static_cast<float>(3.2), std::get<3>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_workswithreferencesandpointers) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  double val1 = 2.3;
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  int16_t val2 = 15;
+  std::string val3 = "hello";
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float val4 = 3.2;
+  auto result = tuple_concat(
+      std::tuple<double&, const int16_t&>(val1, val2),
+      std::tuple<std::string&&, float*>(std::move(val3), &val4));
+  static_assert(
+      std::is_same<
+          std::tuple<double&, const int16_t&, std::string&&, float*>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(2.3, std::get<0>(result));
+  EXPECT_EQ(&val1, &std::get<0>(result));
+  EXPECT_EQ(15, std::get<1>(result));
+  EXPECT_EQ(&val2, &std::get<1>(result));
+  EXPECT_EQ("hello", std::get<2>(result));
+  EXPECT_EQ(&val3, &std::get<2>(result));
+  EXPECT_EQ(static_cast<float>(3.2), *std::get<3>(result));
+  EXPECT_EQ(&val4, std::get<3>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_worksWithMovableOnlyTypes) {
+  auto result = tuple_concat(
+      std::tuple<MovableOnly, MovableOnly>(1, 2), std::tuple<MovableOnly>(3));
+  static_assert(
+      std::is_same<
+          std::tuple<MovableOnly, MovableOnly, MovableOnly>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(MovableOnly(1), std::get<0>(result));
+  EXPECT_EQ(MovableOnly(2), std::get<1>(result));
+  EXPECT_EQ(MovableOnly(3), std::get<2>(result));
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(MetaprogrammingTest, TupleConcat_doesntCopyMoreThanNecessary) {
+  auto result = tuple_concat(
+      std::tuple<CopyCounting, CopyCounting>(CopyCounting(), CopyCounting()),
+      std::tuple<CopyCounting>(CopyCounting()),
+      std::tuple<CopyCounting>(CopyCounting()));
+  static_assert(
+      std::is_same<
+          std::tuple<CopyCounting, CopyCounting, CopyCounting, CopyCounting>,
+          decltype(result)>::value,
+      "");
+  EXPECT_EQ(0, std::get<0>(result).copy_count);
+  EXPECT_EQ(0, std::get<1>(result).copy_count);
+  EXPECT_EQ(0, std::get<2>(result).copy_count);
+  EXPECT_EQ(0, std::get<3>(result).copy_count);
+  EXPECT_EQ(2, std::get<0>(result).move_count);
+  EXPECT_EQ(2, std::get<1>(result).move_count);
+  EXPECT_EQ(2, std::get<2>(result).move_count);
+  EXPECT_EQ(2, std::get<3>(result).move_count);
+}
+} // namespace test_tuple_concat
+
 namespace test_concat_iseq {
-  using std::index_sequence;
-  using std::integer_sequence;
-  static_assert(std::is_same<index_sequence<>, concat_iseq_t<>>::value, "");
-  static_assert(std::is_same<index_sequence<>, concat_iseq_t<index_sequence<>>>::value, "");
-  static_assert(std::is_same<index_sequence<>, concat_iseq_t<index_sequence<>, index_sequence<>>>::value, "");
-  static_assert(std::is_same<index_sequence<4>, concat_iseq_t<index_sequence<4>>>::value, "");
-  static_assert(std::is_same<index_sequence<4>, concat_iseq_t<index_sequence<4>, index_sequence<>>>::value, "");
-  static_assert(std::is_same<index_sequence<4>, concat_iseq_t<index_sequence<>, index_sequence<4>>>::value, "");
-  static_assert(std::is_same<index_sequence<4>, concat_iseq_t<index_sequence<>, index_sequence<4>, index_sequence<>>>::value, "");
-  static_assert(std::is_same<index_sequence<4, 2>, concat_iseq_t<index_sequence<4>, index_sequence<2>>>::value, "");
-  static_assert(std::is_same<index_sequence<4, 2>, concat_iseq_t<index_sequence<>, index_sequence<4, 2>, index_sequence<>>>::value, "");
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-  static_assert(std::is_same<index_sequence<4, 2, 9>, concat_iseq_t<index_sequence<>, index_sequence<4, 2>, index_sequence<9>>>::value, "");
+using std::index_sequence;
+using std::integer_sequence;
+static_assert(std::is_same<index_sequence<>, concat_iseq_t<>>::value, "");
+static_assert(
+    std::is_same<index_sequence<>, concat_iseq_t<index_sequence<>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<>,
+        concat_iseq_t<index_sequence<>, index_sequence<>>>::value,
+    "");
+static_assert(
+    std::is_same<index_sequence<4>, concat_iseq_t<index_sequence<4>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<4>,
+        concat_iseq_t<index_sequence<4>, index_sequence<>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<4>,
+        concat_iseq_t<index_sequence<>, index_sequence<4>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<4>,
+        concat_iseq_t<index_sequence<>, index_sequence<4>, index_sequence<>>>::
+        value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<4, 2>,
+        concat_iseq_t<index_sequence<4>, index_sequence<2>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        index_sequence<4, 2>,
+        concat_iseq_t<
+            index_sequence<>,
+            index_sequence<4, 2>,
+            index_sequence<>>>::value,
+    "");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+static_assert(
+    std::is_same<
+        index_sequence<4, 2, 9>,
+        concat_iseq_t<
+            index_sequence<>,
+            index_sequence<4, 2>,
+            index_sequence<9>>>::value,
+    "");
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-  static_assert(std::is_same<integer_sequence<int8_t, -5, -3>, concat_iseq_t<integer_sequence<int8_t, -5>, integer_sequence<int8_t, -3>>>::value, "");
-}
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+static_assert(
+    std::is_same<
+        integer_sequence<int8_t, -5, -3>,
+        concat_iseq_t<
+            integer_sequence<int8_t, -5>,
+            integer_sequence<int8_t, -3>>>::value,
+    "");
+} // namespace test_concat_iseq
 
-
-}
+} // namespace
diff --git a/c10/test/util/TypeIndex_test.cpp b/c10/test/util/TypeIndex_test.cpp
index 085be909113..2f0c757a8a3 100644
--- a/c10/test/util/TypeIndex_test.cpp
+++ b/c10/test/util/TypeIndex_test.cpp
@@ -61,12 +61,10 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, TopLevelName) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Dummy>().find("Dummy")
-    );
-}
+  EXPECT_NE(
+      string_view::npos, get_fully_qualified_type_name<Dummy>().find("Dummy"));
 }
+} // namespace test_top_level_name
 
 namespace test_nested_name {
 struct Dummy final {};
@@ -79,10 +77,9 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, NestedName) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Dummy>().find("test_nested_name::Dummy")
-    );
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<Dummy>().find("test_nested_name::Dummy"));
 }
 } // namespace test_nested_name
 
@@ -105,16 +102,14 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, TypeTemplateParameter) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Outer<Inner>>().find(
-            "test_type_template_parameter::Outer")
-    );
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Outer<Inner>>().find(
-            "test_type_template_parameter::Inner")
-    );
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<Outer<Inner>>().find(
+          "test_type_template_parameter::Outer"));
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<Outer<Inner>>().find(
+          "test_type_template_parameter::Inner"));
 }
 } // namespace test_type_template_parameter
 
@@ -131,10 +126,9 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, NonTypeTemplateParameter) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Class<38474355>>().find("38474355")
-    );
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<Class<38474355>>().find("38474355"));
 }
 } // namespace test_nontype_template_parameter
 
@@ -164,21 +158,18 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, TypeComputationsAreResolved) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<typename Type<int>::type>().find("int")
-    );
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<typename Type<int>::type>().find("*")
-    );
-    // but with remove_pointer applied, there is no '*' in the type name anymore
-    EXPECT_EQ(
-        string_view::npos,
-        get_fully_qualified_type_name<
-            typename std::remove_pointer<typename Type<int>::type>::type>()
-            .find("*")
-    );
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<typename Type<int>::type>().find("int"));
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<typename Type<int>::type>().find("*"));
+  // but with remove_pointer applied, there is no '*' in the type name anymore
+  EXPECT_EQ(
+      string_view::npos,
+      get_fully_qualified_type_name<
+          typename std::remove_pointer<typename Type<int>::type>::type>()
+          .find("*"));
 }
 
 struct Functor final {
@@ -193,11 +184,10 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, FunctionTypeComputationsAreResolved) {
-    EXPECT_EQ(
-        get_fully_qualified_type_name<std::string(int64_t, const Type<int>&)>(),
-        get_fully_qualified_type_name<
-            typename c10::guts::infer_function_traits_t<Functor>::func_type>()
-    );
+  EXPECT_EQ(
+      get_fully_qualified_type_name<std::string(int64_t, const Type<int>&)>(),
+      get_fully_qualified_type_name<
+          typename c10::guts::infer_function_traits_t<Functor>::func_type>());
 }
 } // namespace test_type_computations_are_resolved
 
@@ -218,16 +208,14 @@ static_assert(
 #endif
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(TypeIndex, FunctionArgumentsAndReturns) {
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<Dummy(int)>().find(
-            "test_function_arguments_and_returns::Dummy")
-    );
-    EXPECT_NE(
-        string_view::npos,
-        get_fully_qualified_type_name<void(Dummy)>().find(
-            "test_function_arguments_and_returns::Dummy")
-    );
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<Dummy(int)>().find(
+          "test_function_arguments_and_returns::Dummy"));
+  EXPECT_NE(
+      string_view::npos,
+      get_fully_qualified_type_name<void(Dummy)>().find(
+          "test_function_arguments_and_returns::Dummy"));
 }
 } // namespace test_function_arguments_and_returns
 } // namespace
diff --git a/c10/test/util/TypeList_test.cpp b/c10/test/util/TypeList_test.cpp
index f1468e824bf..0b38aeb3862 100644
--- a/c10/test/util/TypeList_test.cpp
+++ b/c10/test/util/TypeList_test.cpp
@@ -5,204 +5,382 @@
 using namespace c10::guts::typelist;
 
 namespace test_size {
-    class MyClass {};
-    static_assert(0 == size<typelist<>>::value, "");
-    static_assert(1 == size<typelist<int>>::value, "");
-    static_assert(3 == size<typelist<int, float&, const MyClass&&>>::value, "");
-}
+class MyClass {};
+static_assert(0 == size<typelist<>>::value, "");
+static_assert(1 == size<typelist<int>>::value, "");
+static_assert(3 == size<typelist<int, float&, const MyClass&&>>::value, "");
+} // namespace test_size
 
 namespace test_from_tuple {
-    class MyClass {};
-    static_assert(std::is_same<typelist<int, float&, const MyClass&&>, from_tuple_t<std::tuple<int, float&, const MyClass&&>>>::value, "");
-    static_assert(std::is_same<typelist<>, from_tuple_t<std::tuple<>>>::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<
+        typelist<int, float&, const MyClass&&>,
+        from_tuple_t<std::tuple<int, float&, const MyClass&&>>>::value,
+    "");
+static_assert(std::is_same<typelist<>, from_tuple_t<std::tuple<>>>::value, "");
+} // namespace test_from_tuple
 
 namespace test_to_tuple {
-    class MyClass {};
-    static_assert(std::is_same<std::tuple<int, float&, const MyClass&&>, to_tuple_t<typelist<int, float&, const MyClass&&>>>::value, "");
-    static_assert(std::is_same<std::tuple<>, to_tuple_t<typelist<>>>::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<
+        std::tuple<int, float&, const MyClass&&>,
+        to_tuple_t<typelist<int, float&, const MyClass&&>>>::value,
+    "");
+static_assert(std::is_same<std::tuple<>, to_tuple_t<typelist<>>>::value, "");
+} // namespace test_to_tuple
 
 namespace test_concat {
-    class MyClass {};
-    static_assert(std::is_same<typelist<>, concat_t<>>::value, "");
-    static_assert(std::is_same<typelist<>, concat_t<typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<>, concat_t<typelist<>, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<int>, concat_t<typelist<int>>>::value, "");
-    static_assert(std::is_same<typelist<int>, concat_t<typelist<int>, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<int>, concat_t<typelist<>, typelist<int>>>::value, "");
-    static_assert(std::is_same<typelist<int>, concat_t<typelist<>, typelist<int>, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<int, float&>, concat_t<typelist<int>, typelist<float&>>>::value, "");
-    static_assert(std::is_same<typelist<int, float&>, concat_t<typelist<>, typelist<int, float&>, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<int, float&, const MyClass&&>, concat_t<typelist<>, typelist<int, float&>, typelist<const MyClass&&>>>::value, "");
-}
+class MyClass {};
+static_assert(std::is_same<typelist<>, concat_t<>>::value, "");
+static_assert(std::is_same<typelist<>, concat_t<typelist<>>>::value, "");
+static_assert(
+    std::is_same<typelist<>, concat_t<typelist<>, typelist<>>>::value,
+    "");
+static_assert(std::is_same<typelist<int>, concat_t<typelist<int>>>::value, "");
+static_assert(
+    std::is_same<typelist<int>, concat_t<typelist<int>, typelist<>>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<int>, concat_t<typelist<>, typelist<int>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int>,
+        concat_t<typelist<>, typelist<int>, typelist<>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int, float&>,
+        concat_t<typelist<int>, typelist<float&>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int, float&>,
+        concat_t<typelist<>, typelist<int, float&>, typelist<>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int, float&, const MyClass&&>,
+        concat_t<
+            typelist<>,
+            typelist<int, float&>,
+            typelist<const MyClass&&>>>::value,
+    "");
+} // namespace test_concat
 
 namespace test_filter {
-    class MyClass {};
-    static_assert(std::is_same<typelist<>, filter_t<std::is_reference, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<>, filter_t<std::is_reference, typelist<int, float, double, MyClass>>>::value, "");
-    static_assert(std::is_same<typelist<float&, const MyClass&&>, filter_t<std::is_reference, typelist<int, float&, double, const MyClass&&>>>::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<typelist<>, filter_t<std::is_reference, typelist<>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<>,
+        filter_t<std::is_reference, typelist<int, float, double, MyClass>>>::
+        value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<float&, const MyClass&&>,
+        filter_t<
+            std::is_reference,
+            typelist<int, float&, double, const MyClass&&>>>::value,
+    "");
+} // namespace test_filter
 
 namespace test_count_if {
-    class MyClass final {};
-    static_assert(count_if<std::is_reference, typelist<int, bool&, const MyClass&&, float, double>>::value == 2, "");
-    static_assert(count_if<std::is_reference, typelist<int, bool>>::value == 0, "");
-    static_assert(count_if<std::is_reference, typelist<>>::value == 0, "");
-}
+class MyClass final {};
+static_assert(
+    count_if<
+        std::is_reference,
+        typelist<int, bool&, const MyClass&&, float, double>>::value == 2,
+    "");
+static_assert(count_if<std::is_reference, typelist<int, bool>>::value == 0, "");
+static_assert(count_if<std::is_reference, typelist<>>::value == 0, "");
+} // namespace test_count_if
 
 namespace test_true_for_each_type {
-    template<class> class Test;
-    class MyClass {};
-    static_assert(all<std::is_reference, typelist<int&, const float&&, const MyClass&>>::value, "");
-    static_assert(!all<std::is_reference, typelist<int&, const float, const MyClass&>>::value, "");
-    static_assert(all<std::is_reference, typelist<>>::value, "");
-}
+template <class>
+class Test;
+class MyClass {};
+static_assert(
+    all<std::is_reference,
+        typelist<int&, const float&&, const MyClass&>>::value,
+    "");
+static_assert(
+    !all<std::is_reference, typelist<int&, const float, const MyClass&>>::value,
+    "");
+static_assert(all<std::is_reference, typelist<>>::value, "");
+} // namespace test_true_for_each_type
 
 namespace test_true_for_any_type {
-    template<class> class Test;
-    class MyClass {};
-    static_assert(true_for_any_type<std::is_reference, typelist<int&, const float&&, const MyClass&>>::value, "");
-    static_assert(true_for_any_type<std::is_reference, typelist<int&, const float, const MyClass&>>::value, "");
-    static_assert(!true_for_any_type<std::is_reference, typelist<int, const float, const MyClass>>::value, "");
-    static_assert(!true_for_any_type<std::is_reference, typelist<>>::value, "");
-}
+template <class>
+class Test;
+class MyClass {};
+static_assert(
+    true_for_any_type<
+        std::is_reference,
+        typelist<int&, const float&&, const MyClass&>>::value,
+    "");
+static_assert(
+    true_for_any_type<
+        std::is_reference,
+        typelist<int&, const float, const MyClass&>>::value,
+    "");
+static_assert(
+    !true_for_any_type<
+        std::is_reference,
+        typelist<int, const float, const MyClass>>::value,
+    "");
+static_assert(!true_for_any_type<std::is_reference, typelist<>>::value, "");
+} // namespace test_true_for_any_type
 
 namespace test_map {
-    class MyClass {};
-    static_assert(std::is_same<typelist<>, map_t<std::add_lvalue_reference_t, typelist<>>>::value, "");
-    static_assert(std::is_same<typelist<int&>, map_t<std::add_lvalue_reference_t, typelist<int>>>::value, "");
-    static_assert(std::is_same<typelist<int&, double&, const MyClass&>, map_t<std::add_lvalue_reference_t, typelist<int, double, const MyClass>>>::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<typelist<>, map_t<std::add_lvalue_reference_t, typelist<>>>::
+        value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int&>,
+        map_t<std::add_lvalue_reference_t, typelist<int>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int&, double&, const MyClass&>,
+        map_t<
+            std::add_lvalue_reference_t,
+            typelist<int, double, const MyClass>>>::value,
+    "");
+} // namespace test_map
 
 namespace test_head {
-    class MyClass {};
-    static_assert(std::is_same<int, head_t<typelist<int, double>>>::value, "");
-    static_assert(std::is_same<const MyClass&, head_t<typelist<const MyClass&, double>>>::value, "");
-    static_assert(std::is_same<MyClass&&, head_t<typelist<MyClass&&, MyClass>>>::value, "");
-    static_assert(std::is_same<bool, head_t<typelist<bool>>>::value, "");
-}
+class MyClass {};
+static_assert(std::is_same<int, head_t<typelist<int, double>>>::value, "");
+static_assert(
+    std::is_same<const MyClass&, head_t<typelist<const MyClass&, double>>>::
+        value,
+    "");
+static_assert(
+    std::is_same<MyClass&&, head_t<typelist<MyClass&&, MyClass>>>::value,
+    "");
+static_assert(std::is_same<bool, head_t<typelist<bool>>>::value, "");
+} // namespace test_head
 
 namespace test_head_with_default {
-    class MyClass {};
-    static_assert(std::is_same<int, head_with_default_t<bool, typelist<int, double>>>::value, "");
-    static_assert(std::is_same<const MyClass&, head_with_default_t<bool, typelist<const MyClass&, double>>>::value, "");
-    static_assert(std::is_same<MyClass&&, head_with_default_t<bool, typelist<MyClass&&, MyClass>>>::value, "");
-    static_assert(std::is_same<int, head_with_default_t<bool, typelist<int>>>::value, "");
-    static_assert(std::is_same<bool, head_with_default_t<bool, typelist<>>>::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<int, head_with_default_t<bool, typelist<int, double>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        const MyClass&,
+        head_with_default_t<bool, typelist<const MyClass&, double>>>::value,
+    "");
+static_assert(
+    std::is_same<
+        MyClass&&,
+        head_with_default_t<bool, typelist<MyClass&&, MyClass>>>::value,
+    "");
+static_assert(
+    std::is_same<int, head_with_default_t<bool, typelist<int>>>::value,
+    "");
+static_assert(
+    std::is_same<bool, head_with_default_t<bool, typelist<>>>::value,
+    "");
+} // namespace test_head_with_default
 
 namespace test_reverse {
-    class MyClass {};
-    static_assert(std::is_same<
-            typelist<int, double, MyClass*, const MyClass&&>,
-            reverse_t<typelist<const MyClass&&, MyClass*, double, int>>
-    >::value, "");
-    static_assert(std::is_same<
-            typelist<>,
-            reverse_t<typelist<>>
-    >::value, "");
-}
+class MyClass {};
+static_assert(
+    std::is_same<
+        typelist<int, double, MyClass*, const MyClass&&>,
+        reverse_t<typelist<const MyClass&&, MyClass*, double, int>>>::value,
+    "");
+static_assert(std::is_same<typelist<>, reverse_t<typelist<>>>::value, "");
+} // namespace test_reverse
 
 namespace test_map_types_to_values {
-    struct map_to_size {
-      template<class T> constexpr size_t operator()(T) const {return sizeof(typename T::type);}
-    };
+struct map_to_size {
+  template <class T>
+  constexpr size_t operator()(T) const {
+    return sizeof(typename T::type);
+  }
+};
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(TypeListTest, MapTypesToValues_sametype) {
-        auto sizes =
-            map_types_to_values<typelist<int64_t, bool, uint32_t>>(map_to_size());
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        std::tuple<size_t, size_t, size_t> expected(8, 1, 4);
-        static_assert(std::is_same<decltype(expected), decltype(sizes)>::value, "");
-        EXPECT_EQ(expected, sizes);
-    }
-
-    struct map_make_shared {
-      template<class T> std::shared_ptr<typename T::type> operator()(T) {
-        return std::make_shared<typename T::type>();
-      }
-    };
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(TypeListTest, MapTypesToValues_differenttypes) {
-        auto shared_ptrs =
-                map_types_to_values<typelist<int, double>>(map_make_shared());
-        static_assert(std::is_same<std::tuple<std::shared_ptr<int>, std::shared_ptr<double>>, decltype(shared_ptrs)>::value, "");
-    }
-
-    struct Class1 {static int func() {return 3;}};
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    struct Class2 {static double func() {return 2.0;}};
-
-    struct mapper_call_func {
-      template<class T> decltype(auto) operator()(T) { return T::type::func(); }
-    };
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(TypeListTest, MapTypesToValues_members) {
-        auto result =
-                map_types_to_values<typelist<Class1, Class2>>(mapper_call_func());
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        std::tuple<int, double> expected(3, 2.0);
-        static_assert(std::is_same<decltype(expected), decltype(result)>::value, "");
-        EXPECT_EQ(expected, result);
-    }
-
-    struct mapper_call_nonexistent_function {
-      template<class T> decltype(auto) operator()(T) { return T::type::this_doesnt_exist(); }
-    };
-
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    TEST(TypeListTest, MapTypesToValues_empty) {
-        auto result =
-                map_types_to_values<typelist<>>(mapper_call_nonexistent_function());
-        std::tuple<> expected;
-        static_assert(std::is_same<decltype(expected), decltype(result)>::value, "");
-        EXPECT_EQ(expected, result);
-    }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(TypeListTest, MapTypesToValues_sametype) {
+  auto sizes =
+      map_types_to_values<typelist<int64_t, bool, uint32_t>>(map_to_size());
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  std::tuple<size_t, size_t, size_t> expected(8, 1, 4);
+  static_assert(std::is_same<decltype(expected), decltype(sizes)>::value, "");
+  EXPECT_EQ(expected, sizes);
 }
 
+struct map_make_shared {
+  template <class T>
+  std::shared_ptr<typename T::type> operator()(T) {
+    return std::make_shared<typename T::type>();
+  }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(TypeListTest, MapTypesToValues_differenttypes) {
+  auto shared_ptrs =
+      map_types_to_values<typelist<int, double>>(map_make_shared());
+  static_assert(
+      std::is_same<
+          std::tuple<std::shared_ptr<int>, std::shared_ptr<double>>,
+          decltype(shared_ptrs)>::value,
+      "");
+}
+
+struct Class1 {
+  static int func() {
+    return 3;
+  }
+};
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+struct Class2 {
+  static double func() {
+    return 2.0;
+  }
+};
+
+struct mapper_call_func {
+  template <class T>
+  decltype(auto) operator()(T) {
+    return T::type::func();
+  }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(TypeListTest, MapTypesToValues_members) {
+  auto result =
+      map_types_to_values<typelist<Class1, Class2>>(mapper_call_func());
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  std::tuple<int, double> expected(3, 2.0);
+  static_assert(std::is_same<decltype(expected), decltype(result)>::value, "");
+  EXPECT_EQ(expected, result);
+}
+
+struct mapper_call_nonexistent_function {
+  template <class T>
+  decltype(auto) operator()(T) {
+    return T::type::this_doesnt_exist();
+  }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(TypeListTest, MapTypesToValues_empty) {
+  auto result =
+      map_types_to_values<typelist<>>(mapper_call_nonexistent_function());
+  std::tuple<> expected;
+  static_assert(std::is_same<decltype(expected), decltype(result)>::value, "");
+  EXPECT_EQ(expected, result);
+}
+} // namespace test_map_types_to_values
+
 namespace test_find_if {
-  static_assert(0 == find_if<typelist<char&>, std::is_reference>::value, "");
-  static_assert(0 == find_if<typelist<char&, int, char&, int&>, std::is_reference>::value, "");
-  static_assert(2 == find_if<typelist<char, int, char&, int&>, std::is_reference>::value, "");
-  static_assert(3 == find_if<typelist<char, int, char, int&>, std::is_reference>::value, "");
-}
+static_assert(0 == find_if<typelist<char&>, std::is_reference>::value, "");
+static_assert(
+    0 == find_if<typelist<char&, int, char&, int&>, std::is_reference>::value,
+    "");
+static_assert(
+    2 == find_if<typelist<char, int, char&, int&>, std::is_reference>::value,
+    "");
+static_assert(
+    3 == find_if<typelist<char, int, char, int&>, std::is_reference>::value,
+    "");
+} // namespace test_find_if
 
 namespace test_contains {
-  static_assert(contains<typelist<double>, double>::value, "");
-  static_assert(contains<typelist<int, double>, double>::value, "");
-  static_assert(!contains<typelist<int, double>, float>::value, "");
-  static_assert(!contains<typelist<>, double>::value, "");
-}
+static_assert(contains<typelist<double>, double>::value, "");
+static_assert(contains<typelist<int, double>, double>::value, "");
+static_assert(!contains<typelist<int, double>, float>::value, "");
+static_assert(!contains<typelist<>, double>::value, "");
+} // namespace test_contains
 
 namespace test_take {
-    static_assert(std::is_same<typelist<>, take_t<typelist<>, 0>>::value, "");
-    static_assert(std::is_same<typelist<>, take_t<typelist<int64_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int64_t>, take_t<typelist<int64_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<>, take_t<typelist<int64_t, int32_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int64_t>, take_t<typelist<int64_t, int32_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<int64_t, int32_t>, take_t<typelist<int64_t, int32_t>, 2>>::value, "");
-}
+static_assert(std::is_same<typelist<>, take_t<typelist<>, 0>>::value, "");
+static_assert(
+    std::is_same<typelist<>, take_t<typelist<int64_t>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<int64_t>, take_t<typelist<int64_t>, 1>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<>, take_t<typelist<int64_t, int32_t>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<int64_t>, take_t<typelist<int64_t, int32_t>, 1>>::
+        value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int64_t, int32_t>,
+        take_t<typelist<int64_t, int32_t>, 2>>::value,
+    "");
+} // namespace test_take
 
 namespace test_drop {
-    static_assert(std::is_same<typelist<>, drop_t<typelist<>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int64_t>, drop_t<typelist<int64_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_t<typelist<int64_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<int64_t, int32_t>, drop_t<typelist<int64_t, int32_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int32_t>, drop_t<typelist<int64_t, int32_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_t<typelist<int64_t, int32_t>, 2>>::value, "");
-}
+static_assert(std::is_same<typelist<>, drop_t<typelist<>, 0>>::value, "");
+static_assert(
+    std::is_same<typelist<int64_t>, drop_t<typelist<int64_t>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<>, drop_t<typelist<int64_t>, 1>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int64_t, int32_t>,
+        drop_t<typelist<int64_t, int32_t>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<int32_t>, drop_t<typelist<int64_t, int32_t>, 1>>::
+        value,
+    "");
+static_assert(
+    std::is_same<typelist<>, drop_t<typelist<int64_t, int32_t>, 2>>::value,
+    "");
+} // namespace test_drop
 
 namespace test_drop_if_nonempty {
-    static_assert(std::is_same<typelist<>, drop_if_nonempty_t<typelist<>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int64_t>, drop_if_nonempty_t<typelist<int64_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_if_nonempty_t<typelist<int64_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<int64_t, int32_t>, drop_if_nonempty_t<typelist<int64_t, int32_t>, 0>>::value, "");
-    static_assert(std::is_same<typelist<int32_t>, drop_if_nonempty_t<typelist<int64_t, int32_t>, 1>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_if_nonempty_t<typelist<int64_t, int32_t>, 2>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_if_nonempty_t<typelist<>, 1>>::value, "");
-    static_assert(std::is_same<typelist<>, drop_if_nonempty_t<typelist<int64_t, int32_t>, 3>>::value, "");
-}
+static_assert(
+    std::is_same<typelist<>, drop_if_nonempty_t<typelist<>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<int64_t>, drop_if_nonempty_t<typelist<int64_t>, 0>>::
+        value,
+    "");
+static_assert(
+    std::is_same<typelist<>, drop_if_nonempty_t<typelist<int64_t>, 1>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int64_t, int32_t>,
+        drop_if_nonempty_t<typelist<int64_t, int32_t>, 0>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<int32_t>,
+        drop_if_nonempty_t<typelist<int64_t, int32_t>, 1>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<>,
+        drop_if_nonempty_t<typelist<int64_t, int32_t>, 2>>::value,
+    "");
+static_assert(
+    std::is_same<typelist<>, drop_if_nonempty_t<typelist<>, 1>>::value,
+    "");
+static_assert(
+    std::is_same<
+        typelist<>,
+        drop_if_nonempty_t<typelist<int64_t, int32_t>, 3>>::value,
+    "");
+} // namespace test_drop_if_nonempty
diff --git a/c10/test/util/TypeTraits_test.cpp b/c10/test/util/TypeTraits_test.cpp
index 580f6cacfd6..356b4758564 100644
--- a/c10/test/util/TypeTraits_test.cpp
+++ b/c10/test/util/TypeTraits_test.cpp
@@ -6,152 +6,190 @@ using namespace c10::guts;
 namespace {
 
 namespace test_is_equality_comparable {
-    class NotEqualityComparable {};
-    class EqualityComparable {};
+class NotEqualityComparable {};
+class EqualityComparable {};
 
-    inline bool operator==(const EqualityComparable &, const EqualityComparable &) { return false; }
-
-    static_assert(!is_equality_comparable<NotEqualityComparable>::value, "");
-    static_assert(is_equality_comparable<EqualityComparable>::value, "");
-    static_assert(is_equality_comparable<int>::value, "");
-
-    // v_ just exists to silence a compiler warning about operator==(EqualityComparable, EqualityComparable) not being needed
-    const bool v_ = EqualityComparable() == EqualityComparable();
+inline bool operator==(const EqualityComparable&, const EqualityComparable&) {
+  return false;
 }
 
+static_assert(!is_equality_comparable<NotEqualityComparable>::value, "");
+static_assert(is_equality_comparable<EqualityComparable>::value, "");
+static_assert(is_equality_comparable<int>::value, "");
+
+// v_ just exists to silence a compiler warning about
+// operator==(EqualityComparable, EqualityComparable) not being needed
+const bool v_ = EqualityComparable() == EqualityComparable();
+} // namespace test_is_equality_comparable
+
 namespace test_is_hashable {
-    class NotHashable {};
-    class Hashable {};
-}
-}
+class NotHashable {};
+class Hashable {};
+} // namespace test_is_hashable
+} // namespace
 namespace std {
-    template<> struct hash<test_is_hashable::Hashable> final {
-        size_t operator()(const test_is_hashable::Hashable &) { return 0; }
-    };
-}
+template <>
+struct hash<test_is_hashable::Hashable> final {
+  size_t operator()(const test_is_hashable::Hashable&) {
+    return 0;
+  }
+};
+} // namespace std
 namespace {
 namespace test_is_hashable {
-    static_assert(is_hashable<int>::value, "");
-    static_assert(is_hashable<Hashable>::value, "");
-    static_assert(!is_hashable<NotHashable>::value, "");
-}
+static_assert(is_hashable<int>::value, "");
+static_assert(is_hashable<Hashable>::value, "");
+static_assert(!is_hashable<NotHashable>::value, "");
+} // namespace test_is_hashable
 
 namespace test_is_function_type {
-    class MyClass {};
-    struct Functor {
-        void operator()() {}
-    };
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    auto lambda = [] () {};
-    // func() and func__ just exists to silence a compiler warning about lambda being unused
-    bool func() {
-        lambda();
-        return true;
-    }
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    bool func__ = func();
-
-    static_assert(is_function_type<void()>::value, "");
-    static_assert(is_function_type<int()>::value, "");
-    static_assert(is_function_type<MyClass()>::value, "");
-    static_assert(is_function_type<void(MyClass)>::value, "");
-    static_assert(is_function_type<void(int)>::value, "");
-    static_assert(is_function_type<void(void*)>::value, "");
-    static_assert(is_function_type<int()>::value, "");
-    static_assert(is_function_type<int(MyClass)>::value, "");
-    static_assert(is_function_type<int(const MyClass&)>::value, "");
-    static_assert(is_function_type<int(MyClass&&)>::value, "");
-    static_assert(is_function_type<MyClass&&()>::value, "");
-    static_assert(is_function_type<MyClass&&(MyClass&&)>::value, "");
-    static_assert(is_function_type<const MyClass&(int, float, MyClass)>::value, "");
-
-    static_assert(!is_function_type<void>::value, "");
-    static_assert(!is_function_type<int>::value, "");
-    static_assert(!is_function_type<MyClass>::value, "");
-    static_assert(!is_function_type<void*>::value, "");
-    static_assert(!is_function_type<const MyClass&>::value, "");
-    static_assert(!is_function_type<MyClass&&>::value, "");
-
-    static_assert(!is_function_type<void (*)()>::value, "function pointers aren't plain functions");
-    static_assert(!is_function_type<Functor>::value, "Functors aren't plain functions");
-    static_assert(!is_function_type<decltype(lambda)>::value, "Lambdas aren't plain functions");
+class MyClass {};
+struct Functor {
+  void operator()() {}
+};
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+auto lambda = []() {};
+// func() and func__ just exists to silence a compiler warning about lambda
+// being unused
+bool func() {
+  lambda();
+  return true;
 }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+bool func__ = func();
+
+static_assert(is_function_type<void()>::value, "");
+static_assert(is_function_type<int()>::value, "");
+static_assert(is_function_type<MyClass()>::value, "");
+static_assert(is_function_type<void(MyClass)>::value, "");
+static_assert(is_function_type<void(int)>::value, "");
+static_assert(is_function_type<void(void*)>::value, "");
+static_assert(is_function_type<int()>::value, "");
+static_assert(is_function_type<int(MyClass)>::value, "");
+static_assert(is_function_type<int(const MyClass&)>::value, "");
+static_assert(is_function_type<int(MyClass&&)>::value, "");
+static_assert(is_function_type < MyClass && () > ::value, "");
+static_assert(is_function_type < MyClass && (MyClass &&) > ::value, "");
+static_assert(is_function_type<const MyClass&(int, float, MyClass)>::value, "");
+
+static_assert(!is_function_type<void>::value, "");
+static_assert(!is_function_type<int>::value, "");
+static_assert(!is_function_type<MyClass>::value, "");
+static_assert(!is_function_type<void*>::value, "");
+static_assert(!is_function_type<const MyClass&>::value, "");
+static_assert(!is_function_type<MyClass&&>::value, "");
+
+static_assert(
+    !is_function_type<void (*)()>::value,
+    "function pointers aren't plain functions");
+static_assert(
+    !is_function_type<Functor>::value,
+    "Functors aren't plain functions");
+static_assert(
+    !is_function_type<decltype(lambda)>::value,
+    "Lambdas aren't plain functions");
+} // namespace test_is_function_type
 
 namespace test_is_instantiation_of {
-    class MyClass {};
-    template<class T> class Single {};
-    template<class T1, class T2> class Double {};
-    template<class... T> class Multiple {};
+class MyClass {};
+template <class T>
+class Single {};
+template <class T1, class T2>
+class Double {};
+template <class... T>
+class Multiple {};
 
-    static_assert(is_instantiation_of<Single, Single<void>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<MyClass>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<int>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<void*>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<int*>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<const MyClass&>>::value, "");
-    static_assert(is_instantiation_of<Single, Single<MyClass&&>>::value, "");
-    static_assert(is_instantiation_of<Double, Double<int, void>>::value, "");
-    static_assert(is_instantiation_of<Double, Double<const int&, MyClass*>>::value, "");
-    static_assert(is_instantiation_of<Multiple, Multiple<>>::value, "");
-    static_assert(is_instantiation_of<Multiple, Multiple<int>>::value, "");
-    static_assert(is_instantiation_of<Multiple, Multiple<MyClass&, int>>::value, "");
-    static_assert(is_instantiation_of<Multiple, Multiple<MyClass&, int, MyClass>>::value, "");
-    static_assert(is_instantiation_of<Multiple, Multiple<MyClass&, int, MyClass, void*>>::value, "");
+static_assert(is_instantiation_of<Single, Single<void>>::value, "");
+static_assert(is_instantiation_of<Single, Single<MyClass>>::value, "");
+static_assert(is_instantiation_of<Single, Single<int>>::value, "");
+static_assert(is_instantiation_of<Single, Single<void*>>::value, "");
+static_assert(is_instantiation_of<Single, Single<int*>>::value, "");
+static_assert(is_instantiation_of<Single, Single<const MyClass&>>::value, "");
+static_assert(is_instantiation_of<Single, Single<MyClass&&>>::value, "");
+static_assert(is_instantiation_of<Double, Double<int, void>>::value, "");
+static_assert(
+    is_instantiation_of<Double, Double<const int&, MyClass*>>::value,
+    "");
+static_assert(is_instantiation_of<Multiple, Multiple<>>::value, "");
+static_assert(is_instantiation_of<Multiple, Multiple<int>>::value, "");
+static_assert(
+    is_instantiation_of<Multiple, Multiple<MyClass&, int>>::value,
+    "");
+static_assert(
+    is_instantiation_of<Multiple, Multiple<MyClass&, int, MyClass>>::value,
+    "");
+static_assert(
+    is_instantiation_of<Multiple, Multiple<MyClass&, int, MyClass, void*>>::
+        value,
+    "");
 
-    static_assert(!is_instantiation_of<Single, Double<int, int>>::value, "");
-    static_assert(!is_instantiation_of<Single, Double<int, void>>::value, "");
-    static_assert(!is_instantiation_of<Single, Multiple<int>>::value, "");
-    static_assert(!is_instantiation_of<Double, Single<int>>::value, "");
-    static_assert(!is_instantiation_of<Double, Multiple<int, int>>::value, "");
-    static_assert(!is_instantiation_of<Double, Multiple<>>::value, "");
-    static_assert(!is_instantiation_of<Multiple, Double<int, int>>::value, "");
-    static_assert(!is_instantiation_of<Multiple, Single<int>>::value, "");
-}
+static_assert(!is_instantiation_of<Single, Double<int, int>>::value, "");
+static_assert(!is_instantiation_of<Single, Double<int, void>>::value, "");
+static_assert(!is_instantiation_of<Single, Multiple<int>>::value, "");
+static_assert(!is_instantiation_of<Double, Single<int>>::value, "");
+static_assert(!is_instantiation_of<Double, Multiple<int, int>>::value, "");
+static_assert(!is_instantiation_of<Double, Multiple<>>::value, "");
+static_assert(!is_instantiation_of<Multiple, Double<int, int>>::value, "");
+static_assert(!is_instantiation_of<Multiple, Single<int>>::value, "");
+} // namespace test_is_instantiation_of
 
 namespace test_is_type_condition {
-    template<class> class NotATypeCondition {};
-    static_assert(is_type_condition<std::is_reference>::value, "");
-    static_assert(!is_type_condition<NotATypeCondition>::value, "");
-}
-}
+template <class>
+class NotATypeCondition {};
+static_assert(is_type_condition<std::is_reference>::value, "");
+static_assert(!is_type_condition<NotATypeCondition>::value, "");
+} // namespace test_is_type_condition
+} // namespace
 
 namespace test_lambda_is_stateless {
-  template<class Result, class... Args>
-  struct MyStatelessFunctor final {
-    Result operator()(Args...) {}
-  };
+template <class Result, class... Args>
+struct MyStatelessFunctor final {
+  Result operator()(Args...) {}
+};
 
-  template<class Result, class... Args>
-  struct MyStatelessConstFunctor final {
-    Result operator()(Args...) const {}
-  };
+template <class Result, class... Args>
+struct MyStatelessConstFunctor final {
+  Result operator()(Args...) const {}
+};
 
-  void func() {
-    auto stateless_lambda = [] (int a) {return a;};
-    static_assert(is_stateless_lambda<decltype(stateless_lambda)>::value, "");
+void func() {
+  auto stateless_lambda = [](int a) { return a; };
+  static_assert(is_stateless_lambda<decltype(stateless_lambda)>::value, "");
 
-    int b = 4;
-    auto stateful_lambda_1 = [&] (int a) {return a + b;};
-    static_assert(!is_stateless_lambda<decltype(stateful_lambda_1)>::value, "");
+  int b = 4;
+  auto stateful_lambda_1 = [&](int a) { return a + b; };
+  static_assert(!is_stateless_lambda<decltype(stateful_lambda_1)>::value, "");
 
-    auto stateful_lambda_2 = [=] (int a) {return a + b;};
-    static_assert(!is_stateless_lambda<decltype(stateful_lambda_2)>::value, "");
+  auto stateful_lambda_2 = [=](int a) { return a + b; };
+  static_assert(!is_stateless_lambda<decltype(stateful_lambda_2)>::value, "");
 
-    auto stateful_lambda_3 = [b] (int a) {return a + b;};
-    static_assert(!is_stateless_lambda<decltype(stateful_lambda_3)>::value, "");
+  auto stateful_lambda_3 = [b](int a) { return a + b; };
+  static_assert(!is_stateless_lambda<decltype(stateful_lambda_3)>::value, "");
 
-    static_assert(!is_stateless_lambda<MyStatelessFunctor<int, int>>::value, "even if stateless, a functor is not a lambda, so it's false");
-    static_assert(!is_stateless_lambda<MyStatelessFunctor<void, int>>::value, "even if stateless, a functor is not a lambda, so it's false");
-    static_assert(!is_stateless_lambda<MyStatelessConstFunctor<int, int>>::value, "even if stateless, a functor is not a lambda, so it's false");
-    static_assert(!is_stateless_lambda<MyStatelessConstFunctor<void, int>>::value, "even if stateless, a functor is not a lambda, so it's false");
+  static_assert(
+      !is_stateless_lambda<MyStatelessFunctor<int, int>>::value,
+      "even if stateless, a functor is not a lambda, so it's false");
+  static_assert(
+      !is_stateless_lambda<MyStatelessFunctor<void, int>>::value,
+      "even if stateless, a functor is not a lambda, so it's false");
+  static_assert(
+      !is_stateless_lambda<MyStatelessConstFunctor<int, int>>::value,
+      "even if stateless, a functor is not a lambda, so it's false");
+  static_assert(
+      !is_stateless_lambda<MyStatelessConstFunctor<void, int>>::value,
+      "even if stateless, a functor is not a lambda, so it's false");
 
-    class Dummy final {};
-    static_assert(!is_stateless_lambda<Dummy>::value, "A non-functor type is also not a lambda");
+  class Dummy final {};
+  static_assert(
+      !is_stateless_lambda<Dummy>::value,
+      "A non-functor type is also not a lambda");
 
-    static_assert(!is_stateless_lambda<int>::value, "An int is not a lambda");
+  static_assert(!is_stateless_lambda<int>::value, "An int is not a lambda");
 
-    using Func = int(int);
-    static_assert(!is_stateless_lambda<Func>::value, "A function is not a lambda");
-    static_assert(!is_stateless_lambda<Func*>::value, "A function pointer is not a lambda");
-  }
+  using Func = int(int);
+  static_assert(
+      !is_stateless_lambda<Func>::value, "A function is not a lambda");
+  static_assert(
+      !is_stateless_lambda<Func*>::value, "A function pointer is not a lambda");
 }
+} // namespace test_lambda_is_stateless
diff --git a/c10/test/util/accumulate_test.cpp b/c10/test/util/accumulate_test.cpp
index 1b41aebc24f..02de9ea950b 100644
--- a/c10/test/util/accumulate_test.cpp
+++ b/c10/test/util/accumulate_test.cpp
@@ -11,70 +11,73 @@ using namespace ::testing;
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(accumulate_test, vector_test) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    std::vector<int> ints = {1, 2, 3, 4, 5};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  std::vector<int> ints = {1, 2, 3, 4, 5};
 
-    EXPECT_EQ(c10::sum_integers(ints), 1+2+3+4+5);
-    EXPECT_EQ(c10::multiply_integers(ints), 1*2*3*4*5);
+  EXPECT_EQ(c10::sum_integers(ints), 1 + 2 + 3 + 4 + 5);
+  EXPECT_EQ(c10::multiply_integers(ints), 1 * 2 * 3 * 4 * 5);
 
-    EXPECT_EQ(c10::sum_integers(ints.begin(), ints.end()), 1+2+3+4+5);
-    EXPECT_EQ(c10::multiply_integers(ints.begin(), ints.end()), 1*2*3*4*5);
+  EXPECT_EQ(c10::sum_integers(ints.begin(), ints.end()), 1 + 2 + 3 + 4 + 5);
+  EXPECT_EQ(
+      c10::multiply_integers(ints.begin(), ints.end()), 1 * 2 * 3 * 4 * 5);
 
-    EXPECT_EQ(c10::sum_integers(ints.begin()+1, ints.end()-1), 2+3+4);
-    EXPECT_EQ(c10::multiply_integers(ints.begin()+1, ints.end()-1), 2*3*4);
+  EXPECT_EQ(c10::sum_integers(ints.begin() + 1, ints.end() - 1), 2 + 3 + 4);
+  EXPECT_EQ(
+      c10::multiply_integers(ints.begin() + 1, ints.end() - 1), 2 * 3 * 4);
 
-    EXPECT_EQ(c10::numelements_from_dim(2, ints), 3*4*5);
-    EXPECT_EQ(c10::numelements_to_dim(3, ints), 1*2*3);
-    EXPECT_EQ(c10::numelements_between_dim(2, 4, ints), 3*4);
-    EXPECT_EQ(c10::numelements_between_dim(4, 2, ints), 3*4);
+  EXPECT_EQ(c10::numelements_from_dim(2, ints), 3 * 4 * 5);
+  EXPECT_EQ(c10::numelements_to_dim(3, ints), 1 * 2 * 3);
+  EXPECT_EQ(c10::numelements_between_dim(2, 4, ints), 3 * 4);
+  EXPECT_EQ(c10::numelements_between_dim(4, 2, ints), 3 * 4);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(accumulate_test, list_test) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    std::list<int> ints = {1, 2, 3, 4, 5};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  std::list<int> ints = {1, 2, 3, 4, 5};
 
-    EXPECT_EQ(c10::sum_integers(ints), 1+2+3+4+5);
-    EXPECT_EQ(c10::multiply_integers(ints), 1*2*3*4*5);
+  EXPECT_EQ(c10::sum_integers(ints), 1 + 2 + 3 + 4 + 5);
+  EXPECT_EQ(c10::multiply_integers(ints), 1 * 2 * 3 * 4 * 5);
 
-    EXPECT_EQ(c10::sum_integers(ints.begin(), ints.end()), 1+2+3+4+5);
-    EXPECT_EQ(c10::multiply_integers(ints.begin(), ints.end()), 1*2*3*4*5);
+  EXPECT_EQ(c10::sum_integers(ints.begin(), ints.end()), 1 + 2 + 3 + 4 + 5);
+  EXPECT_EQ(
+      c10::multiply_integers(ints.begin(), ints.end()), 1 * 2 * 3 * 4 * 5);
 
-    EXPECT_EQ(c10::numelements_from_dim(2, ints), 3*4*5);
-    EXPECT_EQ(c10::numelements_to_dim(3, ints), 1*2*3);
-    EXPECT_EQ(c10::numelements_between_dim(2, 4, ints), 3*4);
-    EXPECT_EQ(c10::numelements_between_dim(4, 2, ints), 3*4);
+  EXPECT_EQ(c10::numelements_from_dim(2, ints), 3 * 4 * 5);
+  EXPECT_EQ(c10::numelements_to_dim(3, ints), 1 * 2 * 3);
+  EXPECT_EQ(c10::numelements_between_dim(2, 4, ints), 3 * 4);
+  EXPECT_EQ(c10::numelements_between_dim(4, 2, ints), 3 * 4);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(accumulate_test, base_cases) {
-    std::vector<int> ints = {};
+  std::vector<int> ints = {};
 
-    EXPECT_EQ(c10::sum_integers(ints), 0);
-    EXPECT_EQ(c10::multiply_integers(ints), 1);
+  EXPECT_EQ(c10::sum_integers(ints), 0);
+  EXPECT_EQ(c10::multiply_integers(ints), 1);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(accumulate_test, errors) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    std::vector<int> ints = {1,2,3,4,5};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  std::vector<int> ints = {1, 2, 3, 4, 5};
 
-    #ifndef NDEBUG
-    EXPECT_THROW(c10::numelements_from_dim(-1, ints), c10::Error);
-    #endif
+#ifndef NDEBUG
+  EXPECT_THROW(c10::numelements_from_dim(-1, ints), c10::Error);
+#endif
 
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_to_dim(-1, ints), c10::Error);
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_between_dim(-1, 10, ints), c10::Error);
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_between_dim(10, -1, ints), c10::Error);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_to_dim(-1, ints), c10::Error);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_between_dim(-1, 10, ints), c10::Error);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_between_dim(10, -1, ints), c10::Error);
 
-    EXPECT_EQ(c10::numelements_from_dim(10, ints),1);
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_to_dim(10, ints), c10::Error);
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_between_dim(10, 4, ints), c10::Error);
-    // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-    EXPECT_THROW(c10::numelements_between_dim(4, 10, ints), c10::Error);
+  EXPECT_EQ(c10::numelements_from_dim(10, ints), 1);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_to_dim(10, ints), c10::Error);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_between_dim(10, 4, ints), c10::Error);
+  // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+  EXPECT_THROW(c10::numelements_between_dim(4, 10, ints), c10::Error);
 }
diff --git a/c10/test/util/bfloat16_test.cpp b/c10/test/util/bfloat16_test.cpp
index e6ee94c2f76..0cde27587fa 100644
--- a/c10/test/util/bfloat16_test.cpp
+++ b/c10/test/util/bfloat16_test.cpp
@@ -2,196 +2,194 @@
 #include <gtest/gtest.h>
 
 namespace {
-  float float_from_bytes(
-      uint32_t sign,
-      uint32_t exponent,
-      uint32_t fraction
-  ) {
-      // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-      uint32_t bytes;
-      bytes = 0;
-      bytes |= sign;
-      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-      bytes <<= 8;
-      bytes |= exponent;
-      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-      bytes <<= 23;
-      bytes |= fraction;
+float float_from_bytes(uint32_t sign, uint32_t exponent, uint32_t fraction) {
+  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+  uint32_t bytes;
+  bytes = 0;
+  bytes |= sign;
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  bytes <<= 8;
+  bytes |= exponent;
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  bytes <<= 23;
+  bytes |= fraction;
 
-      // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-      float res;
-      std::memcpy(&res, &bytes, sizeof(res));
-      return res;
+  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+  float res;
+  std::memcpy(&res, &bytes, sizeof(res));
+  return res;
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Conversion, FloatToBFloat16AndBack) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  float in[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  for (int i = 0; i < 100; ++i) {
+    // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions,cppcoreguidelines-avoid-magic-numbers)
+    in[i] = i + 1.25;
   }
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Conversion, FloatToBFloat16AndBack) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    float in[100];
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    for (int i = 0; i < 100; ++i) {
-      // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions,cppcoreguidelines-avoid-magic-numbers)
-      in[i] = i + 1.25;
-    }
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  c10::BFloat16 bfloats[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  float out[100];
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    c10::BFloat16 bfloats[100];
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    float out[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  for (int i = 0; i < 100; ++i) {
+    bfloats[i].x = c10::detail::bits_from_f32(in[i]);
+    out[i] = c10::detail::f32_from_bits(bfloats[i].x);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    for (int i = 0; i < 100; ++i) {
-      bfloats[i].x = c10::detail::bits_from_f32(in[i]);
-      out[i] = c10::detail::f32_from_bits(bfloats[i].x);
+    // The relative error should be less than 1/(2^7) since BFloat16
+    // has 7 bits mantissa.
+    EXPECT_LE(fabs(out[i] - in[i]) / in[i], 1.0 / 128);
+  }
+}
 
-      // The relative error should be less than 1/(2^7) since BFloat16
-      // has 7 bits mantissa.
-      EXPECT_LE(fabs(out[i] - in[i]) / in[i], 1.0 / 128);
-    }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Conversion, FloatToBFloat16RNEAndBack) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  float in[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  for (int i = 0; i < 100; ++i) {
+    // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions,cppcoreguidelines-avoid-magic-numbers)
+    in[i] = i + 1.25;
   }
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Conversion, FloatToBFloat16RNEAndBack) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    float in[100];
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    for (int i = 0; i < 100; ++i) {
-      // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions,cppcoreguidelines-avoid-magic-numbers)
-      in[i] = i + 1.25;
-    }
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  c10::BFloat16 bfloats[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
+  float out[100];
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    c10::BFloat16 bfloats[100];
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,cppcoreguidelines-avoid-magic-numbers,modernize-avoid-c-arrays)
-    float out[100];
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  for (int i = 0; i < 100; ++i) {
+    bfloats[i].x = c10::detail::round_to_nearest_even(in[i]);
+    out[i] = c10::detail::f32_from_bits(bfloats[i].x);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    for (int i = 0; i < 100; ++i) {
-      bfloats[i].x = c10::detail::round_to_nearest_even(in[i]);
-      out[i] = c10::detail::f32_from_bits(bfloats[i].x);
-
-      // The relative error should be less than 1/(2^7) since BFloat16
-      // has 7 bits mantissa.
-      EXPECT_LE(fabs(out[i] - in[i]) / in[i], 1.0 / 128);
-    }
+    // The relative error should be less than 1/(2^7) since BFloat16
+    // has 7 bits mantissa.
+    EXPECT_LE(fabs(out[i] - in[i]) / in[i], 1.0 / 128);
   }
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Conversion, NaN) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float inNaN = float_from_bytes(0, 0xFF, 0x7FFFFF);
-    EXPECT_TRUE(std::isnan(inNaN));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Conversion, NaN) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float inNaN = float_from_bytes(0, 0xFF, 0x7FFFFF);
+  EXPECT_TRUE(std::isnan(inNaN));
 
-    c10::BFloat16 a = c10::BFloat16(inNaN);
-    float out = c10::detail::f32_from_bits(a.x);
+  c10::BFloat16 a = c10::BFloat16(inNaN);
+  float out = c10::detail::f32_from_bits(a.x);
 
-    EXPECT_TRUE(std::isnan(out));
-  }
+  EXPECT_TRUE(std::isnan(out));
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Conversion, Inf) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float inInf = float_from_bytes(0, 0xFF, 0);
-    EXPECT_TRUE(std::isinf(inInf));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Conversion, Inf) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float inInf = float_from_bytes(0, 0xFF, 0);
+  EXPECT_TRUE(std::isinf(inInf));
 
-    c10::BFloat16 a = c10::BFloat16(inInf);
-    float out = c10::detail::f32_from_bits(a.x);
+  c10::BFloat16 a = c10::BFloat16(inInf);
+  float out = c10::detail::f32_from_bits(a.x);
 
-    EXPECT_TRUE(std::isinf(out));
-  }
+  EXPECT_TRUE(std::isinf(out));
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Conversion, SmallestDenormal) {
-    float in =  std::numeric_limits<float>::denorm_min(); // The smallest non-zero subnormal number
-    c10::BFloat16 a = c10::BFloat16(in);
-    float out = c10::detail::f32_from_bits(a.x);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Conversion, SmallestDenormal) {
+  float in = std::numeric_limits<float>::denorm_min(); // The smallest non-zero
+                                                       // subnormal number
+  c10::BFloat16 a = c10::BFloat16(in);
+  float out = c10::detail::f32_from_bits(a.x);
 
-    EXPECT_FLOAT_EQ(in, out);
-  }
+  EXPECT_FLOAT_EQ(in, out);
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Math, Addition) {
-    // This test verifies that if only first 7 bits of float's mantissa are
-    // changed after addition, we should have no loss in precision.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Math, Addition) {
+  // This test verifies that if only first 7 bits of float's mantissa are
+  // changed after addition, we should have no loss in precision.
 
-    // input bits
-    // S | Exponent | Mantissa
-    // 0 | 10000000 | 10010000000000000000000 = 3.125
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float input = float_from_bytes(0, 0, 0x40480000);
+  // input bits
+  // S | Exponent | Mantissa
+  // 0 | 10000000 | 10010000000000000000000 = 3.125
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float input = float_from_bytes(0, 0, 0x40480000);
 
-    // expected bits
-    // S | Exponent | Mantissa
-    // 0 | 10000001 | 10010000000000000000000 = 6.25
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float expected = float_from_bytes(0, 0, 0x40c80000);
+  // expected bits
+  // S | Exponent | Mantissa
+  // 0 | 10000001 | 10010000000000000000000 = 6.25
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float expected = float_from_bytes(0, 0, 0x40c80000);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-    c10::BFloat16 b;
-    b.x = c10::detail::bits_from_f32(input);
-    b = b + b;
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  c10::BFloat16 b;
+  b.x = c10::detail::bits_from_f32(input);
+  b = b + b;
 
-    float res = c10::detail::f32_from_bits(b.x);
-    EXPECT_EQ(res, expected);
-  }
+  float res = c10::detail::f32_from_bits(b.x);
+  EXPECT_EQ(res, expected);
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST(BFloat16Math, Subtraction) {
-    // This test verifies that if only first 7 bits of float's mantissa are
-    // changed after subtraction, we should have no loss in precision.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST(BFloat16Math, Subtraction) {
+  // This test verifies that if only first 7 bits of float's mantissa are
+  // changed after subtraction, we should have no loss in precision.
 
-    // input bits
-    // S | Exponent | Mantissa
-    // 0 | 10000001 | 11101000000000000000000 = 7.625
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float input = float_from_bytes(0, 0, 0x40f40000);
+  // input bits
+  // S | Exponent | Mantissa
+  // 0 | 10000001 | 11101000000000000000000 = 7.625
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float input = float_from_bytes(0, 0, 0x40f40000);
 
-    // expected bits
-    // S | Exponent | Mantissa
-    // 0 | 10000000 | 01010000000000000000000 = 2.625
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    float expected = float_from_bytes(0, 0, 0x40280000);
+  // expected bits
+  // S | Exponent | Mantissa
+  // 0 | 10000000 | 01010000000000000000000 = 2.625
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  float expected = float_from_bytes(0, 0, 0x40280000);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-    c10::BFloat16 b;
-    b.x = c10::detail::bits_from_f32(input);
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    b = b - 5;
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+  c10::BFloat16 b;
+  b.x = c10::detail::bits_from_f32(input);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  b = b - 5;
 
-    float res = c10::detail::f32_from_bits(b.x);
-    EXPECT_EQ(res, expected);
-  }
+  float res = c10::detail::f32_from_bits(b.x);
+  EXPECT_EQ(res, expected);
+}
 
-  float BinaryToFloat(uint32_t bytes) {
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    float res;
-    std::memcpy(&res, &bytes, sizeof(res));
-    return res;
-  }
+float BinaryToFloat(uint32_t bytes) {
+  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+  float res;
+  std::memcpy(&res, &bytes, sizeof(res));
+  return res;
+}
 
-  struct BFloat16TestParam {
-    uint32_t input;
-    uint16_t rne;
-  };
+struct BFloat16TestParam {
+  uint32_t input;
+  uint16_t rne;
+};
 
-  class BFloat16Test : public ::testing::Test,
-                       public ::testing::WithParamInterface<BFloat16TestParam> {
-  };
+class BFloat16Test : public ::testing::Test,
+                     public ::testing::WithParamInterface<BFloat16TestParam> {};
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  TEST_P(BFloat16Test, BFloat16RNETest) {
-    float value = BinaryToFloat(GetParam().input);
-    uint16_t rounded = c10::detail::round_to_nearest_even(value);
-    EXPECT_EQ(GetParam().rne, rounded);
-  }
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+TEST_P(BFloat16Test, BFloat16RNETest) {
+  float value = BinaryToFloat(GetParam().input);
+  uint16_t rounded = c10::detail::round_to_nearest_even(value);
+  EXPECT_EQ(GetParam().rne, rounded);
+}
 
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  INSTANTIATE_TEST_CASE_P(
-      BFloat16Test_Instantiation, BFloat16Test,
-      ::testing::Values(BFloat16TestParam{0x3F848000, 0x3F84},
-                        BFloat16TestParam{0x3F848010, 0x3F85},
-                        BFloat16TestParam{0x3F850000, 0x3F85},
-                        BFloat16TestParam{0x3F858000, 0x3F86},
-                        BFloat16TestParam{0x3FFF8000, 0x4000}));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+INSTANTIATE_TEST_CASE_P(
+    BFloat16Test_Instantiation,
+    BFloat16Test,
+    ::testing::Values(
+        BFloat16TestParam{0x3F848000, 0x3F84},
+        BFloat16TestParam{0x3F848010, 0x3F85},
+        BFloat16TestParam{0x3F850000, 0x3F85},
+        BFloat16TestParam{0x3F858000, 0x3F86},
+        BFloat16TestParam{0x3FFF8000, 0x4000}));
 
 } // namespace
diff --git a/c10/test/util/complex_math_test_common.h b/c10/test/util/complex_math_test_common.h
index 4715c37c7f9..15addf68785 100644
--- a/c10/test/util/complex_math_test_common.h
+++ b/c10/test/util/complex_math_test_common.h
@@ -1,4 +1,5 @@
-// Warning: this file is included twice in aten/src/ATen/test/cuda_complex_math_test.cu
+// Warning: this file is included twice in
+// aten/src/ATen/test/cuda_complex_math_test.cu
 
 #include <c10/util/complex.h>
 #include <gtest/gtest.h>
@@ -16,152 +17,152 @@
 C10_DEFINE_TEST(TestExponential, IPi) {
   // exp(i*pi) = -1
   {
-  c10::complex<float> e_i_pi = std::exp(c10::complex<float>(0, float(PI)));
-  C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
-  C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
+    c10::complex<float> e_i_pi = std::exp(c10::complex<float>(0, float(PI)));
+    C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
+    C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
   }
   {
-  c10::complex<float> e_i_pi = ::exp(c10::complex<float>(0, float(PI)));
-  C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
-  C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
+    c10::complex<float> e_i_pi = ::exp(c10::complex<float>(0, float(PI)));
+    C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
+    C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
   }
   {
-  c10::complex<double> e_i_pi = std::exp(c10::complex<double>(0, PI));
-  C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
-  C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
+    c10::complex<double> e_i_pi = std::exp(c10::complex<double>(0, PI));
+    C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
+    C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
   }
   {
-  c10::complex<double> e_i_pi = ::exp(c10::complex<double>(0, PI));
-  C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
-  C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
+    c10::complex<double> e_i_pi = ::exp(c10::complex<double>(0, PI));
+    C10_ASSERT_NEAR(e_i_pi.real(), -1, tol);
+    C10_ASSERT_NEAR(e_i_pi.imag(), 0, tol);
   }
 }
 
 C10_DEFINE_TEST(TestExponential, EulerFormula) {
   // exp(ix) = cos(x) + i * sin(x)
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> e = std::exp(x);
-  float expected_real = std::exp(x.real()) * std::cos(x.imag());
-  float expected_imag = std::exp(x.real()) * std::sin(x.imag());
-  C10_ASSERT_NEAR(e.real(), expected_real, tol);
-  C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> e = std::exp(x);
+    float expected_real = std::exp(x.real()) * std::cos(x.imag());
+    float expected_imag = std::exp(x.real()) * std::sin(x.imag());
+    C10_ASSERT_NEAR(e.real(), expected_real, tol);
+    C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> e = ::exp(x);
-  float expected_real = ::exp(x.real()) * ::cos(x.imag());
-  float expected_imag = ::exp(x.real()) * ::sin(x.imag());
-  C10_ASSERT_NEAR(e.real(), expected_real, tol);
-  C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> e = ::exp(x);
+    float expected_real = ::exp(x.real()) * ::cos(x.imag());
+    float expected_imag = ::exp(x.real()) * ::sin(x.imag());
+    C10_ASSERT_NEAR(e.real(), expected_real, tol);
+    C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> e = std::exp(x);
-  float expected_real = std::exp(x.real()) * std::cos(x.imag());
-  float expected_imag = std::exp(x.real()) * std::sin(x.imag());
-  C10_ASSERT_NEAR(e.real(), expected_real, tol);
-  C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> e = std::exp(x);
+    float expected_real = std::exp(x.real()) * std::cos(x.imag());
+    float expected_imag = std::exp(x.real()) * std::sin(x.imag());
+    C10_ASSERT_NEAR(e.real(), expected_real, tol);
+    C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> e = ::exp(x);
-  float expected_real = ::exp(x.real()) * ::cos(x.imag());
-  float expected_imag = ::exp(x.real()) * ::sin(x.imag());
-  C10_ASSERT_NEAR(e.real(), expected_real, tol);
-  C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> e = ::exp(x);
+    float expected_real = ::exp(x.real()) * ::cos(x.imag());
+    float expected_imag = ::exp(x.real()) * ::sin(x.imag());
+    C10_ASSERT_NEAR(e.real(), expected_real, tol);
+    C10_ASSERT_NEAR(e.imag(), expected_imag, tol);
   }
 }
 
 C10_DEFINE_TEST(TestLog, Definition) {
   // log(x) = log(r) + i*theta
   {
-  c10::complex<float> x(1.2, 3.4);
-  c10::complex<float> l = std::log(x);
-  float expected_real = std::log(std::abs(x));
-  float expected_imag = std::arg(x);
-  C10_ASSERT_NEAR(l.real(), expected_real, tol);
-  C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
+    c10::complex<float> x(1.2, 3.4);
+    c10::complex<float> l = std::log(x);
+    float expected_real = std::log(std::abs(x));
+    float expected_imag = std::arg(x);
+    C10_ASSERT_NEAR(l.real(), expected_real, tol);
+    C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
   }
   {
-  c10::complex<float> x(1.2, 3.4);
-  c10::complex<float> l = ::log(x);
-  float expected_real = ::log(std::abs(x));
-  float expected_imag = std::arg(x);
-  C10_ASSERT_NEAR(l.real(), expected_real, tol);
-  C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
+    c10::complex<float> x(1.2, 3.4);
+    c10::complex<float> l = ::log(x);
+    float expected_real = ::log(std::abs(x));
+    float expected_imag = std::arg(x);
+    C10_ASSERT_NEAR(l.real(), expected_real, tol);
+    C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(1.2, 3.4);
-  c10::complex<double> l = std::log(x);
-  float expected_real = std::log(std::abs(x));
-  float expected_imag = std::arg(x);
-  C10_ASSERT_NEAR(l.real(), expected_real, tol);
-  C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
+    c10::complex<double> x(1.2, 3.4);
+    c10::complex<double> l = std::log(x);
+    float expected_real = std::log(std::abs(x));
+    float expected_imag = std::arg(x);
+    C10_ASSERT_NEAR(l.real(), expected_real, tol);
+    C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(1.2, 3.4);
-  c10::complex<double> l = ::log(x);
-  float expected_real = ::log(std::abs(x));
-  float expected_imag = std::arg(x);
-  C10_ASSERT_NEAR(l.real(), expected_real, tol);
-  C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
+    c10::complex<double> x(1.2, 3.4);
+    c10::complex<double> l = ::log(x);
+    float expected_real = ::log(std::abs(x));
+    float expected_imag = std::arg(x);
+    C10_ASSERT_NEAR(l.real(), expected_real, tol);
+    C10_ASSERT_NEAR(l.imag(), expected_imag, tol);
   }
 }
 
 C10_DEFINE_TEST(TestLog10, Rev) {
   // log10(10^x) = x
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> l = std::log10(std::pow(float(10), x));
-  C10_ASSERT_NEAR(l.real(), float(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> l = std::log10(std::pow(float(10), x));
+    C10_ASSERT_NEAR(l.real(), float(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> l = ::log10(::pow(float(10), x));
-  C10_ASSERT_NEAR(l.real(), float(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> l = ::log10(::pow(float(10), x));
+    C10_ASSERT_NEAR(l.real(), float(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> l = std::log10(std::pow(double(10), x));
-  C10_ASSERT_NEAR(l.real(), double(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> l = std::log10(std::pow(double(10), x));
+    C10_ASSERT_NEAR(l.real(), double(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> l = ::log10(::pow(double(10), x));
-  C10_ASSERT_NEAR(l.real(), double(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> l = ::log10(::pow(double(10), x));
+    C10_ASSERT_NEAR(l.real(), double(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
   }
 }
 
 C10_DEFINE_TEST(TestLog2, Rev) {
   // log2(2^x) = x
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> l = std::log2(std::pow(float(2), x));
-  C10_ASSERT_NEAR(l.real(), float(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> l = std::log2(std::pow(float(2), x));
+    C10_ASSERT_NEAR(l.real(), float(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> l = ::log2(std::pow(float(2), x));
-  C10_ASSERT_NEAR(l.real(), float(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> l = ::log2(std::pow(float(2), x));
+    C10_ASSERT_NEAR(l.real(), float(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), float(1.2), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> l = std::log2(std::pow(double(2), x));
-  C10_ASSERT_NEAR(l.real(), double(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> l = std::log2(std::pow(double(2), x));
+    C10_ASSERT_NEAR(l.real(), double(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> l = ::log2(std::pow(double(2), x));
-  C10_ASSERT_NEAR(l.real(), double(0.1), tol);
-  C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> l = ::log2(std::pow(double(2), x));
+    C10_ASSERT_NEAR(l.real(), double(0.1), tol);
+    C10_ASSERT_NEAR(l.imag(), double(1.2), tol);
   }
 }
 
@@ -170,64 +171,64 @@ C10_DEFINE_TEST(TestLog2, Rev) {
 C10_DEFINE_TEST(TestPowSqrt, Equal) {
   // x^0.5 = sqrt(x)
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::pow(x, float(0.5));
-  c10::complex<float> z = std::sqrt(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::pow(x, float(0.5));
+    c10::complex<float> z = std::sqrt(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::pow(x, float(0.5));
-  c10::complex<float> z = ::sqrt(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::pow(x, float(0.5));
+    c10::complex<float> z = ::sqrt(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::pow(x, double(0.5));
-  c10::complex<double> z = std::sqrt(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::pow(x, double(0.5));
+    c10::complex<double> z = std::sqrt(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::pow(x, double(0.5));
-  c10::complex<double> z = ::sqrt(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::pow(x, double(0.5));
+    c10::complex<double> z = ::sqrt(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
 }
 
 C10_DEFINE_TEST(TestPow, Square) {
   // x^2 = x * x
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::pow(x, float(2));
-  c10::complex<float> z = x * x;
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::pow(x, float(2));
+    c10::complex<float> z = x * x;
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::pow(x, float(2));
-  c10::complex<float> z = x * x;
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::pow(x, float(2));
+    c10::complex<float> z = x * x;
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::pow(x, double(2));
-  c10::complex<double> z = x * x;
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::pow(x, double(2));
+    c10::complex<double> z = x * x;
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::pow(x, double(2));
-  c10::complex<double> z = x * x;
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::pow(x, double(2));
+    c10::complex<double> z = x * x;
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
 }
 
@@ -237,132 +238,132 @@ C10_DEFINE_TEST(TestSinCosSinhCosh, Identity) {
   // sin(x + i * y) = sin(x) * cosh(y) + i * cos(x) * sinh(y)
   // cos(x + i * y) = cos(x) * cosh(y) - i * sin(x) * sinh(y)
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::sin(x);
-  float expected_real = std::sin(x.real()) * std::cosh(x.imag());
-  float expected_imag = std::cos(x.real()) * std::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::sin(x);
+    float expected_real = std::sin(x.real()) * std::cosh(x.imag());
+    float expected_imag = std::cos(x.real()) * std::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::sin(x);
-  float expected_real = ::sin(x.real()) * ::cosh(x.imag());
-  float expected_imag = ::cos(x.real()) * ::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::sin(x);
+    float expected_real = ::sin(x.real()) * ::cosh(x.imag());
+    float expected_imag = ::cos(x.real()) * ::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::cos(x);
-  float expected_real = std::cos(x.real()) * std::cosh(x.imag());
-  float expected_imag = - std::sin(x.real()) * std::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::cos(x);
+    float expected_real = std::cos(x.real()) * std::cosh(x.imag());
+    float expected_imag = -std::sin(x.real()) * std::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::cos(x);
-  float expected_real = ::cos(x.real()) * ::cosh(x.imag());
-  float expected_imag = - ::sin(x.real()) * ::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::cos(x);
+    float expected_real = ::cos(x.real()) * ::cosh(x.imag());
+    float expected_imag = -::sin(x.real()) * ::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::sin(x);
-  float expected_real = std::sin(x.real()) * std::cosh(x.imag());
-  float expected_imag = std::cos(x.real()) * std::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::sin(x);
+    float expected_real = std::sin(x.real()) * std::cosh(x.imag());
+    float expected_imag = std::cos(x.real()) * std::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::sin(x);
-  float expected_real = ::sin(x.real()) * ::cosh(x.imag());
-  float expected_imag = ::cos(x.real()) * ::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::sin(x);
+    float expected_real = ::sin(x.real()) * ::cosh(x.imag());
+    float expected_imag = ::cos(x.real()) * ::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::cos(x);
-  float expected_real = std::cos(x.real()) * std::cosh(x.imag());
-  float expected_imag = - std::sin(x.real()) * std::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::cos(x);
+    float expected_real = std::cos(x.real()) * std::cosh(x.imag());
+    float expected_imag = -std::sin(x.real()) * std::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::cos(x);
-  float expected_real = ::cos(x.real()) * ::cosh(x.imag());
-  float expected_imag = - ::sin(x.real()) * ::sinh(x.imag());
-  C10_ASSERT_NEAR(y.real(), expected_real, tol);
-  C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::cos(x);
+    float expected_real = ::cos(x.real()) * ::cosh(x.imag());
+    float expected_imag = -::sin(x.real()) * ::sinh(x.imag());
+    C10_ASSERT_NEAR(y.real(), expected_real, tol);
+    C10_ASSERT_NEAR(y.imag(), expected_imag, tol);
   }
 }
 
 C10_DEFINE_TEST(TestTan, Identity) {
   // tan(x) = sin(x) / cos(x)
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::tan(x);
-  c10::complex<float> z = std::sin(x) / std::cos(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::tan(x);
+    c10::complex<float> z = std::sin(x) / std::cos(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::tan(x);
-  c10::complex<float> z = ::sin(x) / ::cos(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::tan(x);
+    c10::complex<float> z = ::sin(x) / ::cos(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::tan(x);
-  c10::complex<double> z = std::sin(x) / std::cos(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::tan(x);
+    c10::complex<double> z = std::sin(x) / std::cos(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::tan(x);
-  c10::complex<double> z = ::sin(x) / ::cos(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::tan(x);
+    c10::complex<double> z = ::sin(x) / ::cos(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
 }
 
 C10_DEFINE_TEST(TestTanh, Identity) {
   // tanh(x) = sinh(x) / cosh(x)
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = std::tanh(x);
-  c10::complex<float> z = std::sinh(x) / std::cosh(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = std::tanh(x);
+    c10::complex<float> z = std::sinh(x) / std::cosh(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<float> x(0.1, 1.2);
-  c10::complex<float> y = ::tanh(x);
-  c10::complex<float> z = ::sinh(x) / ::cosh(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<float> x(0.1, 1.2);
+    c10::complex<float> y = ::tanh(x);
+    c10::complex<float> z = ::sinh(x) / ::cosh(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = std::tanh(x);
-  c10::complex<double> z = std::sinh(x) / std::cosh(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = std::tanh(x);
+    c10::complex<double> z = std::sinh(x) / std::cosh(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
   {
-  c10::complex<double> x(0.1, 1.2);
-  c10::complex<double> y = ::tanh(x);
-  c10::complex<double> z = ::sinh(x) / ::cosh(x);
-  C10_ASSERT_NEAR(y.real(), z.real(), tol);
-  C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
+    c10::complex<double> x(0.1, 1.2);
+    c10::complex<double> y = ::tanh(x);
+    c10::complex<double> z = ::sinh(x) / ::cosh(x);
+    C10_ASSERT_NEAR(y.real(), z.real(), tol);
+    C10_ASSERT_NEAR(y.imag(), z.imag(), tol);
   }
 }
 
@@ -373,64 +374,64 @@ C10_DEFINE_TEST(TestRevTrigonometric, Rev) {
   // acos(cos(x)) = x
   // atan(tan(x)) = x
   {
-  c10::complex<float> x(0.5, 0.6);
-  c10::complex<float> s = std::sin(x);
-  c10::complex<float> ss = std::asin(s);
-  c10::complex<float> c = std::cos(x);
-  c10::complex<float> cc = std::acos(c);
-  c10::complex<float> t = std::tan(x);
-  c10::complex<float> tt = std::atan(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<float> x(0.5, 0.6);
+    c10::complex<float> s = std::sin(x);
+    c10::complex<float> ss = std::asin(s);
+    c10::complex<float> c = std::cos(x);
+    c10::complex<float> cc = std::acos(c);
+    c10::complex<float> t = std::tan(x);
+    c10::complex<float> tt = std::atan(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<float> x(0.5, 0.6);
-  c10::complex<float> s = ::sin(x);
-  c10::complex<float> ss = ::asin(s);
-  c10::complex<float> c = ::cos(x);
-  c10::complex<float> cc = ::acos(c);
-  c10::complex<float> t = ::tan(x);
-  c10::complex<float> tt = ::atan(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<float> x(0.5, 0.6);
+    c10::complex<float> s = ::sin(x);
+    c10::complex<float> ss = ::asin(s);
+    c10::complex<float> c = ::cos(x);
+    c10::complex<float> cc = ::acos(c);
+    c10::complex<float> t = ::tan(x);
+    c10::complex<float> tt = ::atan(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<double> x(0.5, 0.6);
-  c10::complex<double> s = std::sin(x);
-  c10::complex<double> ss = std::asin(s);
-  c10::complex<double> c = std::cos(x);
-  c10::complex<double> cc = std::acos(c);
-  c10::complex<double> t = std::tan(x);
-  c10::complex<double> tt = std::atan(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<double> x(0.5, 0.6);
+    c10::complex<double> s = std::sin(x);
+    c10::complex<double> ss = std::asin(s);
+    c10::complex<double> c = std::cos(x);
+    c10::complex<double> cc = std::acos(c);
+    c10::complex<double> t = std::tan(x);
+    c10::complex<double> tt = std::atan(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<double> x(0.5, 0.6);
-  c10::complex<double> s = ::sin(x);
-  c10::complex<double> ss = ::asin(s);
-  c10::complex<double> c = ::cos(x);
-  c10::complex<double> cc = ::acos(c);
-  c10::complex<double> t = ::tan(x);
-  c10::complex<double> tt = ::atan(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<double> x(0.5, 0.6);
+    c10::complex<double> s = ::sin(x);
+    c10::complex<double> ss = ::asin(s);
+    c10::complex<double> c = ::cos(x);
+    c10::complex<double> cc = ::acos(c);
+    c10::complex<double> t = ::tan(x);
+    c10::complex<double> tt = ::atan(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
 }
 
@@ -441,63 +442,63 @@ C10_DEFINE_TEST(TestRevHyperbolic, Rev) {
   // acosh(cosh(x)) = x
   // atanh(tanh(x)) = x
   {
-  c10::complex<float> x(0.5, 0.6);
-  c10::complex<float> s = std::sinh(x);
-  c10::complex<float> ss = std::asinh(s);
-  c10::complex<float> c = std::cosh(x);
-  c10::complex<float> cc = std::acosh(c);
-  c10::complex<float> t = std::tanh(x);
-  c10::complex<float> tt = std::atanh(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<float> x(0.5, 0.6);
+    c10::complex<float> s = std::sinh(x);
+    c10::complex<float> ss = std::asinh(s);
+    c10::complex<float> c = std::cosh(x);
+    c10::complex<float> cc = std::acosh(c);
+    c10::complex<float> t = std::tanh(x);
+    c10::complex<float> tt = std::atanh(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<float> x(0.5, 0.6);
-  c10::complex<float> s = ::sinh(x);
-  c10::complex<float> ss = ::asinh(s);
-  c10::complex<float> c = ::cosh(x);
-  c10::complex<float> cc = ::acosh(c);
-  c10::complex<float> t = ::tanh(x);
-  c10::complex<float> tt = ::atanh(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<float> x(0.5, 0.6);
+    c10::complex<float> s = ::sinh(x);
+    c10::complex<float> ss = ::asinh(s);
+    c10::complex<float> c = ::cosh(x);
+    c10::complex<float> cc = ::acosh(c);
+    c10::complex<float> t = ::tanh(x);
+    c10::complex<float> tt = ::atanh(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<double> x(0.5, 0.6);
-  c10::complex<double> s = std::sinh(x);
-  c10::complex<double> ss = std::asinh(s);
-  c10::complex<double> c = std::cosh(x);
-  c10::complex<double> cc = std::acosh(c);
-  c10::complex<double> t = std::tanh(x);
-  c10::complex<double> tt = std::atanh(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<double> x(0.5, 0.6);
+    c10::complex<double> s = std::sinh(x);
+    c10::complex<double> ss = std::asinh(s);
+    c10::complex<double> c = std::cosh(x);
+    c10::complex<double> cc = std::acosh(c);
+    c10::complex<double> t = std::tanh(x);
+    c10::complex<double> tt = std::atanh(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
   {
-  c10::complex<double> x(0.5, 0.6);
-  c10::complex<double> s = ::sinh(x);
-  c10::complex<double> ss = ::asinh(s);
-  c10::complex<double> c = ::cosh(x);
-  c10::complex<double> cc = ::acosh(c);
-  c10::complex<double> t = ::tanh(x);
-  c10::complex<double> tt = ::atanh(t);
-  C10_ASSERT_NEAR(x.real(), ss.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), cc.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
-  C10_ASSERT_NEAR(x.real(), tt.real(), tol);
-  C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
+    c10::complex<double> x(0.5, 0.6);
+    c10::complex<double> s = ::sinh(x);
+    c10::complex<double> ss = ::asinh(s);
+    c10::complex<double> c = ::cosh(x);
+    c10::complex<double> cc = ::acosh(c);
+    c10::complex<double> t = ::tanh(x);
+    c10::complex<double> tt = ::atanh(t);
+    C10_ASSERT_NEAR(x.real(), ss.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), ss.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), cc.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), cc.imag(), tol);
+    C10_ASSERT_NEAR(x.real(), tt.real(), tol);
+    C10_ASSERT_NEAR(x.imag(), tt.imag(), tol);
   }
 }
diff --git a/c10/test/util/complex_test_common.h b/c10/test/util/complex_test_common.h
index 027143206b0..f7ab797e776 100644
--- a/c10/test/util/complex_test_common.h
+++ b/c10/test/util/complex_test_common.h
@@ -1,10 +1,10 @@
-#include <type_traits>
-#include <tuple>
-#include <sstream>
-#include <c10/util/complex.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/complex.h>
 #include <c10/util/hash.h>
 #include <gtest/gtest.h>
+#include <sstream>
+#include <tuple>
+#include <type_traits>
 #include <unordered_map>
 
 #if (defined(__CUDACC__) || defined(__HIPCC__))
@@ -34,71 +34,72 @@ MAYBE_GLOBAL void test_pod() {
 
 TEST(TestMemory, ReinterpretCast) {
   {
-  std::complex<float> z(1, 2);
-  c10::complex<float> zz = *reinterpret_cast<c10::complex<float>*>(&z);
-  ASSERT_EQ(zz.real(), float(1));
-  ASSERT_EQ(zz.imag(), float(2));
+    std::complex<float> z(1, 2);
+    c10::complex<float> zz = *reinterpret_cast<c10::complex<float>*>(&z);
+    ASSERT_EQ(zz.real(), float(1));
+    ASSERT_EQ(zz.imag(), float(2));
   }
 
   {
-  c10::complex<float> z(3, 4);
-  std::complex<float> zz = *reinterpret_cast<std::complex<float>*>(&z);
-  ASSERT_EQ(zz.real(), float(3));
-  ASSERT_EQ(zz.imag(), float(4));
+    c10::complex<float> z(3, 4);
+    std::complex<float> zz = *reinterpret_cast<std::complex<float>*>(&z);
+    ASSERT_EQ(zz.real(), float(3));
+    ASSERT_EQ(zz.imag(), float(4));
   }
 
   {
-  std::complex<double> z(1, 2);
-  c10::complex<double> zz = *reinterpret_cast<c10::complex<double>*>(&z);
-  ASSERT_EQ(zz.real(), double(1));
-  ASSERT_EQ(zz.imag(), double(2));
+    std::complex<double> z(1, 2);
+    c10::complex<double> zz = *reinterpret_cast<c10::complex<double>*>(&z);
+    ASSERT_EQ(zz.real(), double(1));
+    ASSERT_EQ(zz.imag(), double(2));
   }
 
   {
-  c10::complex<double> z(3, 4);
-  std::complex<double> zz = *reinterpret_cast<std::complex<double>*>(&z);
-  ASSERT_EQ(zz.real(), double(3));
-  ASSERT_EQ(zz.imag(), double(4));
+    c10::complex<double> z(3, 4);
+    std::complex<double> zz = *reinterpret_cast<std::complex<double>*>(&z);
+    ASSERT_EQ(zz.real(), double(3));
+    ASSERT_EQ(zz.imag(), double(4));
   }
 }
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
 TEST(TestMemory, ThrustReinterpretCast) {
   {
-  thrust::complex<float> z(1, 2);
-  c10::complex<float> zz = *reinterpret_cast<c10::complex<float>*>(&z);
-  ASSERT_EQ(zz.real(), float(1));
-  ASSERT_EQ(zz.imag(), float(2));
+    thrust::complex<float> z(1, 2);
+    c10::complex<float> zz = *reinterpret_cast<c10::complex<float>*>(&z);
+    ASSERT_EQ(zz.real(), float(1));
+    ASSERT_EQ(zz.imag(), float(2));
   }
 
   {
-  c10::complex<float> z(3, 4);
-  thrust::complex<float> zz = *reinterpret_cast<thrust::complex<float>*>(&z);
-  ASSERT_EQ(zz.real(), float(3));
-  ASSERT_EQ(zz.imag(), float(4));
+    c10::complex<float> z(3, 4);
+    thrust::complex<float> zz = *reinterpret_cast<thrust::complex<float>*>(&z);
+    ASSERT_EQ(zz.real(), float(3));
+    ASSERT_EQ(zz.imag(), float(4));
   }
 
   {
-  thrust::complex<double> z(1, 2);
-  c10::complex<double> zz = *reinterpret_cast<c10::complex<double>*>(&z);
-  ASSERT_EQ(zz.real(), double(1));
-  ASSERT_EQ(zz.imag(), double(2));
+    thrust::complex<double> z(1, 2);
+    c10::complex<double> zz = *reinterpret_cast<c10::complex<double>*>(&z);
+    ASSERT_EQ(zz.real(), double(1));
+    ASSERT_EQ(zz.imag(), double(2));
   }
 
   {
-  c10::complex<double> z(3, 4);
-  thrust::complex<double> zz = *reinterpret_cast<thrust::complex<double>*>(&z);
-  ASSERT_EQ(zz.real(), double(3));
-  ASSERT_EQ(zz.imag(), double(4));
+    c10::complex<double> z(3, 4);
+    thrust::complex<double> zz =
+        *reinterpret_cast<thrust::complex<double>*>(&z);
+    ASSERT_EQ(zz.real(), double(3));
+    ASSERT_EQ(zz.imag(), double(4));
   }
 }
 #endif
 
-}  // memory
+} // namespace memory
 
 namespace constructors {
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_construct_from_scalar() {
   constexpr scalar_t num1 = scalar_t(1.23);
   constexpr scalar_t num2 = scalar_t(4.56);
@@ -111,29 +112,48 @@ C10_HOST_DEVICE void test_construct_from_scalar() {
   static_assert(c10::complex<scalar_t>().imag() == zero, "");
 }
 
-template<typename scalar_t, typename other_t>
+template <typename scalar_t, typename other_t>
 C10_HOST_DEVICE void test_construct_from_other() {
   constexpr other_t num1 = other_t(1.23);
   constexpr other_t num2 = other_t(4.56);
   constexpr scalar_t num3 = scalar_t(num1);
   constexpr scalar_t num4 = scalar_t(num2);
-  static_assert(c10::complex<scalar_t>(c10::complex<other_t>(num1, num2)).real() == num3, "");
-  static_assert(c10::complex<scalar_t>(c10::complex<other_t>(num1, num2)).imag() == num4, "");
+  static_assert(
+      c10::complex<scalar_t>(c10::complex<other_t>(num1, num2)).real() == num3,
+      "");
+  static_assert(
+      c10::complex<scalar_t>(c10::complex<other_t>(num1, num2)).imag() == num4,
+      "");
 }
 
 MAYBE_GLOBAL void test_convert_constructors() {
   test_construct_from_scalar<float>();
   test_construct_from_scalar<double>();
 
-  static_assert(std::is_convertible<c10::complex<float>, c10::complex<float>>::value, "");
-  static_assert(!std::is_convertible<c10::complex<double>, c10::complex<float>>::value, "");
-  static_assert(std::is_convertible<c10::complex<float>, c10::complex<double>>::value, "");
-  static_assert(std::is_convertible<c10::complex<double>, c10::complex<double>>::value, "");
+  static_assert(
+      std::is_convertible<c10::complex<float>, c10::complex<float>>::value, "");
+  static_assert(
+      !std::is_convertible<c10::complex<double>, c10::complex<float>>::value,
+      "");
+  static_assert(
+      std::is_convertible<c10::complex<float>, c10::complex<double>>::value,
+      "");
+  static_assert(
+      std::is_convertible<c10::complex<double>, c10::complex<double>>::value,
+      "");
 
-  static_assert(std::is_constructible<c10::complex<float>, c10::complex<float>>::value, "");
-  static_assert(std::is_constructible<c10::complex<double>, c10::complex<float>>::value, "");
-  static_assert(std::is_constructible<c10::complex<float>, c10::complex<double>>::value, "");
-  static_assert(std::is_constructible<c10::complex<double>, c10::complex<double>>::value, "");
+  static_assert(
+      std::is_constructible<c10::complex<float>, c10::complex<float>>::value,
+      "");
+  static_assert(
+      std::is_constructible<c10::complex<double>, c10::complex<float>>::value,
+      "");
+  static_assert(
+      std::is_constructible<c10::complex<float>, c10::complex<double>>::value,
+      "");
+  static_assert(
+      std::is_constructible<c10::complex<double>, c10::complex<double>>::value,
+      "");
 
   test_construct_from_other<float, float>();
   test_construct_from_other<float, double>();
@@ -141,12 +161,16 @@ MAYBE_GLOBAL void test_convert_constructors() {
   test_construct_from_other<double, double>();
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_construct_from_std() {
   constexpr scalar_t num1 = scalar_t(1.23);
   constexpr scalar_t num2 = scalar_t(4.56);
-  static_assert(c10::complex<scalar_t>(std::complex<scalar_t>(num1, num2)).real() == num1, "");
-  static_assert(c10::complex<scalar_t>(std::complex<scalar_t>(num1, num2)).imag() == num2, "");
+  static_assert(
+      c10::complex<scalar_t>(std::complex<scalar_t>(num1, num2)).real() == num1,
+      "");
+  static_assert(
+      c10::complex<scalar_t>(std::complex<scalar_t>(num1, num2)).imag() == num2,
+      "");
 }
 
 MAYBE_GLOBAL void test_std_conversion() {
@@ -155,12 +179,16 @@ MAYBE_GLOBAL void test_std_conversion() {
 }
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-template<typename scalar_t>
+template <typename scalar_t>
 void test_construct_from_thrust() {
   constexpr scalar_t num1 = scalar_t(1.23);
   constexpr scalar_t num2 = scalar_t(4.56);
-  ASSERT_EQ(c10::complex<scalar_t>(thrust::complex<scalar_t>(num1, num2)).real(), num1);
-  ASSERT_EQ(c10::complex<scalar_t>(thrust::complex<scalar_t>(num1, num2)).imag(), num2);
+  ASSERT_EQ(
+      c10::complex<scalar_t>(thrust::complex<scalar_t>(num1, num2)).real(),
+      num1);
+  ASSERT_EQ(
+      c10::complex<scalar_t>(thrust::complex<scalar_t>(num1, num2)).imag(),
+      num2);
 }
 
 TEST(TestConstructors, FromThrust) {
@@ -170,7 +198,11 @@ TEST(TestConstructors, FromThrust) {
 #endif
 
 TEST(TestConstructors, UnorderedMap) {
-  std::unordered_map<c10::complex<double>, c10::complex<double>, c10::hash<c10::complex<double>>> m;
+  std::unordered_map<
+      c10::complex<double>,
+      c10::complex<double>,
+      c10::hash<c10::complex<double>>>
+      m;
   auto key1 = c10::complex<double>(2.5, 3);
   auto key2 = c10::complex<double>(2, 0);
   auto val1 = c10::complex<double>(2, -3.2);
@@ -181,11 +213,11 @@ TEST(TestConstructors, UnorderedMap) {
   ASSERT_EQ(m[key2], val2);
 }
 
-}  // constructors
+} // namespace constructors
 
 namespace assignment {
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> one() {
   c10::complex<scalar_t> result(3, 4);
   result = scalar_t(1);
@@ -232,7 +264,8 @@ MAYBE_GLOBAL void test_assign_std() {
 }
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-C10_HOST_DEVICE std::tuple<c10::complex<double>, c10::complex<float>> one_two_thrust() {
+C10_HOST_DEVICE std::tuple<c10::complex<double>, c10::complex<float>>
+one_two_thrust() {
   thrust::complex<float> src(1, 2);
   c10::complex<double> ret0;
   c10::complex<float> ret1;
@@ -258,7 +291,8 @@ MAYBE_GLOBAL void test_complex_literals() {
   static_assert(std::is_same<decltype(0.5_if), c10::complex<float>>::value, "");
   static_assert((0.5_if).real() == float(), "");
   static_assert((0.5_if).imag() == float(0.5), "");
-  static_assert(std::is_same<decltype(0.5_id), c10::complex<double>>::value, "");
+  static_assert(
+      std::is_same<decltype(0.5_id), c10::complex<double>>::value, "");
   static_assert((0.5_id).real() == float(), "");
   static_assert((0.5_id).imag() == float(0.5), "");
 
@@ -274,14 +308,14 @@ MAYBE_GLOBAL void test_complex_literals() {
 
 namespace real_imag {
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> zero_one() {
   c10::complex<scalar_t> result;
   result.imag(scalar_t(1));
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> one_zero() {
   c10::complex<scalar_t> result;
   result.real(scalar_t(1));
@@ -304,35 +338,35 @@ MAYBE_GLOBAL void test_real_imag_modify() {
 
 namespace arithmetic_assign {
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> p(scalar_t value) {
   c10::complex<scalar_t> result(scalar_t(2), scalar_t(2));
   result += value;
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> m(scalar_t value) {
   c10::complex<scalar_t> result(scalar_t(2), scalar_t(2));
   result -= value;
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> t(scalar_t value) {
   c10::complex<scalar_t> result(scalar_t(2), scalar_t(2));
   result *= value;
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 constexpr c10::complex<scalar_t> d(scalar_t value) {
   c10::complex<scalar_t> result(scalar_t(2), scalar_t(2));
   result /= value;
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_arithmetic_assign_scalar() {
   constexpr c10::complex<scalar_t> x = p(scalar_t(1));
   static_assert(x.real() == scalar_t(3), "");
@@ -348,35 +382,47 @@ C10_HOST_DEVICE void test_arithmetic_assign_scalar() {
   static_assert(t.imag() == scalar_t(1), "");
 }
 
-template<typename scalar_t, typename rhs_t>
-constexpr c10::complex<scalar_t> p(scalar_t real, scalar_t imag, c10::complex<rhs_t> rhs) {
+template <typename scalar_t, typename rhs_t>
+constexpr c10::complex<scalar_t> p(
+    scalar_t real,
+    scalar_t imag,
+    c10::complex<rhs_t> rhs) {
   c10::complex<scalar_t> result(real, imag);
   result += rhs;
   return result;
 }
 
-template<typename scalar_t, typename rhs_t>
-constexpr c10::complex<scalar_t> m(scalar_t real, scalar_t imag, c10::complex<rhs_t> rhs) {
+template <typename scalar_t, typename rhs_t>
+constexpr c10::complex<scalar_t> m(
+    scalar_t real,
+    scalar_t imag,
+    c10::complex<rhs_t> rhs) {
   c10::complex<scalar_t> result(real, imag);
   result -= rhs;
   return result;
 }
 
-template<typename scalar_t, typename rhs_t>
-constexpr c10::complex<scalar_t> t(scalar_t real, scalar_t imag, c10::complex<rhs_t> rhs) {
+template <typename scalar_t, typename rhs_t>
+constexpr c10::complex<scalar_t> t(
+    scalar_t real,
+    scalar_t imag,
+    c10::complex<rhs_t> rhs) {
   c10::complex<scalar_t> result(real, imag);
   result *= rhs;
   return result;
 }
 
-template<typename scalar_t, typename rhs_t>
-constexpr c10::complex<scalar_t> d(scalar_t real, scalar_t imag, c10::complex<rhs_t> rhs) {
+template <typename scalar_t, typename rhs_t>
+constexpr c10::complex<scalar_t> d(
+    scalar_t real,
+    scalar_t imag,
+    c10::complex<rhs_t> rhs) {
   c10::complex<scalar_t> result(real, imag);
   result /= rhs;
   return result;
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_arithmetic_assign_complex() {
   using namespace c10::complex_literals;
   constexpr c10::complex<scalar_t> x2 = p(scalar_t(2), scalar_t(2), 1.0_if);
@@ -429,26 +475,64 @@ MAYBE_GLOBAL void test_arithmetic_assign() {
 
 namespace arithmetic {
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_arithmetic_() {
-  static_assert(c10::complex<scalar_t>(1, 2) == +c10::complex<scalar_t>(1, 2), "");
-  static_assert(c10::complex<scalar_t>(-1, -2) == -c10::complex<scalar_t>(1, 2), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) == +c10::complex<scalar_t>(1, 2), "");
+  static_assert(
+      c10::complex<scalar_t>(-1, -2) == -c10::complex<scalar_t>(1, 2), "");
 
-  static_assert(c10::complex<scalar_t>(1, 2) + c10::complex<scalar_t>(3, 4) == c10::complex<scalar_t>(4, 6), "");
-  static_assert(c10::complex<scalar_t>(1, 2) + scalar_t(3) == c10::complex<scalar_t>(4, 2), "");
-  static_assert(scalar_t(3) + c10::complex<scalar_t>(1, 2)  == c10::complex<scalar_t>(4, 2), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) + c10::complex<scalar_t>(3, 4) ==
+          c10::complex<scalar_t>(4, 6),
+      "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) + scalar_t(3) ==
+          c10::complex<scalar_t>(4, 2),
+      "");
+  static_assert(
+      scalar_t(3) + c10::complex<scalar_t>(1, 2) ==
+          c10::complex<scalar_t>(4, 2),
+      "");
 
-  static_assert(c10::complex<scalar_t>(1, 2) - c10::complex<scalar_t>(3, 4) == c10::complex<scalar_t>(-2, -2), "");
-  static_assert(c10::complex<scalar_t>(1, 2) - scalar_t(3) == c10::complex<scalar_t>(-2, 2), "");
-  static_assert(scalar_t(3) - c10::complex<scalar_t>(1, 2)  == c10::complex<scalar_t>(2, -2), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) - c10::complex<scalar_t>(3, 4) ==
+          c10::complex<scalar_t>(-2, -2),
+      "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) - scalar_t(3) ==
+          c10::complex<scalar_t>(-2, 2),
+      "");
+  static_assert(
+      scalar_t(3) - c10::complex<scalar_t>(1, 2) ==
+          c10::complex<scalar_t>(2, -2),
+      "");
 
-  static_assert(c10::complex<scalar_t>(1, 2) * c10::complex<scalar_t>(3, 4) == c10::complex<scalar_t>(-5, 10), "");
-  static_assert(c10::complex<scalar_t>(1, 2) * scalar_t(3) == c10::complex<scalar_t>(3, 6), "");
-  static_assert(scalar_t(3) * c10::complex<scalar_t>(1, 2)  == c10::complex<scalar_t>(3, 6), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) * c10::complex<scalar_t>(3, 4) ==
+          c10::complex<scalar_t>(-5, 10),
+      "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) * scalar_t(3) ==
+          c10::complex<scalar_t>(3, 6),
+      "");
+  static_assert(
+      scalar_t(3) * c10::complex<scalar_t>(1, 2) ==
+          c10::complex<scalar_t>(3, 6),
+      "");
 
-  static_assert(c10::complex<scalar_t>(-5, 10) / c10::complex<scalar_t>(3, 4) == c10::complex<scalar_t>(1, 2), "");
-  static_assert(c10::complex<scalar_t>(5, 10) / scalar_t(5) == c10::complex<scalar_t>(1, 2), "");
-  static_assert(scalar_t(25) / c10::complex<scalar_t>(3, 4)  == c10::complex<scalar_t>(3, -4), "");
+  static_assert(
+      c10::complex<scalar_t>(-5, 10) / c10::complex<scalar_t>(3, 4) ==
+          c10::complex<scalar_t>(1, 2),
+      "");
+  static_assert(
+      c10::complex<scalar_t>(5, 10) / scalar_t(5) ==
+          c10::complex<scalar_t>(1, 2),
+      "");
+  static_assert(
+      scalar_t(25) / c10::complex<scalar_t>(3, 4) ==
+          c10::complex<scalar_t>(3, -4),
+      "");
 }
 
 MAYBE_GLOBAL void test_arithmetic() {
@@ -456,7 +540,7 @@ MAYBE_GLOBAL void test_arithmetic() {
   test_arithmetic_<double>();
 }
 
-template<typename T, typename int_t>
+template <typename T, typename int_t>
 void test_binary_ops_for_int_type_(T real, T img, int_t num) {
   c10::complex<T> c(real, img);
   ASSERT_EQ(c + num, c10::complex<T>(real + num, img));
@@ -466,10 +550,12 @@ void test_binary_ops_for_int_type_(T real, T img, int_t num) {
   ASSERT_EQ(c * num, c10::complex<T>(real * num, img * num));
   ASSERT_EQ(num * c, c10::complex<T>(num * real, num * img));
   ASSERT_EQ(c / num, c10::complex<T>(real / num, img / num));
-  ASSERT_EQ(num / c, c10::complex<T>(num * real / std::norm(c), -num * img / std::norm(c)));
+  ASSERT_EQ(
+      num / c,
+      c10::complex<T>(num * real / std::norm(c), -num * img / std::norm(c)));
 }
 
-template<typename T>
+template <typename T>
 void test_binary_ops_for_all_int_types_(T real, T img, int8_t i) {
   test_binary_ops_for_int_type_<T, int8_t>(real, img, i);
   test_binary_ops_for_int_type_<T, int16_t>(real, img, i);
@@ -486,12 +572,14 @@ TEST(TestArithmeticIntScalar, All) {
 
 namespace equality {
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_equality_() {
-  static_assert(c10::complex<scalar_t>(1, 2) == c10::complex<scalar_t>(1, 2), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) == c10::complex<scalar_t>(1, 2), "");
   static_assert(c10::complex<scalar_t>(1, 0) == scalar_t(1), "");
   static_assert(scalar_t(1) == c10::complex<scalar_t>(1, 0), "");
-  static_assert(c10::complex<scalar_t>(1, 2) != c10::complex<scalar_t>(3, 4), "");
+  static_assert(
+      c10::complex<scalar_t>(1, 2) != c10::complex<scalar_t>(3, 4), "");
   static_assert(c10::complex<scalar_t>(1, 2) != scalar_t(1), "");
   static_assert(scalar_t(1) != c10::complex<scalar_t>(1, 2), "");
 }
@@ -505,7 +593,7 @@ MAYBE_GLOBAL void test_equality() {
 
 namespace io {
 
-template<typename scalar_t>
+template <typename scalar_t>
 void test_io_() {
   std::stringstream ss;
   c10::complex<scalar_t> a(1, 2);
@@ -525,14 +613,16 @@ TEST(TestIO, All) {
 
 namespace test_std {
 
-template<typename scalar_t>
+template <typename scalar_t>
 C10_HOST_DEVICE void test_callable_() {
   static_assert(std::real(c10::complex<scalar_t>(1, 2)) == scalar_t(1), "");
   static_assert(std::imag(c10::complex<scalar_t>(1, 2)) == scalar_t(2), "");
   std::abs(c10::complex<scalar_t>(1, 2));
   std::arg(c10::complex<scalar_t>(1, 2));
   static_assert(std::norm(c10::complex<scalar_t>(3, 4)) == scalar_t(25), "");
-  static_assert(std::conj(c10::complex<scalar_t>(3, 4)) == c10::complex<scalar_t>(3, -4), "");
+  static_assert(
+      std::conj(c10::complex<scalar_t>(3, 4)) == c10::complex<scalar_t>(3, -4),
+      "");
   c10::polar(float(1), float(PI / 2));
   c10::polar(double(1), double(PI / 2));
 }
@@ -542,11 +632,15 @@ MAYBE_GLOBAL void test_callable() {
   test_callable_<double>();
 }
 
-template<typename scalar_t>
+template <typename scalar_t>
 void test_values_() {
   ASSERT_EQ(std::abs(c10::complex<scalar_t>(3, 4)), scalar_t(5));
   ASSERT_LT(std::abs(std::arg(c10::complex<scalar_t>(0, 1)) - PI / 2), 1e-6);
-  ASSERT_LT(std::abs(c10::polar(scalar_t(1), scalar_t(PI / 2)) - c10::complex<scalar_t>(0, 1)), 1e-6);
+  ASSERT_LT(
+      std::abs(
+          c10::polar(scalar_t(1), scalar_t(PI / 2)) -
+          c10::complex<scalar_t>(0, 1)),
+      1e-6);
 }
 
 TEST(TestStd, BasicFunctions) {
@@ -554,8 +648,11 @@ TEST(TestStd, BasicFunctions) {
   test_values_<double>();
   // CSQRT edge cases: checks for overflows which are likely to occur
   // if square root is computed using polar form
-  ASSERT_LT(std::abs(std::sqrt(c10::complex<float>(-1e20, -4988429.2)).real()), 3e-4);
-  ASSERT_LT(std::abs(std::sqrt(c10::complex<double>(-1e60, -4988429.2)).real()), 3e-4);
+  ASSERT_LT(
+      std::abs(std::sqrt(c10::complex<float>(-1e20, -4988429.2)).real()), 3e-4);
+  ASSERT_LT(
+      std::abs(std::sqrt(c10::complex<double>(-1e60, -4988429.2)).real()),
+      3e-4);
 }
 
 } // namespace test_std
diff --git a/c10/test/util/either_test.cpp b/c10/test/util/either_test.cpp
index e4f963aaa79..a2bb42fc55c 100644
--- a/c10/test/util/either_test.cpp
+++ b/c10/test/util/either_test.cpp
@@ -1,1124 +1,1086 @@
-// Originally taken from https://raw.githubusercontent.com/cryfs/cryfs/14ad22570ddacef22d5ff139cdff68a54fc8234d/test/cpp-utils/either_test.cpp
+// Originally taken from
+// https://raw.githubusercontent.com/cryfs/cryfs/14ad22570ddacef22d5ff139cdff68a54fc8234d/test/cpp-utils/either_test.cpp
 
-#include <c10/util/either.h>
 #include <c10/macros/Macros.h>
-#include <gtest/gtest.h>
+#include <c10/util/either.h>
 #include <gmock/gmock.h>
-#include <vector>
+#include <gtest/gtest.h>
 #include <sstream>
+#include <vector>
 
-using std::string;
-using std::vector;
-using std::pair;
-using std::tuple;
-using std::ostringstream;
 using c10::either;
 using c10::make_left;
 using c10::make_right;
+using std::ostringstream;
+using std::pair;
+using std::string;
+using std::tuple;
+using std::vector;
 
 namespace {
 class MovableOnly final {
-public:
-    explicit MovableOnly(int value): _value(value) {}
-    MovableOnly(const MovableOnly&) = delete;
-    MovableOnly& operator=(const MovableOnly&) = delete;
+ public:
+  explicit MovableOnly(int value) : _value(value) {}
+  MovableOnly(const MovableOnly&) = delete;
+  MovableOnly& operator=(const MovableOnly&) = delete;
 
-    MovableOnly(MovableOnly&& rhs): _value(rhs._value) {
-      rhs._value = 0;
-    }
+  MovableOnly(MovableOnly&& rhs) : _value(rhs._value) {
+    rhs._value = 0;
+  }
 
-    MovableOnly& operator=(MovableOnly&& rhs) {
-      _value = rhs._value;
-      rhs._value = 0;
-      return *this;
-    }
+  MovableOnly& operator=(MovableOnly&& rhs) {
+    _value = rhs._value;
+    rhs._value = 0;
+    return *this;
+  }
 
-    int value() const {
-        return _value;
-    }
+  int value() const {
+    return _value;
+  }
 
-private:
-    int _value;
+ private:
+  int _value;
 };
 
 bool operator==(const MovableOnly& lhs, const MovableOnly& rhs) {
   return lhs.value() == rhs.value();
 }
 
-template<class T>
-void test_with_matrix(std::vector<std::function<void(std::function<void(T&)>)>> setups, std::vector<std::function<void(T&)>> expectations) {
-  for (const auto& setup: setups) {
-    for (const auto& expectation: expectations) {
+template <class T>
+void test_with_matrix(
+    std::vector<std::function<void(std::function<void(T&)>)>> setups,
+    std::vector<std::function<void(T&)>> expectations) {
+  for (const auto& setup : setups) {
+    for (const auto& expectation : expectations) {
       setup(expectation);
     }
   }
 }
 
-template<class Left, class Right>
-std::vector<std::function<void(either<Left, Right>&)>> EXPECT_IS_LEFT(const Left& expected) {
+template <class Left, class Right>
+std::vector<std::function<void(either<Left, Right>&)>> EXPECT_IS_LEFT(
+    const Left& expected) {
   return {
-    [&] (either<Left, Right>& obj) {
-      EXPECT_TRUE(obj.is_left());
-    }, [&] (either<Left, Right>& obj) {
-      EXPECT_FALSE(obj.is_right());
-    }, [&] (either<Left, Right>& obj) {
-      EXPECT_EQ(expected, obj.left());
-    }, [&] (either<Left, Right>& obj) {
-      EXPECT_EQ(expected, std::move(obj).left());
-    }, [&] (either<Left, Right>& obj) {
-      // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-      EXPECT_ANY_THROW(obj.right());
-    }, [&] (either<Left, Right>& obj) {
-      // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
-      EXPECT_ANY_THROW(std::move(obj).right());
-    }
-  };
+      [&](either<Left, Right>& obj) { EXPECT_TRUE(obj.is_left()); },
+      [&](either<Left, Right>& obj) { EXPECT_FALSE(obj.is_right()); },
+      [&](either<Left, Right>& obj) { EXPECT_EQ(expected, obj.left()); },
+      [&](either<Left, Right>& obj) {
+        EXPECT_EQ(expected, std::move(obj).left());
+      },
+      [&](either<Left, Right>& obj) {
+        // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+        EXPECT_ANY_THROW(obj.right());
+      },
+      [&](either<Left, Right>& obj) {
+        // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
+        EXPECT_ANY_THROW(std::move(obj).right());
+      }};
 }
 
-template<class Left, class Right>
-std::vector<std::function<void(either<Left, Right>&)>> EXPECT_IS_RIGHT(const Right& expected) {
+template <class Left, class Right>
+std::vector<std::function<void(either<Left, Right>&)>> EXPECT_IS_RIGHT(
+    const Right& expected) {
   return {
-      [&] (either<Left, Right>& obj) {
-        EXPECT_FALSE(obj.is_left());
-      }, [&] (either<Left, Right>& obj) {
-        EXPECT_TRUE(obj.is_right());
-      }, [&] (either<Left, Right>& obj) {
-        EXPECT_EQ(expected, obj.right());
-      }, [&] (either<Left, Right>& obj) {
+      [&](either<Left, Right>& obj) { EXPECT_FALSE(obj.is_left()); },
+      [&](either<Left, Right>& obj) { EXPECT_TRUE(obj.is_right()); },
+      [&](either<Left, Right>& obj) { EXPECT_EQ(expected, obj.right()); },
+      [&](either<Left, Right>& obj) {
         EXPECT_EQ(expected, std::move(obj).right());
-      }, [&] (either<Left, Right>& obj) {
+      },
+      [&](either<Left, Right>& obj) {
         // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
         EXPECT_ANY_THROW(obj.left());
-      }, [&] (either<Left, Right>& obj) {
+      },
+      [&](either<Left, Right>& obj) {
         // NOLINTNEXTLINE(hicpp-avoid-goto,cppcoreguidelines-avoid-goto)
         EXPECT_ANY_THROW(std::move(obj).left());
-      }
-  };
+      }};
 }
 
-template<class Value>
+template <class Value>
 std::vector<std::function<void(Value&)>> EXPECT_IS(const Value& v) {
-  return {
-    [&] (Value& obj) {
-      return obj == v;
-    }
-  };
+  return {[&](Value& obj) { return obj == v; }};
 }
 
-template<typename T>
+template <typename T>
 struct StoreWith1ByteFlag {
   T val;
   char flag;
 };
 
-template<typename Left, typename Right>
+template <typename Left, typename Right>
 void TestSpaceUsage() {
-    EXPECT_EQ(std::max(sizeof(StoreWith1ByteFlag<Left>), sizeof(StoreWith1ByteFlag<Right>)), sizeof(either<Left, Right>));
-}
+  EXPECT_EQ(
+      std::max(
+          sizeof(StoreWith1ByteFlag<Left>), sizeof(StoreWith1ByteFlag<Right>)),
+      sizeof(either<Left, Right>));
 }
+} // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, SpaceUsage) {
-    TestSpaceUsage<char, int>();
-    TestSpaceUsage<int, short>();
-    TestSpaceUsage<char, short>();
-    TestSpaceUsage<int, string>();
-    TestSpaceUsage<string, vector<string>>();
+  TestSpaceUsage<char, int>();
+  TestSpaceUsage<int, short>();
+  TestSpaceUsage<char, short>();
+  TestSpaceUsage<int, string>();
+  TestSpaceUsage<string, vector<string>>();
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeft) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a(4);
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a = 4;
-        test(a);
+  test_with_matrix(
+      {
+          [](std::function<void(either<int, string>&)> test) {
+            either<int, string> a(4);
+            test(a);
+          },
+          [](std::function<void(either<int, string>&)> test) {
+            either<int, string> a = 4;
+            test(a);
+          },
       },
-    },
-    EXPECT_IS_LEFT<int, string>(4)
-  );
+      EXPECT_IS_LEFT<int, string>(4));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRight) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a = string("4");
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         test(a);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         either<int, string> a = string("4");
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMakeLeft) {
-    test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a = make_left<int, string>(4);
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        auto a = make_left<int, string>(4);
-        test(a);
+  test_with_matrix(
+      {
+          [](std::function<void(either<int, string>&)> test) {
+            either<int, string> a = make_left<int, string>(4);
+            test(a);
+          },
+          [](std::function<void(either<int, string>&)> test) {
+            auto a = make_left<int, string>(4);
+            test(a);
+          },
       },
-    },
-    EXPECT_IS_LEFT<int, string>(4)
-  );
+      EXPECT_IS_LEFT<int, string>(4));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMakeLeftWithSameType) {
-  test_with_matrix({
-      [] (std::function<void(either<int, int>&)> test) {
-        either<int, int> a = make_left<int, int>(4);
-        test(a);
-      }, [] (std::function<void(either<int, int>&)> test) {
-        auto a = make_left<int, int>(4);
-        test(a);
+  test_with_matrix(
+      {
+          [](std::function<void(either<int, int>&)> test) {
+            either<int, int> a = make_left<int, int>(4);
+            test(a);
+          },
+          [](std::function<void(either<int, int>&)> test) {
+            auto a = make_left<int, int>(4);
+            test(a);
+          },
       },
-    },
-    EXPECT_IS_LEFT<int, int>(4)
-  );
+      EXPECT_IS_LEFT<int, int>(4));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMakeRight) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a = make_right<int, string>("4");
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        auto a = make_right<int, string>("4");
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a = make_right<int, string>("4");
+         test(a);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         auto a = make_right<int, string>("4");
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMakeRightWithSameType) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_right<string, string>("4");
-        test(a);
-      }, [] (std::function<void(either<string, string>&)> test) {
-        auto a = make_right<string, string>("4");
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<string, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_right<string, string>("4");
+         test(a);
+       },
+       [](std::function<void(either<string, string>&)> test) {
+         auto a = make_right<string, string>("4");
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMovableOnlyMakeLeft) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, string>&)> test) {
-        either<MovableOnly, string> a = make_left<MovableOnly, string>(3);
-        test(a);
-      }, [] (std::function<void(either<MovableOnly, string>&)> test) {
-        auto a = make_left<MovableOnly, string>(3);
-        test(a);
+  test_with_matrix(
+      {
+          [](std::function<void(either<MovableOnly, string>&)> test) {
+            either<MovableOnly, string> a = make_left<MovableOnly, string>(3);
+            test(a);
+          },
+          [](std::function<void(either<MovableOnly, string>&)> test) {
+            auto a = make_left<MovableOnly, string>(3);
+            test(a);
+          },
       },
-    },
-    EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3))
-  );
+      EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMovableOnlyMakeRight) {
-  test_with_matrix({
-      [] (std::function<void(either<int, MovableOnly>&)> test) {
-        either<int, MovableOnly> a = make_right<int, MovableOnly>(3);
-        test(a);
-      }, [] (std::function<void(either<int, MovableOnly>&)> test) {
-        auto a = make_right<int, MovableOnly>(3);
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, MovableOnly>&)> test) {
+         either<int, MovableOnly> a = make_right<int, MovableOnly>(3);
+         test(a);
+       },
+       [](std::function<void(either<int, MovableOnly>&)> test) {
+         auto a = make_right<int, MovableOnly>(3);
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMultiParamMakeLeft) {
-  test_with_matrix({
-      [] (std::function<void(either<pair<int, int>, string>&)> test) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        either<pair<int, int>, string> a = make_left<pair<int, int>, string>(5, 6);
-        test(a);
-      }, [] (std::function<void(either<pair<int, int>, string>&)> test) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto a = make_left<pair<int, int>, string>(5, 6);
-        test(a);
+  test_with_matrix(
+      {
+          [](std::function<void(either<pair<int, int>, string>&)> test) {
+            // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+            either<pair<int, int>, string> a =
+                make_left<pair<int, int>, string>(5, 6);
+            test(a);
+          },
+          [](std::function<void(either<pair<int, int>, string>&)> test) {
+            // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+            auto a = make_left<pair<int, int>, string>(5, 6);
+            test(a);
+          },
       },
-    },
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    EXPECT_IS_LEFT<pair<int, int>, string>(pair<int, int>(5, 6))
-  );
+      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+      EXPECT_IS_LEFT<pair<int, int>, string>(pair<int, int>(5, 6)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenMultiParamMakeRight) {
-  test_with_matrix({
-      [] (std::function<void(either<int, pair<int, int>>&)> test) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        either<int, pair<int, int>> a = make_right<int, pair<int, int>>(5, 6);
-        test(a);
-      }, [] (std::function<void(either<int, pair<int, int>>&)> test) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        auto a = make_right<int, pair<int, int>>(5, 6);
-        test(a);
-      }
-    },
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    EXPECT_IS_RIGHT<int, pair<int, int>>(pair<int, int>(5, 6))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, pair<int, int>>&)> test) {
+         // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+         either<int, pair<int, int>> a = make_right<int, pair<int, int>>(5, 6);
+         test(a);
+       },
+       [](std::function<void(either<int, pair<int, int>>&)> test) {
+         // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+         auto a = make_right<int, pair<int, int>>(5, 6);
+         test(a);
+       }},
+      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+      EXPECT_IS_RIGHT<int, pair<int, int>>(pair<int, int>(5, 6)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
         string a = "4";
         either<string, int> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+      }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(string&)> test) {
+  test_with_matrix(
+      {[](std::function<void(string&)> test) {
         string a = "4";
         either<string, int> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS<string>("4")
-  );
+      }},
+      EXPECT_IS<string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
         string a = "4";
         either<int, string> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+      }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(string&)> test) {
+  test_with_matrix(
+      {[](std::function<void(string&)> test) {
         string a = "4";
         either<int, string> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS<string>("4")
-  );
+      }},
+      EXPECT_IS<string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, int>&)> test) {
         MovableOnly a(3);
         either<MovableOnly, int> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(MovableOnly&)> test) {
+  test_with_matrix(
+      {[](std::function<void(MovableOnly&)> test) {
         MovableOnly a(3);
         either<MovableOnly, int> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS<MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS<MovableOnly>(MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, MovableOnly>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, MovableOnly>&)> test) {
         MovableOnly a(3);
         either<int, MovableOnly> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(MovableOnly&)> test) {
+  test_with_matrix(
+      {[](std::function<void(MovableOnly&)> test) {
         MovableOnly a(3);
         either<int, MovableOnly> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS<MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS<MovableOnly>(MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssignedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
-        string a = "4";
-        either<string, int> b(2);
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<string, int>&)> test) {
-        string a = "4";
-        either<string, int> b("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
+         string a = "4";
+         either<string, int> b(2);
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<string, int>&)> test) {
+         string a = "4";
+         either<string, int> b("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssignedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(string&)> test) {
-        string a = "4";
-        either<string, int> b(2);
-        b = a;
-        test(a);
-      }, [] (std::function<void(string&)> test) {
-        string a = "4";
-        either<string, int> b("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS<string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(string&)> test) {
+         string a = "4";
+         either<string, int> b(2);
+         b = a;
+         test(a);
+       },
+       [](std::function<void(string&)> test) {
+         string a = "4";
+         either<string, int> b("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS<string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssignedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        string a = "4";
-        either<int, string> b(2);
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        string a = "4";
-        either<int, string> b("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         string a = "4";
+         either<int, string> b(2);
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         string a = "4";
+         either<int, string> b("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssignedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(string&)> test) {
-        string a = "4";
-        either<int, string> b(2);
-        b = a;
-        test(a);
-      }, [] (std::function<void(string&)> test) {
-        string a = "4";
-        either<int, string> b("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS<string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(string&)> test) {
+         string a = "4";
+         either<int, string> b(2);
+         b = a;
+         test(a);
+       },
+       [](std::function<void(string&)> test) {
+         string a = "4";
+         either<int, string> b("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS<string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssignedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, string>&)> test) {
-        MovableOnly a(3);
-        either<MovableOnly, string> b(2);
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<MovableOnly, string>&)> test) {
-        MovableOnly a(3);
-        either<MovableOnly, string> b(MovableOnly(2));
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, string>&)> test) {
+         MovableOnly a(3);
+         either<MovableOnly, string> b(2);
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<MovableOnly, string>&)> test) {
+         MovableOnly a(3);
+         either<MovableOnly, string> b(MovableOnly(2));
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssignedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(MovableOnly&)> test) {
-        MovableOnly a(3);
-        either<MovableOnly, string> b("2");
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(MovableOnly&)> test) {
-        MovableOnly a(3);
-        either<MovableOnly, string> b(MovableOnly(0));
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS<MovableOnly>(MovableOnly(0))
-  );
+  test_with_matrix(
+      {[](std::function<void(MovableOnly&)> test) {
+         MovableOnly a(3);
+         either<MovableOnly, string> b("2");
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(MovableOnly&)> test) {
+         MovableOnly a(3);
+         either<MovableOnly, string> b(MovableOnly(0));
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS<MovableOnly>(MovableOnly(0)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssignedFromValue_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, MovableOnly>&)> test) {
-        MovableOnly a(3);
-        either<string, MovableOnly> b("2");
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<string, MovableOnly>&)> test) {
-        MovableOnly a(3);
-        either<string, MovableOnly> b(MovableOnly(2));
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<string, MovableOnly>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, MovableOnly>&)> test) {
+         MovableOnly a(3);
+         either<string, MovableOnly> b("2");
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<string, MovableOnly>&)> test) {
+         MovableOnly a(3);
+         either<string, MovableOnly> b(MovableOnly(2));
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<string, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssignedFromValue_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(MovableOnly&)> test) {
-        MovableOnly a(3);
-        either<string, MovableOnly> b("2");
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(MovableOnly&)> test) {
-        MovableOnly a(3);
-        either<string, MovableOnly> b(MovableOnly(2));
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS<MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+  test_with_matrix(
+      {[](std::function<void(MovableOnly&)> test) {
+         MovableOnly a(3);
+         either<string, MovableOnly> b("2");
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(MovableOnly&)> test) {
+         MovableOnly a(3);
+         either<string, MovableOnly> b(MovableOnly(2));
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS<MovableOnly>(MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructed_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
         either<string, int> a("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, int> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+      }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructed_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
         either<string, int> a("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, int> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+      }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructed_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
         either<string, string> a = make_left<string, string>("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, string> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, string>("4")
-  );
+      }},
+      EXPECT_IS_LEFT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyConstructed_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
         either<string, string> a = make_left<string, string>("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, string> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS_LEFT<string, string>("4")
-  );
+      }},
+      EXPECT_IS_LEFT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructed_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
         either<int, string> a("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<int, string> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+      }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructed_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
         either<int, string> a("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<int, string> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+      }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructed_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
         either<string, string> a = make_right<string, string>("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, string> b(a);
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<string, string>("4")
-  );
+      }},
+      EXPECT_IS_RIGHT<string, string>("4"));
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyConstructed_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
         either<string, string> a = make_right<string, string>("4");
         // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
         either<string, string> b(a);
         test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<string, string>("4")
-  );
+      }},
+      EXPECT_IS_RIGHT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructed_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, int>&)> test) {
         either<MovableOnly, int> a(MovableOnly(3));
         either<MovableOnly, int> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructed_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, int>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, int>&)> test) {
         either<MovableOnly, int> a(MovableOnly(3));
         either<MovableOnly, int> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS_LEFT<MovableOnly, int>(MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructed_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(MovableOnly(3));
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+        either<MovableOnly, MovableOnly> a =
+            make_left<MovableOnly, MovableOnly>(MovableOnly(3));
         either<MovableOnly, MovableOnly> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveConstructed_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(MovableOnly(3));
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+        either<MovableOnly, MovableOnly> a =
+            make_left<MovableOnly, MovableOnly>(MovableOnly(3));
         either<MovableOnly, MovableOnly> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS_LEFT<MovableOnly, MovableOnly>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructed_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, MovableOnly>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, MovableOnly>&)> test) {
         either<int, MovableOnly> a(MovableOnly(3));
         either<int, MovableOnly> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructed_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, MovableOnly>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<int, MovableOnly>&)> test) {
         either<int, MovableOnly> a(MovableOnly(3));
         either<int, MovableOnly> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS_RIGHT<int, MovableOnly>(MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructed_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(MovableOnly(3));
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+        either<MovableOnly, MovableOnly> a =
+            make_right<MovableOnly, MovableOnly>(MovableOnly(3));
         either<MovableOnly, MovableOnly> b(std::move(a));
         test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(3))
-  );
+      }},
+      EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveConstructed_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(MovableOnly(3));
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+        either<MovableOnly, MovableOnly> a =
+            make_right<MovableOnly, MovableOnly>(MovableOnly(3));
         either<MovableOnly, MovableOnly> b(std::move(a));
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(0))  // 0 is moved-from value
+        test(a); // NOLINT(bugprone-use-after-move)
+      }},
+      EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssigned_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
-        either<string, int> a("4");
-        either<string, int> b(2);
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<string, int>&)> test) {
-        either<string, int> a("4");
-        either<string, int> b("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
+         either<string, int> a("4");
+         either<string, int> b(2);
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<string, int>&)> test) {
+         either<string, int> a("4");
+         either<string, int> b("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssigned_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, int>&)> test) {
-        either<string, int> a("4");
-        either<string, int> b(2);
-        b = a;
-        test(a);
-      }, [] (std::function<void(either<string, int>&)> test) {
-        either<string, int> a("4");
-        either<string, int> b("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS_LEFT<string, int>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, int>&)> test) {
+         either<string, int> a("4");
+         either<string, int> b(2);
+         b = a;
+         test(a);
+       },
+       [](std::function<void(either<string, int>&)> test) {
+         either<string, int> a("4");
+         either<string, int> b("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS_LEFT<string, int>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssigned_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_left<string, string>("4");
-        either<string, string> b = make_right<string, string>("2");
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_left<string, string>("4");
-        either<string, string> b = make_left<string, string>("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<string, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_left<string, string>("4");
+         either<string, string> b = make_right<string, string>("2");
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_left<string, string>("4");
+         either<string, string> b = make_left<string, string>("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_LEFT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftCopyAssigned_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_left<string, string>("4");
-        either<string, string> b = make_right<string, string>("2");
-        b = a;
-        test(a);
-      }, [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_left<string, string>("4");
-        either<string, string> b = make_left<string, string>("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS_LEFT<string, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_left<string, string>("4");
+         either<string, string> b = make_right<string, string>("2");
+         b = a;
+         test(a);
+       },
+       [](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_left<string, string>("4");
+         either<string, string> b = make_left<string, string>("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS_LEFT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssigned_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        either<int, string> b(2);
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        either<int, string> b("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         either<int, string> b(2);
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         either<int, string> b("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssigned_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        either<int, string> b(2);
-        b = a;
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        either<int, string> b("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         either<int, string> b(2);
+         b = a;
+         test(a);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         either<int, string> b("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<int, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssigned_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_right<string, string>("4");
-        either<string, string> b = make_left<string, string>("2");
-        b = a;
-        test(b);
-      }, [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_right<string, string>("4");
-        either<string, string> b = make_right<string, string>("2");
-        b = a;
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<string, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_right<string, string>("4");
+         either<string, string> b = make_left<string, string>("2");
+         b = a;
+         test(b);
+       },
+       [](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_right<string, string>("4");
+         either<string, string> b = make_right<string, string>("2");
+         b = a;
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightCopyAssigned_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_right<string, string>("4");
-        either<string, string> b = make_left<string, string>("2");
-        b = a;
-        test(a);
-      }, [] (std::function<void(either<string, string>&)> test) {
-        either<string, string> a = make_right<string, string>("4");
-        either<string, string> b = make_right<string, string>("2");
-        b = a;
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<string, string>("4")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_right<string, string>("4");
+         either<string, string> b = make_left<string, string>("2");
+         b = a;
+         test(a);
+       },
+       [](std::function<void(either<string, string>&)> test) {
+         either<string, string> a = make_right<string, string>("4");
+         either<string, string> b = make_right<string, string>("2");
+         b = a;
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<string, string>("4"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssigned_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, string>&)> test) {
-        either<MovableOnly, string> a(MovableOnly(3));
-        either<MovableOnly, string> b(2);
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<MovableOnly, string>&)> test) {
-        either<MovableOnly, string> a(MovableOnly(3));
-        either<MovableOnly, string> b(MovableOnly(2));
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, string>&)> test) {
+         either<MovableOnly, string> a(MovableOnly(3));
+         either<MovableOnly, string> b(2);
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<MovableOnly, string>&)> test) {
+         either<MovableOnly, string> a(MovableOnly(3));
+         either<MovableOnly, string> b(MovableOnly(2));
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssigned_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, string>&)> test) {
-        either<MovableOnly, string> a(MovableOnly(3));
-        either<MovableOnly, string> b(2);
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(either<MovableOnly, string>&)> test) {
-        either<MovableOnly, string> a(MovableOnly(3));
-        either<MovableOnly, string> b(MovableOnly(2));
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, string>(MovableOnly(0)) // 0 is moved-from value
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, string>&)> test) {
+         either<MovableOnly, string> a(MovableOnly(3));
+         either<MovableOnly, string> b(2);
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(either<MovableOnly, string>&)> test) {
+         either<MovableOnly, string> a(MovableOnly(3));
+         either<MovableOnly, string> b(MovableOnly(2));
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS_LEFT<MovableOnly, string>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssigned_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_right<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_left<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_left<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_right<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_left<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_left<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeftMoveAssigned_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_right<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_left<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_left<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_LEFT<MovableOnly, MovableOnly>(MovableOnly(0)) // 0 is moved-from value
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_left<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_right<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_left<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_left<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS_LEFT<MovableOnly, MovableOnly>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssigned_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, MovableOnly>&)> test) {
-        either<string, MovableOnly> a(MovableOnly(3));
-        either<string, MovableOnly> b("2");
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<string, MovableOnly>&)> test) {
-        either<string, MovableOnly> a(MovableOnly(3));
-        either<string, MovableOnly> b(MovableOnly(2));
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<string, MovableOnly>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<string, MovableOnly>&)> test) {
+         either<string, MovableOnly> a(MovableOnly(3));
+         either<string, MovableOnly> b("2");
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<string, MovableOnly>&)> test) {
+         either<string, MovableOnly> a(MovableOnly(3));
+         either<string, MovableOnly> b(MovableOnly(2));
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<string, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssigned_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<string, MovableOnly>&)> test) {
-        either<string, MovableOnly> a(MovableOnly(3));
-        either<string, MovableOnly> b("2");
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(either<string, MovableOnly>&)> test) {
-        either<string, MovableOnly> a(MovableOnly(3));
-        either<string, MovableOnly> b(MovableOnly(2));
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_RIGHT<string, MovableOnly>(MovableOnly(0)) // 0 is moved-from value
+  test_with_matrix(
+      {[](std::function<void(either<string, MovableOnly>&)> test) {
+         either<string, MovableOnly> a(MovableOnly(3));
+         either<string, MovableOnly> b("2");
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(either<string, MovableOnly>&)> test) {
+         either<string, MovableOnly> a(MovableOnly(3));
+         either<string, MovableOnly> b(MovableOnly(2));
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS_RIGHT<string, MovableOnly>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssigned_withSameType_thenNewIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_left<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(b);
-      }, [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_right<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(b);
-      }
-    },
-    EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(3))
-  );
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_right<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_left<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(b);
+       },
+       [](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_right<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_right<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(b);
+       }},
+      EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRightMoveAssigned_withSameType_thenOldIsCorrect) {
-  test_with_matrix({
-      [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_left<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }, [] (std::function<void(either<MovableOnly, MovableOnly>&)> test) {
-        either<MovableOnly, MovableOnly> a = make_right<MovableOnly, MovableOnly>(3);
-        either<MovableOnly, MovableOnly> b = make_right<MovableOnly, MovableOnly>(2);
-        b = std::move(a);
-        test(a);  // NOLINT(bugprone-use-after-move)
-      }
-    },
-    EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(MovableOnly(0)) // 0 is moved-from value
+  test_with_matrix(
+      {[](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_right<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_left<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       },
+       [](std::function<void(either<MovableOnly, MovableOnly>&)> test) {
+         either<MovableOnly, MovableOnly> a =
+             make_right<MovableOnly, MovableOnly>(3);
+         either<MovableOnly, MovableOnly> b =
+             make_right<MovableOnly, MovableOnly>(2);
+         b = std::move(a);
+         test(a); // NOLINT(bugprone-use-after-move)
+       }},
+      EXPECT_IS_RIGHT<MovableOnly, MovableOnly>(
+          MovableOnly(0)) // 0 is moved-from value
   );
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenLeft_whenModified_thenValueIsChanged) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a(4);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        a.left() = 5;
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a(4);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        a.left() = 5;
-        test(a);
-      }
-    },
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    EXPECT_IS_LEFT<int, string>(5)
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a(4);
+         // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+         a.left() = 5;
+         test(a);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         either<int, string> a(4);
+         // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+         a.left() = 5;
+         test(a);
+       }},
+      // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+      EXPECT_IS_LEFT<int, string>(5));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, givenRight_whenModified_thenValueIsChanged) {
-  test_with_matrix({
-      [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        a.right() = "5";
-        test(a);
-      }, [] (std::function<void(either<int, string>&)> test) {
-        either<int, string> a("4");
-        a.right() = "5";
-        test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<int, string>("5")
-  );
+  test_with_matrix(
+      {[](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         a.right() = "5";
+         test(a);
+       },
+       [](std::function<void(either<int, string>&)> test) {
+         either<int, string> a("4");
+         a.right() = "5";
+         test(a);
+       }},
+      EXPECT_IS_RIGHT<int, string>("5"));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, canEmplaceConstructLeft) {
-  test_with_matrix({
-      [] (std::function<void(either<tuple<int, int>, tuple<int, string, int>>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<tuple<int, int>, tuple<int, string, int>>&)>
+              test) {
         either<tuple<int, int>, tuple<int, string, int>> a(2, 3);
         test(a);
-      }
-    },
-    EXPECT_IS_LEFT<tuple<int, int>, tuple<int, string, int>>(tuple<int, int>(2, 3))
-  );
+      }},
+      EXPECT_IS_LEFT<tuple<int, int>, tuple<int, string, int>>(
+          tuple<int, int>(2, 3)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest, canEmplaceConstructRight) {
-  test_with_matrix({
-      [] (std::function<void(either<tuple<int, int>, tuple<int, string, int>>&)> test) {
+  test_with_matrix(
+      {[](std::function<void(either<tuple<int, int>, tuple<int, string, int>>&)>
+              test) {
         either<tuple<int, int>, tuple<int, string, int>> a(2, "3", 4);
         test(a);
-      }
-    },
-    EXPECT_IS_RIGHT<tuple<int, int>, tuple<int, string, int>>(tuple<int, string, int>(2, "3", 4))
-  );
+      }},
+      EXPECT_IS_RIGHT<tuple<int, int>, tuple<int, string, int>>(
+          tuple<int, string, int>(2, "3", 4)));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -1195,10 +1157,9 @@ TEST(EitherTest, givenLeftAndRightWithSameType_thenAreUnequal) {
   EXPECT_TRUE(b != a);
 }
 
-
 namespace {
 class DestructorCallback {
-public:
+ public:
   MOCK_CONST_METHOD0(call, void());
 
   void EXPECT_CALLED(int times = 1) {
@@ -1206,149 +1167,182 @@ public:
   }
 };
 class ClassWithDestructorCallback {
-public:
-  ClassWithDestructorCallback(const DestructorCallback *destructorCallback) : _destructorCallback(destructorCallback) {}
+ public:
+  ClassWithDestructorCallback(const DestructorCallback* destructorCallback)
+      : _destructorCallback(destructorCallback) {}
   // NOLINTNEXTLINE(modernize-use-equals-default)
-  ClassWithDestructorCallback(const ClassWithDestructorCallback &rhs): _destructorCallback(rhs._destructorCallback) {}
+  ClassWithDestructorCallback(const ClassWithDestructorCallback& rhs)
+      : _destructorCallback(rhs._destructorCallback) {}
 
   ~ClassWithDestructorCallback() {
     _destructorCallback->call();
   }
 
-private:
-  const DestructorCallback *_destructorCallback;
+ private:
+  const DestructorCallback* _destructorCallback;
 
   // NOLINTNEXTLINE(modernize-use-equals-delete)
-  ClassWithDestructorCallback &operator=(const ClassWithDestructorCallback &rhs) = delete;
+  ClassWithDestructorCallback& operator=(
+      const ClassWithDestructorCallback& rhs) = delete;
 };
 class OnlyMoveableClassWithDestructorCallback {
-public:
-  OnlyMoveableClassWithDestructorCallback(const DestructorCallback *destructorCallback) : _destructorCallback(destructorCallback) { }
-  OnlyMoveableClassWithDestructorCallback(OnlyMoveableClassWithDestructorCallback &&source): _destructorCallback(source._destructorCallback) {}
+ public:
+  OnlyMoveableClassWithDestructorCallback(
+      const DestructorCallback* destructorCallback)
+      : _destructorCallback(destructorCallback) {}
+  OnlyMoveableClassWithDestructorCallback(
+      OnlyMoveableClassWithDestructorCallback&& source)
+      : _destructorCallback(source._destructorCallback) {}
 
   ~OnlyMoveableClassWithDestructorCallback() {
     _destructorCallback->call();
   }
 
-private:
+ private:
   C10_DISABLE_COPY_AND_ASSIGN(OnlyMoveableClassWithDestructorCallback);
-  const DestructorCallback *_destructorCallback;
+  const DestructorCallback* _destructorCallback;
 };
 
-}
+} // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, LeftDestructorIsCalled) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(2);  //Once for the temp object, once when the either class destructs
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      2); // Once for the temp object, once when the either class destructs
 
-    ClassWithDestructorCallback temp(&destructorCallback);
-    either<ClassWithDestructorCallback, string> var = temp;
+  ClassWithDestructorCallback temp(&destructorCallback);
+  either<ClassWithDestructorCallback, string> var = temp;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, RightDestructorIsCalled) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(2);  //Once for the temp object, once when the either class destructs
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      2); // Once for the temp object, once when the either class destructs
 
-    ClassWithDestructorCallback temp(&destructorCallback);
-    either<string, ClassWithDestructorCallback> var = temp;
+  ClassWithDestructorCallback temp(&destructorCallback);
+  either<string, ClassWithDestructorCallback> var = temp;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, LeftDestructorIsCalledAfterCopying) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      3); // Once for the temp object, once for var1 and once for var2
 
-    ClassWithDestructorCallback temp(&destructorCallback);
-    either<ClassWithDestructorCallback, string> var1 = temp;
-    // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
-    either<ClassWithDestructorCallback, string> var2 = var1;
+  ClassWithDestructorCallback temp(&destructorCallback);
+  either<ClassWithDestructorCallback, string> var1 = temp;
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
+  either<ClassWithDestructorCallback, string> var2 = var1;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, RightDestructorIsCalledAfterCopying) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      3); // Once for the temp object, once for var1 and once for var2
 
-    ClassWithDestructorCallback temp(&destructorCallback);
-    either<string, ClassWithDestructorCallback> var1 = temp;
-    // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
-    either<string, ClassWithDestructorCallback> var2 = var1;
+  ClassWithDestructorCallback temp(&destructorCallback);
+  either<string, ClassWithDestructorCallback> var1 = temp;
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
+  either<string, ClassWithDestructorCallback> var2 = var1;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, LeftDestructorIsCalledAfterMoving) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      3); // Once for the temp object, once for var1 and once for var2
 
-    OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
-    either<OnlyMoveableClassWithDestructorCallback, string> var1 = std::move(temp);
-    either<OnlyMoveableClassWithDestructorCallback, string> var2 = std::move(var1);
+  OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
+  either<OnlyMoveableClassWithDestructorCallback, string> var1 =
+      std::move(temp);
+  either<OnlyMoveableClassWithDestructorCallback, string> var2 =
+      std::move(var1);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, RightDestructorIsCalledAfterMoving) {
-    DestructorCallback destructorCallback;
-    destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2
+  DestructorCallback destructorCallback;
+  destructorCallback.EXPECT_CALLED(
+      3); // Once for the temp object, once for var1 and once for var2
 
-    OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
-    either<string, OnlyMoveableClassWithDestructorCallback> var1 = std::move(temp);
-    either<string, OnlyMoveableClassWithDestructorCallback> var2 = std::move(var1);
+  OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
+  either<string, OnlyMoveableClassWithDestructorCallback> var1 =
+      std::move(temp);
+  either<string, OnlyMoveableClassWithDestructorCallback> var2 =
+      std::move(var1);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, LeftDestructorIsCalledAfterAssignment) {
-    DestructorCallback destructorCallback1;
-    DestructorCallback destructorCallback2;
-    destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
-    destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1
+  DestructorCallback destructorCallback1;
+  DestructorCallback destructorCallback2;
+  destructorCallback1.EXPECT_CALLED(
+      2); // Once for the temp1 object, once at the assignment
+  destructorCallback2.EXPECT_CALLED(
+      3); // Once for the temp2 object, once in destructor of var2, once in
+          // destructor of var1
 
-    ClassWithDestructorCallback temp1(&destructorCallback1);
-    either<ClassWithDestructorCallback, string> var1 = temp1;
-    ClassWithDestructorCallback temp2(&destructorCallback2);
-    either<ClassWithDestructorCallback, string> var2 = temp2;
-    var1 = var2;
+  ClassWithDestructorCallback temp1(&destructorCallback1);
+  either<ClassWithDestructorCallback, string> var1 = temp1;
+  ClassWithDestructorCallback temp2(&destructorCallback2);
+  either<ClassWithDestructorCallback, string> var2 = temp2;
+  var1 = var2;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, RightDestructorIsCalledAfterAssignment) {
-    DestructorCallback destructorCallback1;
-    DestructorCallback destructorCallback2;
-    destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
-    destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1
+  DestructorCallback destructorCallback1;
+  DestructorCallback destructorCallback2;
+  destructorCallback1.EXPECT_CALLED(
+      2); // Once for the temp1 object, once at the assignment
+  destructorCallback2.EXPECT_CALLED(
+      3); // Once for the temp2 object, once in destructor of var2, once in
+          // destructor of var1
 
-    ClassWithDestructorCallback temp1(&destructorCallback1);
-    either<string, ClassWithDestructorCallback> var1 = temp1;
-    ClassWithDestructorCallback temp2(&destructorCallback2);
-    either<string, ClassWithDestructorCallback> var2 = temp2;
-    var1 = var2;
+  ClassWithDestructorCallback temp1(&destructorCallback1);
+  either<string, ClassWithDestructorCallback> var1 = temp1;
+  ClassWithDestructorCallback temp2(&destructorCallback2);
+  either<string, ClassWithDestructorCallback> var2 = temp2;
+  var1 = var2;
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, LeftDestructorIsCalledAfterMoveAssignment) {
-    DestructorCallback destructorCallback1;
-    DestructorCallback destructorCallback2;
-    destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
-    destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1
+  DestructorCallback destructorCallback1;
+  DestructorCallback destructorCallback2;
+  destructorCallback1.EXPECT_CALLED(
+      2); // Once for the temp1 object, once at the assignment
+  destructorCallback2.EXPECT_CALLED(
+      3); // Once for the temp2 object, once in destructor of var2, once in
+          // destructor of var1
 
-    OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
-    either<OnlyMoveableClassWithDestructorCallback, string> var1 = std::move(temp1);
-    OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
-    either<OnlyMoveableClassWithDestructorCallback, string> var2 = std::move(temp2);
-    var1 = std::move(var2);
+  OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
+  either<OnlyMoveableClassWithDestructorCallback, string> var1 =
+      std::move(temp1);
+  OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
+  either<OnlyMoveableClassWithDestructorCallback, string> var2 =
+      std::move(temp2);
+  var1 = std::move(var2);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(EitherTest_Destructor, RightDestructorIsCalledAfterMoveAssignment) {
-    DestructorCallback destructorCallback1;
-    DestructorCallback destructorCallback2;
-    destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
-    destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1
+  DestructorCallback destructorCallback1;
+  DestructorCallback destructorCallback2;
+  destructorCallback1.EXPECT_CALLED(
+      2); // Once for the temp1 object, once at the assignment
+  destructorCallback2.EXPECT_CALLED(
+      3); // Once for the temp2 object, once in destructor of var2, once in
+          // destructor of var1
 
-    OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
-    either<string, OnlyMoveableClassWithDestructorCallback> var1 = std::move(temp1);
-    OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
-    either<string, OnlyMoveableClassWithDestructorCallback> var2 = std::move(temp2);
-    var1 = std::move(var2);
+  OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
+  either<string, OnlyMoveableClassWithDestructorCallback> var1 =
+      std::move(temp1);
+  OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
+  either<string, OnlyMoveableClassWithDestructorCallback> var2 =
+      std::move(temp2);
+  var1 = std::move(var2);
 }
diff --git a/c10/test/util/exception_test.cpp b/c10/test/util/exception_test.cpp
index 04b3c1af9d2..a12b303c565 100644
--- a/c10/test/util/exception_test.cpp
+++ b/c10/test/util/exception_test.cpp
@@ -9,7 +9,7 @@ bool throw_func() {
   throw std::runtime_error("I'm throwing...");
 }
 
-template<class Functor>
+template <class Functor>
 inline void expectThrowsEq(Functor&& functor, const char* expectedMessage) {
   try {
     std::forward<Functor>(functor)();
@@ -18,7 +18,7 @@ inline void expectThrowsEq(Functor&& functor, const char* expectedMessage) {
     return;
   }
   ADD_FAILURE() << "Expected to throw exception with message \""
-    << expectedMessage << "\" but didn't throw";
+                << expectedMessage << "\" but didn't throw";
 }
 } // namespace
 
@@ -43,30 +43,32 @@ TEST(WarningTest, JustPrintWarning) {
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(ExceptionTest, ErrorFormatting) {
-  expectThrowsEq([]() {
-    TORCH_CHECK(false, "This is invalid");
-  }, "This is invalid");
+  expectThrowsEq(
+      []() { TORCH_CHECK(false, "This is invalid"); }, "This is invalid");
 
-  expectThrowsEq([]() {
-    try {
-      TORCH_CHECK(false, "This is invalid");
-    } catch (Error& e) {
-      TORCH_RETHROW(e, "While checking X");
-    }
-  }, "This is invalid (While checking X)");
+  expectThrowsEq(
+      []() {
+        try {
+          TORCH_CHECK(false, "This is invalid");
+        } catch (Error& e) {
+          TORCH_RETHROW(e, "While checking X");
+        }
+      },
+      "This is invalid (While checking X)");
 
-  expectThrowsEq([]() {
-    try {
-      try {
-        TORCH_CHECK(false, "This is invalid");
-      } catch (Error& e) {
-        TORCH_RETHROW(e, "While checking X");
-      }
-    } catch (Error& e) {
-      TORCH_RETHROW(e, "While checking Y");
-    }
-  },
-R"msg(This is invalid
+  expectThrowsEq(
+      []() {
+        try {
+          try {
+            TORCH_CHECK(false, "This is invalid");
+          } catch (Error& e) {
+            TORCH_RETHROW(e, "While checking X");
+          }
+        } catch (Error& e) {
+          TORCH_RETHROW(e, "While checking Y");
+        }
+      },
+      R"msg(This is invalid
   While checking X
   While checking Y)msg");
 }
@@ -94,5 +96,6 @@ TEST(ExceptionTest, DontCallArgumentFunctionsTwiceOnFailure) {
 
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-goto,hicpp-avoid-goto)
   EXPECT_ANY_THROW(failInternalAssert());
-  EXPECT_EQ(assertionArgumentCounter, 2) << "TORCH_INTERNAL_ASSERT called argument twice";
+  EXPECT_EQ(assertionArgumentCounter, 2)
+      << "TORCH_INTERNAL_ASSERT called argument twice";
 }
diff --git a/c10/test/util/intrusive_ptr_test.cpp b/c10/test/util/intrusive_ptr_test.cpp
index a47fdd40d11..a17582f8d7c 100644
--- a/c10/test/util/intrusive_ptr_test.cpp
+++ b/c10/test/util/intrusive_ptr_test.cpp
@@ -67,7 +67,8 @@ class ChildDestructableMock final : public DestructableMock {
 class NullType1 final {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static SomeClass singleton_;
-public:
+
+ public:
   static constexpr SomeClass* singleton() {
     return &singleton_;
   }
@@ -77,7 +78,8 @@ SomeClass NullType1::singleton_;
 class NullType2 final {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static SomeClass singleton_;
-public:
+
+ public:
   static constexpr SomeClass* singleton() {
     return &singleton_;
   }
@@ -934,7 +936,8 @@ TEST(IntrusivePtrTest, givenPtr_whenDestructed_thenDestructsObject) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_FALSE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
   }
@@ -948,7 +951,8 @@ TEST(
     givenPtr_whenMoveConstructed_thenDestructsObjectAfterSecondDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = std::move(obj);
     EXPECT_FALSE(resourcesReleased);
@@ -964,7 +968,8 @@ TEST(
     givenPtr_whenMoveConstructedToBaseClass_thenDestructsObjectAfterSecondDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
   {
     intrusive_ptr<DestructableMock> obj2 = std::move(obj);
     EXPECT_FALSE(resourcesReleased);
@@ -981,7 +986,8 @@ TEST(IntrusivePtrTest, givenPtr_whenMoveAssigned_thenDestructsOldObject) {
   bool wasDestructed = false;
   auto obj = make_intrusive<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_FALSE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = std::move(obj);
@@ -999,7 +1005,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_FALSE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = std::move(obj);
@@ -1017,7 +1024,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       auto copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1040,8 +1048,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 =
-        make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 = make_intrusive<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1064,7 +1072,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1085,7 +1094,8 @@ TEST(
   bool dummy = false;
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = make_intrusive<DestructableMock>(&dummy, &dummy);
     obj2 = std::move(obj);
@@ -1103,7 +1113,8 @@ TEST(
   bool dummy = false;
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = make_intrusive<DestructableMock>(&dummy, &dummy);
     obj2 = std::move(obj);
@@ -1121,7 +1132,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
       intrusive_ptr<DestructableMock> copy = obj;
@@ -1142,7 +1154,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_intrusive<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy = obj;
       EXPECT_FALSE(resourcesReleased);
@@ -1162,7 +1175,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     intrusive_ptr<DestructableMock> copy = obj;
     obj.reset();
     EXPECT_FALSE(resourcesReleased);
@@ -1179,7 +1193,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_intrusive<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     intrusive_ptr<DestructableMock> copy = obj;
     obj.reset();
     EXPECT_FALSE(resourcesReleased);
@@ -1197,7 +1212,8 @@ TEST(
   bool wasDestructed = false;
   bool dummy = false;
   {
-    auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy =
           make_intrusive<DestructableMock>(&dummy, &dummy);
@@ -1220,7 +1236,8 @@ TEST(
   bool wasDestructed = false;
   bool dummy = false;
   {
-    auto obj = make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_intrusive<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy =
           make_intrusive<DestructableMock>(&dummy, &dummy);
@@ -1245,7 +1262,8 @@ TEST(
   {
     auto copy = make_intrusive<DestructableMock>(&dummy, &dummy);
     {
-      auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+      auto obj =
+          make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
       copy = obj;
       EXPECT_FALSE(resourcesReleased);
       EXPECT_FALSE(wasDestructed);
@@ -1267,8 +1285,8 @@ TEST(
   {
     auto copy = make_intrusive<DestructableMock>(&dummy, &dummy);
     {
-      auto obj =
-          make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+      auto obj = make_intrusive<ChildDestructableMock>(
+          &resourcesReleased, &wasDestructed);
       copy = obj;
       EXPECT_FALSE(resourcesReleased);
       EXPECT_FALSE(wasDestructed);
@@ -1287,7 +1305,8 @@ TEST(IntrusivePtrTest, givenPtr_whenCopyAssigned_thenDestructsOldObject) {
   bool wasDestructed = false;
   auto obj = make_intrusive<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_FALSE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = obj;
@@ -1305,7 +1324,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_FALSE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = obj;
@@ -1323,7 +1343,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       auto copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1346,8 +1367,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 =
-        make_intrusive<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 = make_intrusive<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1370,7 +1391,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_intrusive<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_FALSE(resourcesReleased);
@@ -1388,7 +1410,8 @@ TEST(
 TEST(IntrusivePtrTest, givenPtr_whenCallingReset_thenDestructs) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   EXPECT_FALSE(resourcesReleased);
   EXPECT_FALSE(wasDestructed);
   obj.reset();
@@ -1402,7 +1425,8 @@ TEST(
     givenPtrWithCopy_whenCallingReset_thenDestructsAfterCopyDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto copy = obj;
     obj.reset();
@@ -1420,7 +1444,8 @@ TEST(
     givenPtrWithCopy_whenCallingResetOnCopy_thenDestructsAfterOriginalDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto copy = obj;
     copy.reset();
@@ -1438,7 +1463,8 @@ TEST(
     givenPtrWithMoved_whenCallingReset_thenDestructsAfterMovedDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto moved = std::move(obj);
     // NOLINTNEXTLINE(bugprone-use-after-move)
@@ -1457,7 +1483,8 @@ TEST(
     givenPtrWithMoved_whenCallingResetOnMoved_thenDestructsImmediately) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto moved = std::move(obj);
     moved.reset();
@@ -1800,9 +1827,7 @@ TEST(IntrusivePtrTest, givenPtr_whenNonOwningReclaimed_thenDoesntCrash) {
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(
-    IntrusivePtrTest,
-    givenPtr_whenNonOwningReclaimed_thenIsDestructedAtEnd) {
+TEST(IntrusivePtrTest, givenPtr_whenNonOwningReclaimed_thenIsDestructedAtEnd) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
@@ -1840,7 +1865,9 @@ weak_intrusive_ptr<T> make_weak_only(Args&&... args) {
   auto intrusive = make_intrusive<T>(std::forward<Args>(args)...);
   return weak_intrusive_ptr<T>(intrusive);
 }
-template <class T, class NullType = c10::detail::intrusive_target_default_null_type<T>>
+template <
+    class T,
+    class NullType = c10::detail::intrusive_target_default_null_type<T>>
 weak_intrusive_ptr<T, NullType> make_invalid_weak() {
   return weak_intrusive_ptr<T, NullType>(intrusive_ptr<T, NullType>());
 }
@@ -1903,9 +1930,7 @@ TEST(
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(
-    WeakIntrusivePtrTest,
-    vector_insert_weak_intrusive) {
+TEST(WeakIntrusivePtrTest, vector_insert_weak_intrusive) {
   std::vector<weak_intrusive_ptr<SomeClass>> priorWorks;
   std::vector<intrusive_ptr<SomeClass>> wips;
   wips.push_back(make_intrusive<SomeClass>());
@@ -2139,8 +2164,10 @@ TEST(
 TEST(
     WeakIntrusivePtrTest,
     givenNullPtr_whenMoveAssigningToDifferentNullptr_thenHasNewNullptr) {
-  weak_intrusive_ptr<SomeClass, NullType1> obj1 = make_invalid_weak<SomeClass, NullType1>();
-  weak_intrusive_ptr<SomeClass, NullType2> obj2 = make_invalid_weak<SomeClass, NullType2>();
+  weak_intrusive_ptr<SomeClass, NullType1> obj1 =
+      make_invalid_weak<SomeClass, NullType1>();
+  weak_intrusive_ptr<SomeClass, NullType2> obj2 =
+      make_invalid_weak<SomeClass, NullType2>();
   obj2 = std::move(obj1);
   EXPECT_NE(NullType1::singleton(), NullType2::singleton());
   // NOLINTNEXTLINE(bugprone-use-after-move)
@@ -2362,8 +2389,10 @@ TEST(
 TEST(
     WeakIntrusivePtrTest,
     givenNullPtr_whenCopyAssigningToDifferentNullptr_thenHasNewNullptr) {
-  weak_intrusive_ptr<SomeClass, NullType1> obj1 = make_invalid_weak<SomeClass, NullType1>();
-  weak_intrusive_ptr<SomeClass, NullType2> obj2 = make_invalid_weak<SomeClass, NullType2>();
+  weak_intrusive_ptr<SomeClass, NullType1> obj1 =
+      make_invalid_weak<SomeClass, NullType1>();
+  weak_intrusive_ptr<SomeClass, NullType2> obj2 =
+      make_invalid_weak<SomeClass, NullType2>();
   obj2 = obj1;
   EXPECT_NE(NullType1::singleton(), NullType2::singleton());
   EXPECT_TRUE(obj1.expired());
@@ -2468,7 +2497,8 @@ TEST(
 TEST(
     WeakIntrusivePtrTest,
     givenNullPtr_whenMoveConstructingToDifferentNullptr_thenHasNewNullptr) {
-  weak_intrusive_ptr<SomeClass, NullType1> obj1 = make_invalid_weak<SomeClass, NullType1>();
+  weak_intrusive_ptr<SomeClass, NullType1> obj1 =
+      make_invalid_weak<SomeClass, NullType1>();
   weak_intrusive_ptr<SomeClass, NullType2> obj2 = std::move(obj1);
   EXPECT_NE(NullType1::singleton(), NullType2::singleton());
   // NOLINTNEXTLINE(bugprone-use-after-move)
@@ -2575,7 +2605,8 @@ TEST(
 TEST(
     WeakIntrusivePtrTest,
     givenNullPtr_whenCopyConstructingToDifferentNullptr_thenHasNewNullptr) {
-  weak_intrusive_ptr<SomeClass, NullType1> obj1 = make_invalid_weak<SomeClass, NullType1>();
+  weak_intrusive_ptr<SomeClass, NullType1> obj1 =
+      make_invalid_weak<SomeClass, NullType1>();
   weak_intrusive_ptr<SomeClass, NullType2> obj2 = obj1;
   EXPECT_NE(NullType1::singleton(), NullType2::singleton());
   EXPECT_TRUE(obj1.expired());
@@ -3175,7 +3206,8 @@ TEST(
     givenPtr_whenLastStrongPointerResets_thenReleasesResources) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   EXPECT_FALSE(resourcesReleased);
   EXPECT_FALSE(wasDestructed);
   obj.ptr.reset();
@@ -3192,7 +3224,8 @@ TEST(
     givenPtr_whenDestructedButStillHasStrongPointers_thenDoesntReleaseResources) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_intrusive<DestructableMock>(&resourcesReleased, &wasDestructed);
   EXPECT_FALSE(resourcesReleased);
   EXPECT_FALSE(wasDestructed);
   obj.weak.reset();
@@ -3208,7 +3241,8 @@ TEST(WeakIntrusivePtrTest, givenPtr_whenDestructed_thenDestructsObject) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_TRUE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
   }
@@ -3222,7 +3256,8 @@ TEST(
     givenPtr_whenMoveConstructed_thenDestructsObjectAfterSecondDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = std::move(obj);
     EXPECT_TRUE(resourcesReleased);
@@ -3238,7 +3273,8 @@ TEST(
     givenPtr_whenMoveConstructedToBaseClass_thenDestructsObjectAfterSecondDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
   {
     weak_intrusive_ptr<DestructableMock> obj2 = std::move(obj);
     EXPECT_TRUE(resourcesReleased);
@@ -3255,7 +3291,8 @@ TEST(WeakIntrusivePtrTest, givenPtr_whenMoveAssigned_thenDestructsOldObject) {
   bool wasDestructed = false;
   auto obj = make_weak_only<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_TRUE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = std::move(obj);
@@ -3273,7 +3310,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_TRUE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = std::move(obj);
@@ -3291,7 +3329,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       auto copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3314,8 +3353,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 =
-        make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 = make_weak_only<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3338,7 +3377,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3359,7 +3399,8 @@ TEST(
   bool dummy = false;
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = make_weak_only<DestructableMock>(&dummy, &dummy);
     obj2 = std::move(obj);
@@ -3377,7 +3418,8 @@ TEST(
   bool dummy = false;
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto obj2 = make_weak_only<DestructableMock>(&dummy, &dummy);
     obj2 = std::move(obj);
@@ -3395,7 +3437,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
       weak_intrusive_ptr<DestructableMock> copy = obj;
@@ -3416,7 +3459,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_weak_only<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy = obj;
       EXPECT_TRUE(resourcesReleased);
@@ -3436,7 +3480,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     weak_intrusive_ptr<DestructableMock> copy = obj;
     obj.reset();
     EXPECT_TRUE(resourcesReleased);
@@ -3453,7 +3498,8 @@ TEST(
   bool resourcesReleased = false;
   bool wasDestructed = false;
   {
-    auto obj = make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_weak_only<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     weak_intrusive_ptr<DestructableMock> copy = obj;
     obj.reset();
     EXPECT_TRUE(resourcesReleased);
@@ -3471,7 +3517,8 @@ TEST(
   bool wasDestructed = false;
   bool dummy = false;
   {
-    auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy =
           make_weak_only<DestructableMock>(&dummy, &dummy);
@@ -3494,7 +3541,8 @@ TEST(
   bool wasDestructed = false;
   bool dummy = false;
   {
-    auto obj = make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj = make_weak_only<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy =
           make_weak_only<DestructableMock>(&dummy, &dummy);
@@ -3519,7 +3567,8 @@ TEST(
   {
     auto copy = make_weak_only<DestructableMock>(&dummy, &dummy);
     {
-      auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+      auto obj =
+          make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
       copy = obj;
       EXPECT_TRUE(resourcesReleased);
       EXPECT_FALSE(wasDestructed);
@@ -3541,8 +3590,8 @@ TEST(
   {
     auto copy = make_weak_only<DestructableMock>(&dummy, &dummy);
     {
-      auto obj =
-          make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+      auto obj = make_weak_only<ChildDestructableMock>(
+          &resourcesReleased, &wasDestructed);
       copy = obj;
       EXPECT_TRUE(resourcesReleased);
       EXPECT_FALSE(wasDestructed);
@@ -3561,7 +3610,8 @@ TEST(WeakIntrusivePtrTest, givenPtr_whenCopyAssigned_thenDestructsOldObject) {
   bool wasDestructed = false;
   auto obj = make_weak_only<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_TRUE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = obj;
@@ -3579,7 +3629,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     EXPECT_TRUE(resourcesReleased);
     EXPECT_FALSE(wasDestructed);
     obj2 = obj;
@@ -3597,7 +3648,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<DestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       auto copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3620,8 +3672,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 =
-        make_weak_only<ChildDestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 = make_weak_only<ChildDestructableMock>(
+        &resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3644,7 +3696,8 @@ TEST(
   bool wasDestructed = false;
   auto obj = make_weak_only<ChildDestructableMock>(&dummy, &dummy);
   {
-    auto obj2 = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+    auto obj2 =
+        make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
     {
       weak_intrusive_ptr<DestructableMock> copy = obj2;
       EXPECT_TRUE(resourcesReleased);
@@ -3662,7 +3715,8 @@ TEST(
 TEST(WeakIntrusivePtrTest, givenPtr_whenCallingReset_thenDestructs) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   EXPECT_TRUE(resourcesReleased);
   EXPECT_FALSE(wasDestructed);
   obj.reset();
@@ -3676,7 +3730,8 @@ TEST(
     givenPtrWithCopy_whenCallingReset_thenDestructsAfterCopyDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto copy = obj;
     obj.reset();
@@ -3694,7 +3749,8 @@ TEST(
     givenPtrWithCopy_whenCallingResetOnCopy_thenDestructsAfterOriginalDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto copy = obj;
     copy.reset();
@@ -3712,7 +3768,8 @@ TEST(
     givenPtrWithMoved_whenCallingReset_thenDestructsAfterMovedDestructed) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto moved = std::move(obj);
     // NOLINTNEXTLINE(bugprone-use-after-move)
@@ -3731,7 +3788,8 @@ TEST(
     givenPtrWithMoved_whenCallingResetOnMoved_thenDestructsImmediately) {
   bool resourcesReleased = false;
   bool wasDestructed = false;
-  auto obj = make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
+  auto obj =
+      make_weak_only<DestructableMock>(&resourcesReleased, &wasDestructed);
   {
     auto moved = std::move(obj);
     moved.reset();
diff --git a/c10/test/util/irange_test.cpp b/c10/test/util/irange_test.cpp
index 3677760df9e..274aedd2607 100644
--- a/c10/test/util/irange_test.cpp
+++ b/c10/test/util/irange_test.cpp
@@ -8,58 +8,58 @@ using namespace ::testing;
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(irange_test, range_test) {
-    std::vector<int> test_vec;
-    for(const auto i : c10::irange(4, 11)){
-        test_vec.push_back(i);
-    }
-    const std::vector<int> correct = {{4,5,6,7,8,9,10}};
-    ASSERT_EQ(test_vec, correct);
+  std::vector<int> test_vec;
+  for (const auto i : c10::irange(4, 11)) {
+    test_vec.push_back(i);
+  }
+  const std::vector<int> correct = {{4, 5, 6, 7, 8, 9, 10}};
+  ASSERT_EQ(test_vec, correct);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(irange_test, end_test) {
-    std::vector<int> test_vec;
-    for(const auto i : c10::irange(5)){
-        test_vec.push_back(i);
-    }
-    const std::vector<int> correct = {{0, 1, 2, 3, 4}};
-    ASSERT_EQ(test_vec, correct);
+  std::vector<int> test_vec;
+  for (const auto i : c10::irange(5)) {
+    test_vec.push_back(i);
+  }
+  const std::vector<int> correct = {{0, 1, 2, 3, 4}};
+  ASSERT_EQ(test_vec, correct);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(irange_test, neg_range_test) {
-    std::vector<int> test_vec;
-    for(const auto i : c10::irange(-2, 3)){
-        test_vec.push_back(i);
-    }
-    const std::vector<int> correct = {{-2,-1,0,1,2}};
-    ASSERT_EQ(test_vec, correct);
+  std::vector<int> test_vec;
+  for (const auto i : c10::irange(-2, 3)) {
+    test_vec.push_back(i);
+  }
+  const std::vector<int> correct = {{-2, -1, 0, 1, 2}};
+  ASSERT_EQ(test_vec, correct);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(irange, empty_reverse_range_two_inputs){
-    std::vector<int> test_vec;
-    for(const auto i : c10::irange(3, -3)){
-        test_vec.push_back(i);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        if(i>20){ //Cap the number of elements we add if something goes wrong
-            break;
-        }
+TEST(irange, empty_reverse_range_two_inputs) {
+  std::vector<int> test_vec;
+  for (const auto i : c10::irange(3, -3)) {
+    test_vec.push_back(i);
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+    if (i > 20) { // Cap the number of elements we add if something goes wrong
+      break;
     }
-    const std::vector<int> correct = {};
-    ASSERT_EQ(test_vec, correct);
+  }
+  const std::vector<int> correct = {};
+  ASSERT_EQ(test_vec, correct);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(irange, empty_reverse_range_one_input){
-    std::vector<int> test_vec;
-    for(const auto i : c10::irange(-3)){
-        test_vec.push_back(i);
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        if(i>20){ //Cap the number of elements we add if something goes wrong
-            break;
-        }
+TEST(irange, empty_reverse_range_one_input) {
+  std::vector<int> test_vec;
+  for (const auto i : c10::irange(-3)) {
+    test_vec.push_back(i);
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+    if (i > 20) { // Cap the number of elements we add if something goes wrong
+      break;
     }
-    const std::vector<int> correct = {};
-    ASSERT_EQ(test_vec, correct);
+  }
+  const std::vector<int> correct = {};
+  ASSERT_EQ(test_vec, correct);
 }
diff --git a/c10/test/util/logging_test.cpp b/c10/test/util/logging_test.cpp
index 5822eabbece..a66788012e0 100644
--- a/c10/test/util/logging_test.cpp
+++ b/c10/test/util/logging_test.cpp
@@ -1,8 +1,8 @@
 #include <algorithm>
 
-#include <gtest/gtest.h>
 #include <c10/util/ArrayRef.h>
 #include <c10/util/Logging.h>
+#include <gtest/gtest.h>
 
 namespace c10_test {
 
@@ -54,15 +54,15 @@ TEST(LoggingTest, TestEnforceEquals) {
 
 namespace {
 struct EnforceEqWithCaller {
-  void test(const char *x) {
+  void test(const char* x) {
     CAFFE_ENFORCE_EQ_WITH_CALLER(1, 1, "variable: ", x, " is a variable");
   }
 };
-}
+} // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LoggingTest, TestEnforceMessageVariables) {
-  const char *const x = "hello";
+  const char* const x = "hello";
   CAFFE_ENFORCE_EQ(1, 1, "variable: ", x, " is a variable");
 
   EnforceEqWithCaller e;
@@ -70,7 +70,9 @@ TEST(LoggingTest, TestEnforceMessageVariables) {
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-TEST(LoggingTest, EnforceEqualsObjectWithReferenceToTemporaryWithoutUseOutOfScope) {
+TEST(
+    LoggingTest,
+    EnforceEqualsObjectWithReferenceToTemporaryWithoutUseOutOfScope) {
   std::vector<int> x = {1, 2, 3, 4};
   // This case is a little tricky. We have a temporary
   // std::initializer_list to which our temporary ArrayRef
@@ -102,7 +104,7 @@ std::ostream& operator<<(std::ostream& out, const Noncopyable& nc) {
   out << "Noncopyable(" << nc.x << ")";
   return out;
 }
-}
+} // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(LoggingTest, DoesntCopyComparedObjects) {
@@ -132,7 +134,8 @@ TEST(LoggingTest, EnforceShowcase) {
   WRAP_AND_PRINT(CAFFE_ENFORCE_EQ(
       one * two + three, three * two, "It's a pretty complicated expression"));
 
-  WRAP_AND_PRINT(CAFFE_ENFORCE_THAT(std::equal_to<void>(), ==, one * two + three, three * two));
+  WRAP_AND_PRINT(CAFFE_ENFORCE_THAT(
+      std::equal_to<void>(), ==, one * two + three, three * two));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
diff --git a/c10/test/util/optional_test.cpp b/c10/test/util/optional_test.cpp
index 73983e7d32e..6595bf46ae5 100644
--- a/c10/test/util/optional_test.cpp
+++ b/c10/test/util/optional_test.cpp
@@ -17,32 +17,29 @@ class OptionalTest : public ::testing::Test {
 template <typename T>
 T getSampleValue();
 
-template<>
+template <>
 bool getSampleValue() {
   return true;
 }
 
-template<>
+template <>
 uint64_t getSampleValue() {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
   return 42;
 }
 
-template<>
+template <>
 std::string getSampleValue() {
   return "hello";
 }
 
-
 using OptionalTypes = ::testing::Types<
-  // 32-bit scalar optimization.
-  bool,
-  // Trivially destructible but not 32-bit scalar.
-  uint64_t,
-  // Non-trivial destructor.
-  std::string
-  >;
-
+    // 32-bit scalar optimization.
+    bool,
+    // Trivially destructible but not 32-bit scalar.
+    uint64_t,
+    // Non-trivial destructor.
+    std::string>;
 
 TYPED_TEST_CASE(OptionalTest, OptionalTypes);
 
@@ -71,7 +68,8 @@ TYPED_TEST(OptionalTest, Initialized) {
   moveAssign = std::move(moveFrom2);
 
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-  std::array<typename TestFixture::optional *, 5> opts = {&opt, &copy, &copyAssign, &move, &moveAssign};
+  std::array<typename TestFixture::optional*, 5> opts = {
+      &opt, &copy, &copyAssign, &move, &moveAssign};
   for (auto* popt : opts) {
     auto& opt = *popt;
     EXPECT_TRUE((bool)opt);
diff --git a/c10/test/util/ordered_preserving_dict_test.cpp b/c10/test/util/ordered_preserving_dict_test.cpp
index be4dbc64db8..11f0646399b 100644
--- a/c10/test/util/ordered_preserving_dict_test.cpp
+++ b/c10/test/util/ordered_preserving_dict_test.cpp
@@ -1,6 +1,6 @@
-#include <vector>
-#include <unordered_set>
 #include <algorithm>
+#include <unordered_set>
+#include <vector>
 
 #include <c10/macros/Macros.h>
 #include <c10/util/Exception.h>
@@ -11,7 +11,8 @@ namespace {
 
 #define ASSERT_EQUAL_PRIM(t1, t2) ASSERT_TRUE(t1 == t2);
 
-using dict_int_int = ska_ordered::order_preserving_flat_hash_map<int64_t, int64_t>;
+using dict_int_int =
+    ska_ordered::order_preserving_flat_hash_map<int64_t, int64_t>;
 
 dict_int_int test_dict(dict_int_int& dict) {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
@@ -20,7 +21,7 @@ dict_int_int test_dict(dict_int_int& dict) {
   }
 
   int64_t i = 0;
-  for (auto entry: dict) {
+  for (auto entry : dict) {
     TORCH_INTERNAL_ASSERT(entry.first == i && entry.second == i + 1);
     ++i;
   }
@@ -28,7 +29,7 @@ dict_int_int test_dict(dict_int_int& dict) {
   // erase a few entries by themselves
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
   std::unordered_set<int64_t> erase_set = {0, 2, 9, 71};
-  for (auto erase: erase_set) {
+  for (auto erase : erase_set) {
     dict.erase(erase);
   }
 
@@ -55,7 +56,7 @@ dict_int_int test_dict(dict_int_int& dict) {
   }
 
   i = 0;
-  for (auto entry: dict) {
+  for (auto entry : dict) {
     TORCH_INTERNAL_ASSERT(order[i] == entry.first);
     TORCH_INTERNAL_ASSERT(dict[order[i]] == entry.second);
     TORCH_INTERNAL_ASSERT(entry.second == order[i] + 1);
@@ -89,11 +90,11 @@ TEST(OrderedPreservingDictTest, InsertExistingDoesntAffectOrder) {
   TORCH_INTERNAL_ASSERT(dict.begin()->first == 1);
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, testRefType) {
   std::shared_ptr<int64_t> t;
-  using dict_references = ska_ordered::order_preserving_flat_hash_map<int64_t, std::shared_ptr<int64_t>>;
+  using dict_references = ska_ordered::
+      order_preserving_flat_hash_map<int64_t, std::shared_ptr<int64_t>>;
 
   dict_references dict;
 
@@ -108,7 +109,6 @@ TEST(OrderedPreservingDictTest, testRefType) {
   TORCH_INTERNAL_ASSERT(ptr.use_count() == 1);
 }
 
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, DictCollisions) {
   struct BadHash {
@@ -171,254 +171,262 @@ TEST(OrderedPreservingDictTest, DictCollisions) {
   }
 }
 
-
-// Tests taken from https://github.com/Tessil/ordered-map/blob/master/tests/ordered_map_tests.cpp
+// Tests taken from
+// https://github.com/Tessil/ordered-map/blob/master/tests/ordered_map_tests.cpp
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_range_insert) {
-    // insert x values in vector, range insert x-15 values from vector to map, check values
-    const int nb_values = 1000;
-    std::vector<std::pair<int, int>> values;
-    for(int i = 0; i < nb_values; i++) {
-        // NOLINTNEXTLINE(modernize-use-emplace,performance-inefficient-vector-operation)
-        values.push_back(std::make_pair(i, i+1));
-    }
+  // insert x values in vector, range insert x-15 values from vector to map,
+  // check values
+  const int nb_values = 1000;
+  std::vector<std::pair<int, int>> values;
+  for (int i = 0; i < nb_values; i++) {
+    // NOLINTNEXTLINE(modernize-use-emplace,performance-inefficient-vector-operation)
+    values.push_back(std::make_pair(i, i + 1));
+  }
 
-    dict_int_int map = {{-1, 0}, {-2, 0}};
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    map.insert(values.begin() + 10, values.end() - 5);
+  dict_int_int map = {{-1, 0}, {-2, 0}};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  map.insert(values.begin() + 10, values.end() - 5);
 
-    TORCH_INTERNAL_ASSERT(map.size(), 987);
+  TORCH_INTERNAL_ASSERT(map.size(), 987);
 
-    ASSERT_EQUAL_PRIM(map.at(-1), 0);
+  ASSERT_EQUAL_PRIM(map.at(-1), 0);
 
-    ASSERT_EQUAL_PRIM(map.at(-2), 0);
+  ASSERT_EQUAL_PRIM(map.at(-2), 0);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    for(int i = 10, j = 2; i < nb_values - 5; i++, j++) {
-        ASSERT_EQUAL_PRIM(map.at(i), i+1);
-    }
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  for (int i = 10, j = 2; i < nb_values - 5; i++, j++) {
+    ASSERT_EQUAL_PRIM(map.at(i), i + 1);
+  }
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_range_erase_all) {
-    // insert x values, delete all
-    const std::size_t nb_values = 1000;
-    dict_int_int map;
-    for (size_t i = 0; i < nb_values; ++i) {
-      map[i] = i + 1;
-    }
-    auto it = map.erase(map.begin(), map.end());
-    ASSERT_TRUE(it == map.end());
-    ASSERT_TRUE(map.empty());
+  // insert x values, delete all
+  const std::size_t nb_values = 1000;
+  dict_int_int map;
+  for (size_t i = 0; i < nb_values; ++i) {
+    map[i] = i + 1;
+  }
+  auto it = map.erase(map.begin(), map.end());
+  ASSERT_TRUE(it == map.end());
+  ASSERT_TRUE(map.empty());
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_range_erase) {
-    // insert x values, delete all with iterators except 10 first and 780 last values
-    using HMap = ska_ordered::order_preserving_flat_hash_map<std::string, std::int64_t>;
+  // insert x values, delete all with iterators except 10 first and 780 last
+  // values
+  using HMap =
+      ska_ordered::order_preserving_flat_hash_map<std::string, std::int64_t>;
 
-    const std::size_t nb_values = 1000;
-    HMap map;
-    for (size_t i = 0; i < nb_values; ++i) {
-      map[c10::guts::to_string(i)] = i;
-      auto begin = map.begin();
-      for (size_t j = 0; j <= i; ++j, begin++) {
-        TORCH_INTERNAL_ASSERT(begin->second == j);
-      }
+  const std::size_t nb_values = 1000;
+  HMap map;
+  for (size_t i = 0; i < nb_values; ++i) {
+    map[c10::guts::to_string(i)] = i;
+    auto begin = map.begin();
+    for (size_t j = 0; j <= i; ++j, begin++) {
+      TORCH_INTERNAL_ASSERT(begin->second == j);
     }
+  }
 
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto it_first = std::next(map.begin(), 10);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  auto it_last = std::next(map.begin(), 220);
+
+  auto it = map.erase(it_first, it_last);
+  ASSERT_EQUAL_PRIM(std::distance(it, map.end()), 780);
+  ASSERT_EQUAL_PRIM(map.size(), 790);
+  ASSERT_EQUAL_PRIM(std::distance(map.begin(), map.end()), 790);
+
+  for (auto& val : map) {
+    ASSERT_EQUAL_PRIM(map.count(val.first), 1);
+  }
+
+  // Check order
+  it = map.begin();
+  for (std::size_t i = 0; i < nb_values; i++) {
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto it_first = std::next(map.begin(), 10);
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    auto it_last = std::next(map.begin(), 220);
-
-    auto it = map.erase(it_first, it_last);
-    ASSERT_EQUAL_PRIM(std::distance(it, map.end()), 780);
-    ASSERT_EQUAL_PRIM(map.size(), 790);
-    ASSERT_EQUAL_PRIM(std::distance(map.begin(), map.end()), 790);
-
-    for(auto& val: map) {
-        ASSERT_EQUAL_PRIM(map.count(val.first), 1);
-    }
-
-    // Check order
-    it = map.begin();
-    for(std::size_t i = 0; i < nb_values; i++) {
-        // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        if(i >= 10 && i < 220) {
-            continue;
-        }
-        auto exp_it = std::pair<std::string, std::int64_t>(c10::guts::to_string(i), i);
-        TORCH_INTERNAL_ASSERT(*it == exp_it);
-        ++it;
+    if (i >= 10 && i < 220) {
+      continue;
     }
+    auto exp_it =
+        std::pair<std::string, std::int64_t>(c10::guts::to_string(i), i);
+    TORCH_INTERNAL_ASSERT(*it == exp_it);
+    ++it;
+  }
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_move_constructor_empty) {
-    ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map(0);
-    ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map_move(std::move(map));
+  ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map(0);
+  ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map_move(
+      std::move(map));
 
-    // NOLINTNEXTLINE(bugprone-use-after-move)
-    TORCH_INTERNAL_ASSERT(map.empty());
-    TORCH_INTERNAL_ASSERT(map_move.empty());
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  TORCH_INTERNAL_ASSERT(map.empty());
+  TORCH_INTERNAL_ASSERT(map_move.empty());
 
-    // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
-    TORCH_INTERNAL_ASSERT(map.find("") == map.end());
-    TORCH_INTERNAL_ASSERT(map_move.find("") == map_move.end());
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
+  TORCH_INTERNAL_ASSERT(map.find("") == map.end());
+  TORCH_INTERNAL_ASSERT(map_move.find("") == map_move.end());
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_move_operator_empty) {
-    ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map(0);
-    ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map_move;
-    map_move = (std::move(map));
+  ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map(0);
+  ska_ordered::order_preserving_flat_hash_map<std::string, int64_t> map_move;
+  map_move = (std::move(map));
 
-    // NOLINTNEXTLINE(bugprone-use-after-move)
-    TORCH_INTERNAL_ASSERT(map.empty());
-    TORCH_INTERNAL_ASSERT(map_move.empty());
+  // NOLINTNEXTLINE(bugprone-use-after-move)
+  TORCH_INTERNAL_ASSERT(map.empty());
+  TORCH_INTERNAL_ASSERT(map_move.empty());
 
-    // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
-    TORCH_INTERNAL_ASSERT(map.find("") == map.end());
-    TORCH_INTERNAL_ASSERT(map_move.find("") == map_move.end());
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
+  TORCH_INTERNAL_ASSERT(map.find("") == map.end());
+  TORCH_INTERNAL_ASSERT(map_move.find("") == map_move.end());
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_reassign_moved_object_move_constructor) {
-    using HMap = ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
+  using HMap =
+      ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
 
-    HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
-    HMap map_move(std::move(map));
+  HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
+  HMap map_move(std::move(map));
 
-    ASSERT_EQUAL_PRIM(map_move.size(), 3);
-    // NOLINTNEXTLINE(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-    ASSERT_EQUAL_PRIM(map.size(), 0);
+  ASSERT_EQUAL_PRIM(map_move.size(), 3);
+  // NOLINTNEXTLINE(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+  ASSERT_EQUAL_PRIM(map.size(), 0);
 
-    map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
-    TORCH_INTERNAL_ASSERT(map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
+  map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
+  TORCH_INTERNAL_ASSERT(
+      map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_reassign_moved_object_move_operator) {
-    using HMap = ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
+  using HMap =
+      ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
 
-    HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
-    HMap map_move = std::move(map);
+  HMap map = {{"Key1", "Value1"}, {"Key2", "Value2"}, {"Key3", "Value3"}};
+  HMap map_move = std::move(map);
 
-    ASSERT_EQUAL_PRIM(map_move.size(), 3);
-    // NOLINTNEXTLINE(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-    ASSERT_EQUAL_PRIM(map.size(), 0);
+  ASSERT_EQUAL_PRIM(map_move.size(), 3);
+  // NOLINTNEXTLINE(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+  ASSERT_EQUAL_PRIM(map.size(), 0);
 
-    map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
-    TORCH_INTERNAL_ASSERT(map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
+  map = {{"Key4", "Value4"}, {"Key5", "Value5"}};
+  TORCH_INTERNAL_ASSERT(
+      map == (HMap({{"Key4", "Value4"}, {"Key5", "Value5"}})));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_copy_constructor_and_operator) {
-    using HMap = ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
+  using HMap =
+      ska_ordered::order_preserving_flat_hash_map<std::string, std::string>;
 
+  const std::size_t nb_values = 100;
+  HMap map;
+  for (size_t i = 0; i < nb_values; ++i) {
+    map[c10::guts::to_string(i)] = c10::guts::to_string(i);
+  }
 
-    const std::size_t nb_values = 100;
-    HMap map;
-    for (size_t i = 0; i < nb_values; ++i) {
-      map[c10::guts::to_string(i)] = c10::guts::to_string(i);
-    }
+  HMap map_copy = map;
+  HMap map_copy2(map);
+  HMap map_copy3;
+  map_copy3[c10::guts::to_string(0)] = c10::guts::to_string(0);
 
+  map_copy3 = map;
 
-    HMap map_copy = map;
-    HMap map_copy2(map);
-    HMap map_copy3;
-    map_copy3[c10::guts::to_string(0)] = c10::guts::to_string(0);
+  TORCH_INTERNAL_ASSERT(map == map_copy);
+  map.clear();
 
-    map_copy3 = map;
-
-    TORCH_INTERNAL_ASSERT(map == map_copy);
-    map.clear();
-
-    TORCH_INTERNAL_ASSERT(map_copy == map_copy2);
-    TORCH_INTERNAL_ASSERT(map_copy == map_copy3);
+  TORCH_INTERNAL_ASSERT(map_copy == map_copy2);
+  TORCH_INTERNAL_ASSERT(map_copy == map_copy3);
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_copy_constructor_empty) {
-    ska_ordered::order_preserving_flat_hash_map<std::string, int> map(0);
-    ska_ordered::order_preserving_flat_hash_map<std::string, int> map_copy(map);
+  ska_ordered::order_preserving_flat_hash_map<std::string, int> map(0);
+  ska_ordered::order_preserving_flat_hash_map<std::string, int> map_copy(map);
 
-    TORCH_INTERNAL_ASSERT(map.empty());
-    TORCH_INTERNAL_ASSERT(map_copy.empty());
+  TORCH_INTERNAL_ASSERT(map.empty());
+  TORCH_INTERNAL_ASSERT(map_copy.empty());
 
-    TORCH_INTERNAL_ASSERT(map.find("") == map.end());
-    TORCH_INTERNAL_ASSERT(map_copy.find("") == map_copy.end());
+  TORCH_INTERNAL_ASSERT(map.find("") == map.end());
+  TORCH_INTERNAL_ASSERT(map_copy.find("") == map_copy.end());
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_copy_operator_empty) {
-    ska_ordered::order_preserving_flat_hash_map<std::string, int> map(0);
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::string, int> map_copy(16);
-    map_copy = map;
+  ska_ordered::order_preserving_flat_hash_map<std::string, int> map(0);
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::string, int> map_copy(16);
+  map_copy = map;
 
-    TORCH_INTERNAL_ASSERT(map.empty());
-    TORCH_INTERNAL_ASSERT(map_copy.empty());
+  TORCH_INTERNAL_ASSERT(map.empty());
+  TORCH_INTERNAL_ASSERT(map_copy.empty());
 
-    TORCH_INTERNAL_ASSERT(map.find("") == map.end());
-    TORCH_INTERNAL_ASSERT(map_copy.find("") == map_copy.end());
+  TORCH_INTERNAL_ASSERT(map.find("") == map.end());
+  TORCH_INTERNAL_ASSERT(map_copy.find("") == map_copy.end());
 }
 
-
 /**
  * at
  */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_at) {
-    // insert x values, use at for known and unknown values.
-    const ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
+  // insert x values, use at for known and unknown values.
+  const ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>
+      map = {{0, 10}, {-2, 20}};
 
-    ASSERT_EQUAL_PRIM(map.at(0), 10);
-    ASSERT_EQUAL_PRIM(map.at(-2), 20);
-    bool thrown = false;
-    try {
-      map.at(1);
-    } catch (...) {
-      thrown = true;
-    }
-    ASSERT_TRUE(thrown);
+  ASSERT_EQUAL_PRIM(map.at(0), 10);
+  ASSERT_EQUAL_PRIM(map.at(-2), 20);
+  bool thrown = false;
+  try {
+    map.at(1);
+  } catch (...) {
+    thrown = true;
+  }
+  ASSERT_TRUE(thrown);
 }
 
-
 /**
  * equal_range
  */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_equal_range) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map =
+      {{0, 10}, {-2, 20}};
 
-    auto it_pair = map.equal_range(0);
-    ASSERT_EQUAL_PRIM(std::distance(it_pair.first, it_pair.second), 1);
-    ASSERT_EQUAL_PRIM(it_pair.first->second, 10);
+  auto it_pair = map.equal_range(0);
+  ASSERT_EQUAL_PRIM(std::distance(it_pair.first, it_pair.second), 1);
+  ASSERT_EQUAL_PRIM(it_pair.first->second, 10);
 
-    it_pair = map.equal_range(1);
-    TORCH_INTERNAL_ASSERT(it_pair.first == it_pair.second);
-    TORCH_INTERNAL_ASSERT(it_pair.first == map.end());
+  it_pair = map.equal_range(1);
+  TORCH_INTERNAL_ASSERT(it_pair.first == it_pair.second);
+  TORCH_INTERNAL_ASSERT(it_pair.first == map.end());
 }
 
-
 /**
  * operator[]
  */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_access_operator) {
-    // insert x values, use at for known and unknown values.
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map = {{0, 10}, {-2, 20}};
+  // insert x values, use at for known and unknown values.
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map =
+      {{0, 10}, {-2, 20}};
 
-    ASSERT_EQUAL_PRIM(map[0], 10);
-    ASSERT_EQUAL_PRIM(map[-2], 20);
-    ASSERT_EQUAL_PRIM(map[2], std::int64_t());
+  ASSERT_EQUAL_PRIM(map[0], 10);
+  ASSERT_EQUAL_PRIM(map[-2], 20);
+  ASSERT_EQUAL_PRIM(map[2], std::int64_t());
 
-    ASSERT_EQUAL_PRIM(map.size(), 3);
+  ASSERT_EQUAL_PRIM(map.size(), 3);
 }
 
 /**
@@ -426,45 +434,72 @@ TEST(OrderedPreservingDictTest, test_access_operator) {
  */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_swap) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map = {{1, 10}, {8, 80}, {3, 30}};
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map2 = {{4, 40}, {5, 50}};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map =
+      {{1, 10}, {8, 80}, {3, 30}};
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map2 =
+      {{4, 40}, {5, 50}};
 
-    using std::swap;
-    swap(map, map2);
+  using std::swap;
+  swap(map, map2);
 
-    TORCH_INTERNAL_ASSERT(map == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{4, 40}, {5, 50}}));
-    TORCH_INTERNAL_ASSERT(map2 == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{1, 10}, {8, 80}, {3, 30}}));
+  TORCH_INTERNAL_ASSERT(
+      map ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {4, 40}, {5, 50}}));
+  TORCH_INTERNAL_ASSERT(
+      map2 ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {1, 10}, {8, 80}, {3, 30}}));
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    map.insert({6, 60});
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    map2.insert({4, 40});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  map.insert({6, 60});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  map2.insert({4, 40});
 
-    TORCH_INTERNAL_ASSERT(map == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{4, 40}, {5, 50}, {6, 60}}));
-    TORCH_INTERNAL_ASSERT(map2 == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{1, 10}, {8, 80}, {3, 30}, {4, 40}}));
+  TORCH_INTERNAL_ASSERT(
+      map ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {4, 40}, {5, 50}, {6, 60}}));
+  TORCH_INTERNAL_ASSERT(
+      map2 ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {1, 10}, {8, 80}, {3, 30}, {4, 40}}));
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 TEST(OrderedPreservingDictTest, test_swap_empty) {
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map = {{1, 10}, {8, 80}, {3, 30}};
-    ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map2;
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map =
+      {{1, 10}, {8, 80}, {3, 30}};
+  ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t> map2;
 
-    using std::swap;
-    swap(map, map2);
+  using std::swap;
+  swap(map, map2);
 
-    TORCH_INTERNAL_ASSERT(map == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{}));
-    TORCH_INTERNAL_ASSERT(map2 == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{1, 10}, {8, 80}, {3, 30}}));
+  TORCH_INTERNAL_ASSERT(
+      map ==
+      (ska_ordered::
+           order_preserving_flat_hash_map<std::int64_t, std::int64_t>{}));
+  TORCH_INTERNAL_ASSERT(
+      map2 ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {1, 10}, {8, 80}, {3, 30}}));
 
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    map.insert({6, 60});
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-    map2.insert({4, 40});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  map.insert({6, 60});
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+  map2.insert({4, 40});
 
-    TORCH_INTERNAL_ASSERT(map == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{6, 60}}));
-    TORCH_INTERNAL_ASSERT(map2 == (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{{1, 10}, {8, 80}, {3, 30}, {4, 40}}));
+  TORCH_INTERNAL_ASSERT(
+      map ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {6, 60}}));
+  TORCH_INTERNAL_ASSERT(
+      map2 ==
+      (ska_ordered::order_preserving_flat_hash_map<std::int64_t, std::int64_t>{
+          {1, 10}, {8, 80}, {3, 30}, {4, 40}}));
 }
 
-}
+} // namespace
diff --git a/c10/test/util/string_view_test.cpp b/c10/test/util/string_view_test.cpp
index 907461fc5f1..c5d05d808a8 100644
--- a/c10/test/util/string_view_test.cpp
+++ b/c10/test/util/string_view_test.cpp
@@ -7,9 +7,9 @@ using c10::string_view;
 namespace {
 namespace testutils {
 constexpr bool string_equal(const char* lhs, const char* rhs, size_t size) {
-  return (size == 0)
-      ? true
-      : (*lhs != *rhs) ? false : string_equal(lhs + 1, rhs + 1, size - 1);
+  return (size == 0)   ? true
+      : (*lhs != *rhs) ? false
+                       : string_equal(lhs + 1, rhs + 1, size - 1);
 }
 static_assert(string_equal("hi", "hi", 2), "");
 static_assert(string_equal("", "", 0), "");
@@ -124,7 +124,8 @@ TEST(StringViewTest, testCopyAssignment) {
     static_assert(5 == (string_view() = "hello").size(), "");
     static_assert(
         // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
-        string_equal("hello", (string_view() = "hello").data(), 5), "");
+        string_equal("hello", (string_view() = "hello").data(), 5),
+        "");
   }
 #endif
   const string_view hello = assign("hello");
@@ -233,7 +234,7 @@ static_assert('o' == string_view("hello").back(), "");
 namespace test_data {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
 static_assert(string_equal("hello", string_view("hello").data(), 5), "");
-}
+} // namespace test_data
 
 namespace test_size_length {
 static_assert(0 == string_view("").size(), "");
diff --git a/c10/test/util/tempfile_test.cpp b/c10/test/util/tempfile_test.cpp
index 478f6279a1f..3b568460dad 100644
--- a/c10/test/util/tempfile_test.cpp
+++ b/c10/test/util/tempfile_test.cpp
@@ -1,7 +1,7 @@
 #include <c10/util/tempfile.h>
 #include <gtest/gtest.h>
-#include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 
 #if !defined(_WIN32)
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
diff --git a/c10/test/util/typeid_test.cpp b/c10/test/util/typeid_test.cpp
index 80399835894..dab9fc67943 100644
--- a/c10/test/util/typeid_test.cpp
+++ b/c10/test/util/typeid_test.cpp
@@ -8,7 +8,7 @@ namespace {
 
 class TypeMetaTestFoo {};
 class TypeMetaTestBar {};
-}
+} // namespace
 
 CAFFE_KNOWN_TYPE(TypeMetaTestFoo);
 CAFFE_KNOWN_TYPE(TypeMetaTestBar);
@@ -73,7 +73,6 @@ TEST(TypeMetaTest, TypeMeta) {
   EXPECT_NE(bar_meta.name().find("TypeMetaTestBar"), c10::string_view::npos);
 }
 
-
 class ClassAllowAssignment {
  public:
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
@@ -92,7 +91,7 @@ class ClassNoAssignment {
   ClassNoAssignment& operator=(const ClassNoAssignment& src) = delete;
   int x;
 };
-}
+} // namespace
 
 CAFFE_KNOWN_TYPE(ClassAllowAssignment);
 CAFFE_KNOWN_TYPE(ClassNoAssignment);
@@ -135,5 +134,5 @@ TEST(TypeMetaTest, Float16IsNotUint16) {
   EXPECT_NE(TypeMeta::Id<uint16_t>(), TypeMeta::Id<at::Half>());
 }
 
-}  // namespace
-}  // namespace caffe2
+} // namespace
+} // namespace caffe2
diff --git a/c10/util/Array.h b/c10/util/Array.h
index cc3630cc157..f33a36e8e84 100644
--- a/c10/util/Array.h
+++ b/c10/util/Array.h
@@ -1,18 +1,20 @@
 /**
-* This file is based on the std::array implementation of libstdc++ at
-* https://gcc.gnu.org/onlinedocs/gcc-7.1.0/libstdc++/api/a01056_source.html
-*
-* Changes:
-*  - isolate, i.e. remove dependencies on internal libstdc++ stuff
-*  - use c++17 behavior even in c++11 or c++14
-*  - remove std::swappable special case because that doesn't work with MSVC
-*  - constexpr more things
-*  - add some features like prepend/tail
-*
-* If using std::array at runtime, feel free to either keep using std::array or use this one - it doesn't really matter.
-* For compile time computations, this one here is preferred because std::array in C++11
-* misses some constexpr specifiers, forcing these methods to be called at runtime instead of compile time.
-*/
+ * This file is based on the std::array implementation of libstdc++ at
+ * https://gcc.gnu.org/onlinedocs/gcc-7.1.0/libstdc++/api/a01056_source.html
+ *
+ * Changes:
+ *  - isolate, i.e. remove dependencies on internal libstdc++ stuff
+ *  - use c++17 behavior even in c++11 or c++14
+ *  - remove std::swappable special case because that doesn't work with MSVC
+ *  - constexpr more things
+ *  - add some features like prepend/tail
+ *
+ * If using std::array at runtime, feel free to either keep using std::array or
+ * use this one - it doesn't really matter. For compile time computations, this
+ * one here is preferred because std::array in C++11 misses some constexpr
+ * specifiers, forcing these methods to be called at runtime instead of compile
+ * time.
+ */
 
 // Copyright (C) 2007-2017 Free Software Foundation, Inc.
 //
@@ -38,16 +40,17 @@
 
 #pragma once
 
-#include <algorithm>
 #include <c10/util/C++17.h>
+#include <algorithm>
 #include <stdexcept>
 #include <string>
 #include <utility>
 
-namespace c10 { namespace guts {
+namespace c10 {
+namespace guts {
 
 namespace detail {
-template<typename _Tp, std::size_t _Nm>
+template <typename _Tp, std::size_t _Nm>
 struct __array_traits final {
   using _Type = _Tp[_Nm];
 
@@ -60,7 +63,7 @@ struct __array_traits final {
   }
 };
 
-template<typename _Tp>
+template <typename _Tp>
 struct __array_traits<_Tp, 0> final {
   struct _Type final {};
 
@@ -76,11 +79,11 @@ struct __array_traits<_Tp, 0> final {
 [[noreturn]] inline void __throw_out_of_range(std::string msg) {
   throw std::out_of_range(std::move(msg));
 }
-}
+} // namespace detail
 
-template<typename _Tp, std::size_t _Nm>
+template <typename _Tp, std::size_t _Nm>
 class array final {
-public:
+ public:
   using value_type = _Tp;
   using pointer = value_type*;
   using const_pointer = const value_type*;
@@ -93,76 +96,99 @@ public:
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-private:
+ private:
   using _AT_Type = detail::__array_traits<_Tp, _Nm>;
-public: // needs to be public member for aggregate initialization
+
+ public: // needs to be public member for aggregate initialization
   typename _AT_Type::_Type _M_elems;
 
-public:
+ public:
   // No explicit construct/copy/destroy for aggregate type.
 
   // DR 776.
-  constexpr void fill(const value_type& __u)
-  { std::fill_n(begin(), size(), __u); }
+  constexpr void fill(const value_type& __u) {
+    std::fill_n(begin(), size(), __u);
+  }
 
-  constexpr void swap(array& __other)
-  { std::swap_ranges(begin(), end(), __other.begin()); }
+  constexpr void swap(array& __other) {
+    std::swap_ranges(begin(), end(), __other.begin());
+  }
 
   // Iterators.
-  constexpr iterator begin() noexcept
-  { return iterator(data()); }
+  constexpr iterator begin() noexcept {
+    return iterator(data());
+  }
 
-  constexpr const_iterator begin() const noexcept
-  { return const_iterator(data()); }
+  constexpr const_iterator begin() const noexcept {
+    return const_iterator(data());
+  }
 
-  constexpr iterator end() noexcept
-  { return iterator(data() + _Nm); }
+  constexpr iterator end() noexcept {
+    return iterator(data() + _Nm);
+  }
 
-  constexpr const_iterator end() const noexcept
-  { return const_iterator(data() + _Nm); }
+  constexpr const_iterator end() const noexcept {
+    return const_iterator(data() + _Nm);
+  }
 
-  constexpr reverse_iterator rbegin() noexcept
-  { return reverse_iterator(end()); }
+  constexpr reverse_iterator rbegin() noexcept {
+    return reverse_iterator(end());
+  }
 
-  constexpr const_reverse_iterator rbegin() const noexcept
-  { return const_reverse_iterator(end()); }
+  constexpr const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
 
-  constexpr reverse_iterator rend() noexcept
-  { return reverse_iterator(begin()); }
+  constexpr reverse_iterator rend() noexcept {
+    return reverse_iterator(begin());
+  }
 
-  constexpr const_reverse_iterator rend() const noexcept
-  { return const_reverse_iterator(begin()); }
+  constexpr const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
 
-  constexpr const_iterator cbegin() const noexcept
-  { return const_iterator(data()); }
+  constexpr const_iterator cbegin() const noexcept {
+    return const_iterator(data());
+  }
 
-  constexpr const_iterator cend() const noexcept
-  { return const_iterator(data() + _Nm); }
+  constexpr const_iterator cend() const noexcept {
+    return const_iterator(data() + _Nm);
+  }
 
-  constexpr const_reverse_iterator crbegin() const noexcept
-  { return const_reverse_iterator(end()); }
+  constexpr const_reverse_iterator crbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
 
-  constexpr const_reverse_iterator crend() const noexcept
-  { return const_reverse_iterator(begin()); }
+  constexpr const_reverse_iterator crend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
 
   // Capacity.
-  constexpr size_type size() const noexcept { return _Nm; }
+  constexpr size_type size() const noexcept {
+    return _Nm;
+  }
 
-  constexpr size_type max_size() const noexcept { return _Nm; }
+  constexpr size_type max_size() const noexcept {
+    return _Nm;
+  }
 
-  constexpr bool empty() const noexcept { return size() == 0; }
+  constexpr bool empty() const noexcept {
+    return size() == 0;
+  }
 
   // Element access.
-  constexpr reference operator[](size_type __n) noexcept
-  { return _AT_Type::_S_ref(_M_elems, __n); }
+  constexpr reference operator[](size_type __n) noexcept {
+    return _AT_Type::_S_ref(_M_elems, __n);
+  }
 
-  constexpr const_reference operator[](size_type __n) const noexcept
-  { return _AT_Type::_S_ref(_M_elems, __n); }
+  constexpr const_reference operator[](size_type __n) const noexcept {
+    return _AT_Type::_S_ref(_M_elems, __n);
+  }
 
   constexpr reference at(size_type __n) {
     if (__n >= _Nm) {
-      detail::__throw_out_of_range(std::string() +
-          "array::at: __n (which is " + to_string(__n) + ") " +
+      detail::__throw_out_of_range(
+          std::string() + "array::at: __n (which is " + to_string(__n) + ") " +
           ">= _Nm (which is " + to_string(_Nm) + ")");
     }
     return _AT_Type::_S_ref(_M_elems, __n);
@@ -171,101 +197,133 @@ public:
   constexpr const_reference at(size_type __n) const {
     // Result of conditional expression must be an lvalue so use
     // boolean ? lvalue : (throw-expr, lvalue)
-    return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
-      : (detail::__throw_out_of_range(std::string() +
-            "array::at: __n (which is " + to_string(__n) + ") " +
-            ">= _Nm (which is " + to_string(_Nm) + ")"),
-         _AT_Type::_S_ref(_M_elems, 0));
-     }
-
-  constexpr reference front() noexcept
-  { return *begin(); }
-
-  constexpr const_reference front() const noexcept
-  { return _AT_Type::_S_ref(_M_elems, 0); }
-
-  constexpr reference back() noexcept
-  { return _Nm ? *(end() - 1) : *end(); }
-
-  constexpr const_reference back() const noexcept
-  {
-    return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
-            : _AT_Type::_S_ref(_M_elems, 0);
+    return __n < _Nm
+        ? _AT_Type::_S_ref(_M_elems, __n)
+        : (detail::__throw_out_of_range(
+               std::string() + "array::at: __n (which is " + to_string(__n) +
+               ") " + ">= _Nm (which is " + to_string(_Nm) + ")"),
+           _AT_Type::_S_ref(_M_elems, 0));
   }
 
-  constexpr pointer data() noexcept
-  { return _AT_Type::_S_ptr(_M_elems); }
+  constexpr reference front() noexcept {
+    return *begin();
+  }
 
-  constexpr const_pointer data() const noexcept
-  { return _AT_Type::_S_ptr(_M_elems); }
+  constexpr const_reference front() const noexcept {
+    return _AT_Type::_S_ref(_M_elems, 0);
+  }
+
+  constexpr reference back() noexcept {
+    return _Nm ? *(end() - 1) : *end();
+  }
+
+  constexpr const_reference back() const noexcept {
+    return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+               : _AT_Type::_S_ref(_M_elems, 0);
+  }
+
+  constexpr pointer data() noexcept {
+    return _AT_Type::_S_ptr(_M_elems);
+  }
+
+  constexpr const_pointer data() const noexcept {
+    return _AT_Type::_S_ptr(_M_elems);
+  }
 };
 
 #if defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201606
-  template<typename _Tp, typename... _Up>
-  array(_Tp, _Up...) ->
-    array<std::enable_if_t<(std::is_same<_Tp, _Up>::value && ...), _Tp>, 1 + sizeof...(_Up)>;
+template <typename _Tp, typename... _Up>
+array(_Tp, _Up...) -> array<
+    std::enable_if_t<(std::is_same<_Tp, _Up>::value && ...), _Tp>,
+    1 + sizeof...(_Up)>;
 #endif
 
 // Array comparisons.
 namespace detail {
-template<class T, size_t N>
-constexpr inline bool array_equals_(const array<T, N>& lhs, const array<T, N>& rhs, size_t current_index) {
+template <class T, size_t N>
+constexpr inline bool array_equals_(
+    const array<T, N>& lhs,
+    const array<T, N>& rhs,
+    size_t current_index) {
   return (current_index == N)
-         ? true
-         : (lhs.at(current_index) == rhs.at(current_index) && array_equals_(lhs, rhs, current_index + 1));
+      ? true
+      : (lhs.at(current_index) == rhs.at(current_index) &&
+         array_equals_(lhs, rhs, current_index + 1));
 }
-template<class T, size_t N>
-constexpr inline bool array_less_(const array<T, N>& lhs, const array<T, N>& rhs, size_t current_index) {
+template <class T, size_t N>
+constexpr inline bool array_less_(
+    const array<T, N>& lhs,
+    const array<T, N>& rhs,
+    size_t current_index) {
   return (current_index == N)
-         ? false
-         : (lhs.at(current_index) < rhs.at(current_index) || array_less_(lhs, rhs, current_index + 1));
+      ? false
+      : (lhs.at(current_index) < rhs.at(current_index) ||
+         array_less_(lhs, rhs, current_index + 1));
 }
+} // namespace detail
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator==(
+    const array<_Tp, _Nm>& __one,
+    const array<_Tp, _Nm>& __two) {
+  return detail::array_equals_(__one, __two, 0);
 }
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-{ return detail::array_equals_(__one, __two, 0); }
 
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-{ return !(__one == __two); }
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator!=(
+    const array<_Tp, _Nm>& __one,
+    const array<_Tp, _Nm>& __two) {
+  return !(__one == __two);
+}
 
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
-{ return detail::array_less_(__a, __b, 0); }
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator<(
+    const array<_Tp, _Nm>& __a,
+    const array<_Tp, _Nm>& __b) {
+  return detail::array_less_(__a, __b, 0);
+}
 
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-{ return __two < __one; }
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator>(
+    const array<_Tp, _Nm>& __one,
+    const array<_Tp, _Nm>& __two) {
+  return __two < __one;
+}
 
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-{ return !(__one > __two); }
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator<=(
+    const array<_Tp, _Nm>& __one,
+    const array<_Tp, _Nm>& __two) {
+  return !(__one > __two);
+}
 
-template<typename _Tp, std::size_t _Nm>
-constexpr inline bool operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
-{ return !(__one < __two); }
+template <typename _Tp, std::size_t _Nm>
+constexpr inline bool operator>=(
+    const array<_Tp, _Nm>& __one,
+    const array<_Tp, _Nm>& __two) {
+  return !(__one < __two);
+}
 
 // Specialized algorithms.
-template<typename _Tp, std::size_t _Nm>
-inline void swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two)))
-{ __one.swap(__two); }
-
-template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept {
-   static_assert(_Int < _Nm, "array index is within bounds");
-   return detail::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
+template <typename _Tp, std::size_t _Nm>
+inline void swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(
+    noexcept(__one.swap(__two))) {
+  __one.swap(__two);
 }
 
-template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept
-{
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept {
+  static_assert(_Int < _Nm, "array index is within bounds");
+  return detail::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
+}
+
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept {
   static_assert(_Int < _Nm, "array index is within bounds");
   return std::move(get<_Int>(__arr));
 }
 
-template<std::size_t _Int, typename _Tp, std::size_t _Nm>
-constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept
-{
+template <std::size_t _Int, typename _Tp, std::size_t _Nm>
+constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept {
   static_assert(_Int < _Nm, "array index is within bounds");
   return detail::__array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int);
 }
@@ -278,27 +336,34 @@ constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept
  *  prepend(2, {3, 4}) == {2, 3, 4}
  */
 namespace detail {
-template<class T, size_t N, size_t... INDEX>
-constexpr inline array<T, N-1> tail_(const array<T, N>& arg, std::index_sequence<INDEX...>) {
-  static_assert(sizeof...(INDEX) == N-1, "invariant");
-  return {{get<INDEX+1>(arg)...}};
+template <class T, size_t N, size_t... INDEX>
+constexpr inline array<T, N - 1> tail_(
+    const array<T, N>& arg,
+    std::index_sequence<INDEX...>) {
+  static_assert(sizeof...(INDEX) == N - 1, "invariant");
+  return {{get<INDEX + 1>(arg)...}};
 }
-}
-template<class T, size_t N>
-constexpr inline array<T, N-1> tail(const array<T, N>& arg) {
-  static_assert(N > 0, "Can only call tail() on an array with at least one element");
-  return detail::tail_(arg, std::make_index_sequence<N-1>());
+} // namespace detail
+template <class T, size_t N>
+constexpr inline array<T, N - 1> tail(const array<T, N>& arg) {
+  static_assert(
+      N > 0, "Can only call tail() on an array with at least one element");
+  return detail::tail_(arg, std::make_index_sequence<N - 1>());
 }
 
 namespace detail {
-template<class T, size_t N, size_t... INDEX>
-constexpr inline array<T, N+1> prepend_(T&& head, const array<T, N>& tail, std::index_sequence<INDEX...>) {
+template <class T, size_t N, size_t... INDEX>
+constexpr inline array<T, N + 1> prepend_(
+    T&& head,
+    const array<T, N>& tail,
+    std::index_sequence<INDEX...>) {
   return {{std::forward<T>(head), get<INDEX>(tail)...}};
 }
-}
-template<class T, size_t N>
-constexpr inline array<T, N+1> prepend(T&& head, const array<T, N>& tail) {
-  return detail::prepend_(std::forward<T>(head), tail, std::make_index_sequence<N>());
+} // namespace detail
+template <class T, size_t N>
+constexpr inline array<T, N + 1> prepend(T&& head, const array<T, N>& tail) {
+  return detail::prepend_(
+      std::forward<T>(head), tail, std::make_index_sequence<N>());
 }
 
 /**
@@ -309,15 +374,18 @@ constexpr inline array<T, N+1> prepend(T&& head, const array<T, N>& tail) {
  */
 
 namespace detail {
-template<class T, size_t N, size_t... INDEX>
-constexpr array<T, N> to_array_(const T (&arr)[N], std::index_sequence<INDEX...>) {
+template <class T, size_t N, size_t... INDEX>
+constexpr array<T, N> to_array_(
+    const T (&arr)[N],
+    std::index_sequence<INDEX...>) {
   return {{arr[INDEX]...}};
 }
-}
+} // namespace detail
 
-template<class T, size_t N>
+template <class T, size_t N>
 constexpr array<T, N> to_array(const T (&arr)[N]) {
   return detail::to_array_(arr, std::make_index_sequence<N>());
 }
 
-}}
+} // namespace guts
+} // namespace c10
diff --git a/c10/util/ArrayRef.h b/c10/util/ArrayRef.h
index ee40c572187..d0bc5a207b0 100644
--- a/c10/util/ArrayRef.h
+++ b/c10/util/ArrayRef.h
@@ -15,10 +15,10 @@
 
 #pragma once
 
-#include <c10/util/SmallVector.h>
 #include <c10/util/C++17.h>
-#include <c10/util/Exception.h>
 #include <c10/util/Deprecated.h>
+#include <c10/util/Exception.h>
+#include <c10/util/SmallVector.h>
 
 #include <array>
 #include <iterator>
@@ -81,12 +81,15 @@ class ArrayRef final {
       : Data(Vec.data()), Length(Vec.size()) {}
 
   /// Construct an ArrayRef from a std::vector.
-  // The enable_if stuff here makes sure that this isn't used for std::vector<bool>,
-  // because ArrayRef can't work on a std::vector<bool> bitfield.
+  // The enable_if stuff here makes sure that this isn't used for
+  // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
+  // bitfield.
   template <typename A>
   /* implicit */ ArrayRef(const std::vector<T, A>& Vec)
       : Data(Vec.data()), Length(Vec.size()) {
-    static_assert(!std::is_same<T, bool>::value, "ArrayRef<bool> cannot be constructed from a std::vector<bool> bitfield.");
+    static_assert(
+        !std::is_same<T, bool>::value,
+        "ArrayRef<bool> cannot be constructed from a std::vector<bool> bitfield.");
   }
 
   /// Construct an ArrayRef from a std::array
@@ -100,7 +103,9 @@ class ArrayRef final {
 
   /// Construct an ArrayRef from a std::initializer_list.
   /* implicit */ constexpr ArrayRef(const std::initializer_list<T>& Vec)
-      : Data(std::begin(Vec) == std::end(Vec) ? static_cast<T*>(nullptr) : std::begin(Vec)),
+      : Data(
+            std::begin(Vec) == std::end(Vec) ? static_cast<T*>(nullptr)
+                                             : std::begin(Vec)),
         Length(Vec.size()) {}
 
   /// @}
@@ -146,7 +151,8 @@ class ArrayRef final {
 
   /// front - Get the first element.
   C10_HOST_CONSTEXPR_EXCEPT_WIN_CUDA const T& front() const {
-    TORCH_CHECK(!empty(), "ArrayRef: attempted to access front() of empty list");
+    TORCH_CHECK(
+        !empty(), "ArrayRef: attempted to access front() of empty list");
     return Data[0];
   }
 
@@ -162,7 +168,8 @@ class ArrayRef final {
   }
 
   /// slice(n, m) - Take M elements of the array starting at element N
-  C10_HOST_CONSTEXPR_EXCEPT_WIN_CUDA ArrayRef<T> slice(size_t N, size_t M) const {
+  C10_HOST_CONSTEXPR_EXCEPT_WIN_CUDA ArrayRef<T> slice(size_t N, size_t M)
+      const {
     TORCH_CHECK(
         N + M <= size(),
         "ArrayRef: invalid slice, N = ",
@@ -224,10 +231,10 @@ class ArrayRef final {
 };
 
 template <typename T>
-std::ostream& operator<<(std::ostream & out, ArrayRef<T> list) {
+std::ostream& operator<<(std::ostream& out, ArrayRef<T> list) {
   int i = 0;
   out << "[";
-  for(auto e : list) {
+  for (auto e : list) {
     if (i++ > 0)
       out << ", ";
     out << e;
diff --git a/c10/util/BFloat16-inl.h b/c10/util/BFloat16-inl.h
index e683cd9df8e..9dd30d2d5af 100644
--- a/c10/util/BFloat16-inl.h
+++ b/c10/util/BFloat16-inl.h
@@ -7,7 +7,8 @@ namespace c10 {
 
 /// Constructors
 inline C10_HOST_DEVICE BFloat16::BFloat16(float value) {
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000 && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000 && \
+    defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
   x = __bfloat16_as_ushort(__float2bfloat16(value));
 #else
   // RNE by default
@@ -37,8 +38,9 @@ inline C10_HOST_DEVICE BFloat16::operator __nv_bfloat16() const {
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
 inline C10_DEVICE BFloat16 __ldg(const BFloat16* ptr) {
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000 && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
-  return __ldg(reinterpret_cast<const __nv_bfloat16 *>(ptr));
+#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000 && \
+    defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
+  return __ldg(reinterpret_cast<const __nv_bfloat16*>(ptr));
 #else
   return *ptr;
 #endif
@@ -47,19 +49,23 @@ inline C10_DEVICE BFloat16 __ldg(const BFloat16* ptr) {
 
 /// Arithmetic
 
-inline C10_HOST_DEVICE BFloat16 operator+(const BFloat16& a, const BFloat16& b) {
+inline C10_HOST_DEVICE BFloat16
+operator+(const BFloat16& a, const BFloat16& b) {
   return static_cast<float>(a) + static_cast<float>(b);
 }
 
-inline C10_HOST_DEVICE BFloat16 operator-(const BFloat16& a, const BFloat16& b) {
+inline C10_HOST_DEVICE BFloat16
+operator-(const BFloat16& a, const BFloat16& b) {
   return static_cast<float>(a) - static_cast<float>(b);
 }
 
-inline C10_HOST_DEVICE BFloat16 operator*(const BFloat16& a, const BFloat16& b) {
+inline C10_HOST_DEVICE BFloat16
+operator*(const BFloat16& a, const BFloat16& b) {
   return static_cast<float>(a) * static_cast<float>(b);
 }
 
-inline C10_HOST_DEVICE BFloat16 operator/(const BFloat16& a, const BFloat16& b) __ubsan_ignore_float_divide_by_zero__ {
+inline C10_HOST_DEVICE BFloat16 operator/(const BFloat16& a, const BFloat16& b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return static_cast<float>(a) / static_cast<float>(b);
 }
 
@@ -243,7 +249,7 @@ namespace std {
 
 template <>
 class numeric_limits<c10::BFloat16> {
-public:
+ public:
   static constexpr bool is_signed = true;
   static constexpr bool is_specialized = true;
   static constexpr bool is_integer = false;
diff --git a/c10/util/BFloat16-math.h b/c10/util/BFloat16-math.h
index 73f04869549..ac625bade07 100644
--- a/c10/util/BFloat16-math.h
+++ b/c10/util/BFloat16-math.h
@@ -6,35 +6,89 @@
 namespace std {
 
 /// Used by vec256<c10::BFloat16>::map
-inline c10::BFloat16 acos(c10::BFloat16 a) { return std::acos(float(a));}
-inline c10::BFloat16 asin(c10::BFloat16 a) { return std::asin(float(a));}
-inline c10::BFloat16 atan(c10::BFloat16 a) { return std::atan(float(a));}
-inline c10::BFloat16 erf(c10::BFloat16 a) { return std::erf(float(a));}
-inline c10::BFloat16 erfc(c10::BFloat16 a) { return std::erfc(float(a));}
-inline c10::BFloat16 exp(c10::BFloat16 a) { return std::exp(float(a));}
-inline c10::BFloat16 expm1(c10::BFloat16 a) { return std::expm1(float(a));}
-inline c10::BFloat16 log(c10::BFloat16 a) { return std::log(float(a));}
-inline c10::BFloat16 log10(c10::BFloat16 a) { return std::log10(float(a));}
-inline c10::BFloat16 log1p(c10::BFloat16 a) { return std::log1p(float(a));}
-inline c10::BFloat16 log2(c10::BFloat16 a) { return std::log2(float(a));}
-inline c10::BFloat16 ceil(c10::BFloat16 a) { return std::ceil(float(a));}
-inline c10::BFloat16 cos(c10::BFloat16 a) { return std::cos(float(a));}
-inline c10::BFloat16 floor(c10::BFloat16 a) { return std::floor(float(a));}
-inline c10::BFloat16 nearbyint(c10::BFloat16 a) { return std::nearbyint(float(a));}
-inline c10::BFloat16 sin(c10::BFloat16 a) { return std::sin(float(a));}
-inline c10::BFloat16 tan(c10::BFloat16 a) { return std::tan(float(a));}
-inline c10::BFloat16 tanh(c10::BFloat16 a) { return std::tanh(float(a));}
-inline c10::BFloat16 trunc(c10::BFloat16 a) { return std::trunc(float(a));}
-inline c10::BFloat16 lgamma(c10::BFloat16 a) { return std::lgamma(float(a));}
-inline c10::BFloat16 sqrt(c10::BFloat16 a) { return std::sqrt(float(a));}
-inline c10::BFloat16 rsqrt(c10::BFloat16 a) { return 1.0 / std::sqrt(float(a));}
-inline c10::BFloat16 abs(c10::BFloat16 a) { return std::abs(float(a));}
+inline c10::BFloat16 acos(c10::BFloat16 a) {
+  return std::acos(float(a));
+}
+inline c10::BFloat16 asin(c10::BFloat16 a) {
+  return std::asin(float(a));
+}
+inline c10::BFloat16 atan(c10::BFloat16 a) {
+  return std::atan(float(a));
+}
+inline c10::BFloat16 erf(c10::BFloat16 a) {
+  return std::erf(float(a));
+}
+inline c10::BFloat16 erfc(c10::BFloat16 a) {
+  return std::erfc(float(a));
+}
+inline c10::BFloat16 exp(c10::BFloat16 a) {
+  return std::exp(float(a));
+}
+inline c10::BFloat16 expm1(c10::BFloat16 a) {
+  return std::expm1(float(a));
+}
+inline c10::BFloat16 log(c10::BFloat16 a) {
+  return std::log(float(a));
+}
+inline c10::BFloat16 log10(c10::BFloat16 a) {
+  return std::log10(float(a));
+}
+inline c10::BFloat16 log1p(c10::BFloat16 a) {
+  return std::log1p(float(a));
+}
+inline c10::BFloat16 log2(c10::BFloat16 a) {
+  return std::log2(float(a));
+}
+inline c10::BFloat16 ceil(c10::BFloat16 a) {
+  return std::ceil(float(a));
+}
+inline c10::BFloat16 cos(c10::BFloat16 a) {
+  return std::cos(float(a));
+}
+inline c10::BFloat16 floor(c10::BFloat16 a) {
+  return std::floor(float(a));
+}
+inline c10::BFloat16 nearbyint(c10::BFloat16 a) {
+  return std::nearbyint(float(a));
+}
+inline c10::BFloat16 sin(c10::BFloat16 a) {
+  return std::sin(float(a));
+}
+inline c10::BFloat16 tan(c10::BFloat16 a) {
+  return std::tan(float(a));
+}
+inline c10::BFloat16 tanh(c10::BFloat16 a) {
+  return std::tanh(float(a));
+}
+inline c10::BFloat16 trunc(c10::BFloat16 a) {
+  return std::trunc(float(a));
+}
+inline c10::BFloat16 lgamma(c10::BFloat16 a) {
+  return std::lgamma(float(a));
+}
+inline c10::BFloat16 sqrt(c10::BFloat16 a) {
+  return std::sqrt(float(a));
+}
+inline c10::BFloat16 rsqrt(c10::BFloat16 a) {
+  return 1.0 / std::sqrt(float(a));
+}
+inline c10::BFloat16 abs(c10::BFloat16 a) {
+  return std::abs(float(a));
+}
 #if defined(_MSC_VER) && defined(__CUDACC__)
-inline c10::BFloat16 pow(c10::BFloat16 a, double b) { return std::pow(float(a), float(b));}
+inline c10::BFloat16 pow(c10::BFloat16 a, double b) {
+  return std::pow(float(a), float(b));
+}
 #else
-inline c10::BFloat16 pow(c10::BFloat16 a, double b) { return std::pow(float(a), b);}
+inline c10::BFloat16 pow(c10::BFloat16 a, double b) {
+  return std::pow(float(a), b);
+}
 #endif
-inline c10::BFloat16 pow(c10::BFloat16 a, c10::BFloat16 b) { return std::pow(float(a), float(b));}
-inline c10::BFloat16 fmod(c10::BFloat16 a, c10::BFloat16 b) { return std::fmod(float(a), float(b));}
+inline c10::BFloat16 pow(c10::BFloat16 a, c10::BFloat16 b) {
+  return std::pow(float(a), float(b));
+}
+inline c10::BFloat16 fmod(c10::BFloat16 a, c10::BFloat16 b) {
+  return std::fmod(float(a), float(b));
+}
 
 } // namespace std
diff --git a/c10/util/BFloat16.h b/c10/util/BFloat16.h
index ce0d229b72c..5446eb94192 100644
--- a/c10/util/BFloat16.h
+++ b/c10/util/BFloat16.h
@@ -14,60 +14,60 @@
 namespace c10 {
 
 namespace detail {
-  inline C10_HOST_DEVICE float f32_from_bits(uint16_t src) {
-    float res = 0;
-    uint32_t tmp = src;
-    tmp <<= 16;
+inline C10_HOST_DEVICE float f32_from_bits(uint16_t src) {
+  float res = 0;
+  uint32_t tmp = src;
+  tmp <<= 16;
 
 #ifdef __HIP_PLATFORM_HCC__
-    float* tempRes;
+  float* tempRes;
 
-    // We should be using memcpy in order to respect the strict aliasing rule
-    // but it fails in the HIP environment.
-    tempRes = reinterpret_cast<float*>(&tmp);
-    res = *tempRes;
+  // We should be using memcpy in order to respect the strict aliasing rule
+  // but it fails in the HIP environment.
+  tempRes = reinterpret_cast<float*>(&tmp);
+  res = *tempRes;
 #else
-    std::memcpy(&res, &tmp, sizeof(tmp));
+  std::memcpy(&res, &tmp, sizeof(tmp));
 #endif
 
-    return res;
-  }
+  return res;
+}
 
-  inline C10_HOST_DEVICE uint16_t bits_from_f32(float src) {
-    uint32_t res = 0;
+inline C10_HOST_DEVICE uint16_t bits_from_f32(float src) {
+  uint32_t res = 0;
 
 #ifdef __HIP_PLATFORM_HCC__
-    // We should be using memcpy in order to respect the strict aliasing rule
-    // but it fails in the HIP environment.
-    uint32_t* tempRes = reinterpret_cast<uint32_t*>(&src);
-    res = *tempRes;
+  // We should be using memcpy in order to respect the strict aliasing rule
+  // but it fails in the HIP environment.
+  uint32_t* tempRes = reinterpret_cast<uint32_t*>(&src);
+  res = *tempRes;
 #else
-    std::memcpy(&res, &src, sizeof(res));
+  std::memcpy(&res, &src, sizeof(res));
 #endif
 
-    return res >> 16;
-  }
+  return res >> 16;
+}
 
-  inline C10_HOST_DEVICE uint16_t round_to_nearest_even(float src) {
+inline C10_HOST_DEVICE uint16_t round_to_nearest_even(float src) {
 #if defined(__HIP_PLATFORM_HCC__)
-    if(src != src) {
+  if (src != src) {
 #elif defined(_MSC_VER)
-    if (isnan(src)) {
+  if (isnan(src)) {
 #else
-    if (std::isnan(src)) {
+  if (std::isnan(src)) {
 #endif
-      return UINT16_C(0x7FC0);
-    } else {
-      union {
-        uint32_t U32;
-        float F32;
-      };
+    return UINT16_C(0x7FC0);
+  } else {
+    union {
+      uint32_t U32;
+      float F32;
+    };
 
-      F32 = src;
-      uint32_t rounding_bias = ((U32 >> 16) & 1) + UINT32_C(0x7FFF);
-      return static_cast<uint16_t>((U32 + rounding_bias) >> 16);
-    }
+    F32 = src;
+    uint32_t rounding_bias = ((U32 >> 16) & 1) + UINT32_C(0x7FFF);
+    return static_cast<uint16_t>((U32 + rounding_bias) >> 16);
   }
+}
 } // namespace detail
 
 struct alignas(2) BFloat16 {
@@ -85,7 +85,8 @@ struct alignas(2) BFloat16 {
     return from_bits_t();
   }
 
-  constexpr C10_HOST_DEVICE BFloat16(unsigned short bits, from_bits_t) : x(bits){};
+  constexpr C10_HOST_DEVICE BFloat16(unsigned short bits, from_bits_t)
+      : x(bits){};
   inline C10_HOST_DEVICE BFloat16(float value);
   inline C10_HOST_DEVICE operator float() const;
 
@@ -97,5 +98,4 @@ struct alignas(2) BFloat16 {
 
 } // namespace c10
 
-
 #include <c10/util/BFloat16-inl.h>
diff --git a/c10/util/Backtrace.cpp b/c10/util/Backtrace.cpp
index b3b84850b2d..d978f32cd00 100644
--- a/c10/util/Backtrace.cpp
+++ b/c10/util/Backtrace.cpp
@@ -251,7 +251,8 @@ std::string get_backtrace(
   return stream.str();
 #elif defined(_MSC_VER) // !SUPPORTS_BACKTRACE
   // This backtrace retrieval is implemented on Windows via the Windows
-  // API using `CaptureStackBackTrace`, `SymFromAddr` and `SymGetLineFromAddr64`.
+  // API using `CaptureStackBackTrace`, `SymFromAddr` and
+  // `SymGetLineFromAddr64`.
   // https://stackoverflow.com/questions/5693192/win32-backtrace-from-c-code
   // https://stackoverflow.com/questions/26398064/counterpart-to-glibcs-backtrace-and-backtrace-symbols-on-windows
   // https://docs.microsoft.com/en-us/windows/win32/debug/capturestackbacktrace
@@ -313,7 +314,8 @@ std::string get_backtrace(
            << back_trace[i_frame] << std::dec;
     if (with_symbol) {
       stream << std::setfill('0') << std::setw(16) << std::uppercase << std::hex
-             << p_symbol->Address << std::dec << " " << module << "!" << p_symbol->Name;
+             << p_symbol->Address << std::dec << " " << module << "!"
+             << p_symbol->Name;
     } else {
       stream << " <unknown symbol address> " << module << "!<unknown symbol>";
     }
diff --git a/c10/util/Bitset.h b/c10/util/Bitset.h
index 3e67169345c..6f7c4b9a1d7 100644
--- a/c10/util/Bitset.h
+++ b/c10/util/Bitset.h
@@ -21,15 +21,15 @@ namespace utils {
  * to exist is that std::bitset misses a find_first_set() method.
  */
 struct bitset final {
-private:
-  #if defined(_MSC_VER)
-    // MSVCs _BitScanForward64 expects int64_t
-    using bitset_type = int64_t;
-  #else
-    // POSIX ffsll expects long long int
-    using bitset_type = long long int;
-  #endif
-public:
+ private:
+#if defined(_MSC_VER)
+  // MSVCs _BitScanForward64 expects int64_t
+  using bitset_type = int64_t;
+#else
+  // POSIX ffsll expects long long int
+  using bitset_type = long long int;
+#endif
+ public:
   static constexpr size_t NUM_BITS() {
     return 8 * sizeof(bitset_type);
   }
@@ -72,37 +72,38 @@ public:
     }
   }
 
-private:
+ private:
   // Return the index of the first set bit. The returned index is one-indexed
-  // (i.e. if the very first bit is set, this function returns '1'), and a return
-  // of '0' means that there was no bit set.
+  // (i.e. if the very first bit is set, this function returns '1'), and a
+  // return of '0' means that there was no bit set.
   size_t find_first_set() const {
-    #if defined(_MSC_VER) && defined(_M_X64)
-      unsigned long result;
-      bool has_bits_set = (0 != _BitScanForward64(&result, bitset_));
+#if defined(_MSC_VER) && defined(_M_X64)
+    unsigned long result;
+    bool has_bits_set = (0 != _BitScanForward64(&result, bitset_));
+    if (!has_bits_set) {
+      return 0;
+    }
+    return result + 1;
+#elif defined(_MSC_VER) && defined(_M_IX86)
+    unsigned long result;
+    if (static_cast<uint32_t>(bitset_) != 0) {
+      bool has_bits_set =
+          (0 != _BitScanForward(&result, static_cast<uint32_t>(bitset_)));
       if (!has_bits_set) {
         return 0;
       }
       return result + 1;
-    #elif defined(_MSC_VER) && defined(_M_IX86)
-      unsigned long result;
-      if (static_cast<uint32_t>(bitset_) != 0) {
-        bool has_bits_set = (0 != _BitScanForward(&result, static_cast<uint32_t>(bitset_)));
-        if (!has_bits_set) {
-          return 0;
-        }
-        return result + 1;
+    } else {
+      bool has_bits_set =
+          (0 != _BitScanForward(&result, static_cast<uint32_t>(bitset_ >> 32)));
+      if (!has_bits_set) {
+        return 32;
       }
-      else {
-        bool has_bits_set = (0 != _BitScanForward(&result, static_cast<uint32_t>(bitset_ >> 32)));
-        if (!has_bits_set) {
-          return 32;
-        }
-        return result + 33;
-      }
-    #else
-      return __builtin_ffsll(bitset_);
-    #endif
+      return result + 33;
+    }
+#else
+    return __builtin_ffsll(bitset_);
+#endif
   }
 
   friend bool operator==(bitset lhs, bitset rhs) noexcept {
diff --git a/c10/util/C++17.h b/c10/util/C++17.h
index fa872c89592..90b04d896c9 100644
--- a/c10/util/C++17.h
+++ b/c10/util/C++17.h
@@ -2,48 +2,51 @@
 #ifndef C10_UTIL_CPP17_H_
 #define C10_UTIL_CPP17_H_
 
-#include <type_traits>
-#include <utility>
+#include <c10/macros/Macros.h>
+#include <cstdlib>
+#include <functional>
 #include <memory>
 #include <sstream>
 #include <string>
-#include <cstdlib>
-#include <functional>
-#include <c10/macros/Macros.h>
+#include <type_traits>
+#include <utility>
 
 #if !defined(__clang__) && !defined(_MSC_VER) && defined(__GNUC__) && \
-  __GNUC__ < 5
-#error "You're trying to build PyTorch with a too old version of GCC. We need GCC 5 or later."
+    __GNUC__ < 5
+#error \
+    "You're trying to build PyTorch with a too old version of GCC. We need GCC 5 or later."
 #endif
 
 #if defined(__clang__) && __clang_major__ < 4
-#error "You're trying to build PyTorch with a too old version of Clang. We need Clang 4 or later."
+#error \
+    "You're trying to build PyTorch with a too old version of Clang. We need Clang 4 or later."
 #endif
 
-#if (defined(_MSC_VER) && (!defined(_MSVC_LANG) || _MSVC_LANG < 201402L)) || (!defined(_MSC_VER) && __cplusplus < 201402L)
+#if (defined(_MSC_VER) && (!defined(_MSVC_LANG) || _MSVC_LANG < 201402L)) || \
+    (!defined(_MSC_VER) && __cplusplus < 201402L)
 #error You need C++14 to compile PyTorch
 #endif
 
 #if defined(_WIN32) && (defined(min) || defined(max))
-#  error Macro clash with min and max -- define NOMINMAX when compiling your program on Windows
+#error Macro clash with min and max -- define NOMINMAX when compiling your program on Windows
 #endif
 
 /*
  * This header adds some polyfills with C++17 functionality
  */
 
-namespace c10 { namespace guts {
-
+namespace c10 {
+namespace guts {
 
 template <typename Base, typename Child, typename... Args>
-typename std::enable_if<!std::is_array<Base>::value && !std::is_array<Base>::value && std::is_base_of<Base, Child>::value, std::unique_ptr<Base>>::type
+typename std::enable_if<
+    !std::is_array<Base>::value && !std::is_array<Base>::value &&
+        std::is_base_of<Base, Child>::value,
+    std::unique_ptr<Base>>::type
 make_unique_base(Args&&... args) {
   return std::unique_ptr<Base>(new Child(std::forward<Args>(args)...));
 }
 
-
-
-
 #if defined(__cpp_lib_logical_traits) && !(defined(_MSC_VER) && _MSC_VER < 1920)
 
 template <class... B>
@@ -58,42 +61,49 @@ using negation = std::negation<B>;
 #else
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/conjunction
-template<class...> struct conjunction : std::true_type { };
-template<class B1> struct conjunction<B1> : B1 { };
-template<class B1, class... Bn>
+template <class...>
+struct conjunction : std::true_type {};
+template <class B1>
+struct conjunction<B1> : B1 {};
+template <class B1, class... Bn>
 struct conjunction<B1, Bn...>
     : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/disjunction
-template<class...> struct disjunction : std::false_type { };
-template<class B1> struct disjunction<B1> : B1 { };
-template<class B1, class... Bn>
+template <class...>
+struct disjunction : std::false_type {};
+template <class B1>
+struct disjunction<B1> : B1 {};
+template <class B1, class... Bn>
 struct disjunction<B1, Bn...>
-    : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>>  { };
+    : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
 
-// Implementation taken from http://en.cppreference.com/w/cpp/types/integral_constant
+// Implementation taken from
+// http://en.cppreference.com/w/cpp/types/integral_constant
 template <bool B>
 using bool_constant = std::integral_constant<bool, B>;
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/negation
-template<class B>
-struct negation : bool_constant<!bool(B::value)> { };
+template <class B>
+struct negation : bool_constant<!bool(B::value)> {};
 
 #endif
 
-
-
-
 #ifdef __cpp_lib_void_t
 
-template<class T> using void_t = std::void_t<T>;
+template <class T>
+using void_t = std::void_t<T>;
 
 #else
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/void_t
 // (it takes CWG1558 into account and also works for older compilers)
-template<typename... Ts> struct make_void { typedef void type;};
-template<typename... Ts> using void_t = typename make_void<Ts...>::type;
+template <typename... Ts>
+struct make_void {
+  typedef void type;
+};
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
 
 #endif
 
@@ -113,34 +123,44 @@ CUDA_HOST_DEVICE inline constexpr decltype(auto) apply(F&& f, Tuple&& t) {
 
 #else
 
-// Implementation from http://en.cppreference.com/w/cpp/utility/apply (but modified)
-// TODO This is an incomplete implementation of std::apply, not working for member functions.
+// Implementation from http://en.cppreference.com/w/cpp/utility/apply (but
+// modified)
+// TODO This is an incomplete implementation of std::apply, not working for
+// member functions.
 namespace detail {
 template <class F, class Tuple, std::size_t... INDEX>
 #if defined(_MSC_VER)
-// MSVC has a problem with the decltype() return type, but it also doesn't need it
-C10_HOST_DEVICE constexpr auto apply_impl(F&& f, Tuple&& t, std::index_sequence<INDEX...>)
+// MSVC has a problem with the decltype() return type, but it also doesn't need
+// it
+C10_HOST_DEVICE constexpr auto apply_impl(
+    F&& f,
+    Tuple&& t,
+    std::index_sequence<INDEX...>)
 #else
 // GCC/Clang need the decltype() return type
-CUDA_HOST_DEVICE constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<INDEX...>)
+CUDA_HOST_DEVICE constexpr decltype(auto) apply_impl(
+    F&& f,
+    Tuple&& t,
+    std::index_sequence<INDEX...>)
 #endif
 {
-    return std::forward<F>(f)(std::get<INDEX>(std::forward<Tuple>(t))...);
+  return std::forward<F>(f)(std::get<INDEX>(std::forward<Tuple>(t))...);
 }
-}  // namespace detail
+} // namespace detail
 
 template <class F, class Tuple>
 CUDA_HOST_DEVICE constexpr decltype(auto) apply(F&& f, Tuple&& t) {
-    return detail::apply_impl(
-        std::forward<F>(f), std::forward<Tuple>(t),
-        std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
+  return detail::apply_impl(
+      std::forward<F>(f),
+      std::forward<Tuple>(t),
+      std::make_index_sequence<
+          std::tuple_size<std::remove_reference_t<Tuple>>::value>{});
 }
 
 #endif
 
 #undef CUDA_HOST_DEVICE
 
-
 template <typename Functor, typename... Args>
 typename std::enable_if<
     std::is_member_pointer<typename std::decay<Functor>::type>::value,
@@ -157,63 +177,94 @@ invoke(Functor&& f, Args&&... args) {
   return std::forward<Functor>(f)(std::forward<Args>(args)...);
 }
 
-
-
-
-
-
 namespace detail {
 struct _identity final {
-  template<class T>
+  template <class T>
   using type_identity = T;
 
-  template<class T>
+  template <class T>
   decltype(auto) operator()(T&& arg) {
     return std::forward<T>(arg);
   }
 };
 
-template<class Func, class Enable = void>
+template <class Func, class Enable = void>
 struct function_takes_identity_argument : std::false_type {};
 #if defined(_MSC_VER)
-// For some weird reason, MSVC shows a compiler error when using guts::void_t instead of std::void_t.
-// But we're only building on MSVC versions that have std::void_t, so let's just use that one.
-template<class Func>
-struct function_takes_identity_argument<Func, std::void_t<decltype(std::declval<Func>()(_identity()))>> : std::true_type {};
+// For some weird reason, MSVC shows a compiler error when using guts::void_t
+// instead of std::void_t. But we're only building on MSVC versions that have
+// std::void_t, so let's just use that one.
+template <class Func>
+struct function_takes_identity_argument<
+    Func,
+    std::void_t<decltype(std::declval<Func>()(_identity()))>> : std::true_type {
+};
 #else
-template<class Func>
-struct function_takes_identity_argument<Func, void_t<decltype(std::declval<Func>()(_identity()))>> : std::true_type {};
+template <class Func>
+struct function_takes_identity_argument<
+    Func,
+    void_t<decltype(std::declval<Func>()(_identity()))>> : std::true_type {};
 #endif
 
-template<bool Condition>
+template <bool Condition>
 struct _if_constexpr;
 
-template<>
+template <>
 struct _if_constexpr<true> final {
-  template<class ThenCallback, class ElseCallback, std::enable_if_t<function_takes_identity_argument<ThenCallback>::value, void*> = nullptr>
-  static decltype(auto) call(ThenCallback&& thenCallback, ElseCallback&& /* elseCallback */) {
-    // The _identity instance passed in can be used to delay evaluation of an expression,
-    // because the compiler can't know that it's just the identity we're passing in.
+  template <
+      class ThenCallback,
+      class ElseCallback,
+      std::enable_if_t<
+          function_takes_identity_argument<ThenCallback>::value,
+          void*> = nullptr>
+  static decltype(auto) call(
+      ThenCallback&& thenCallback,
+      ElseCallback&& /* elseCallback */) {
+    // The _identity instance passed in can be used to delay evaluation of an
+    // expression, because the compiler can't know that it's just the identity
+    // we're passing in.
     return thenCallback(_identity());
   }
 
-  template<class ThenCallback, class ElseCallback, std::enable_if_t<!function_takes_identity_argument<ThenCallback>::value, void*> = nullptr>
-  static decltype(auto) call(ThenCallback&& thenCallback, ElseCallback&& /* elseCallback */) {
+  template <
+      class ThenCallback,
+      class ElseCallback,
+      std::enable_if_t<
+          !function_takes_identity_argument<ThenCallback>::value,
+          void*> = nullptr>
+  static decltype(auto) call(
+      ThenCallback&& thenCallback,
+      ElseCallback&& /* elseCallback */) {
     return thenCallback();
   }
 };
 
-template<>
+template <>
 struct _if_constexpr<false> final {
-  template<class ThenCallback, class ElseCallback, std::enable_if_t<function_takes_identity_argument<ElseCallback>::value, void*> = nullptr>
-  static decltype(auto) call(ThenCallback&& /* thenCallback */, ElseCallback&& elseCallback) {
-    // The _identity instance passed in can be used to delay evaluation of an expression,
-    // because the compiler can't know that it's just the identity we're passing in.
+  template <
+      class ThenCallback,
+      class ElseCallback,
+      std::enable_if_t<
+          function_takes_identity_argument<ElseCallback>::value,
+          void*> = nullptr>
+  static decltype(auto) call(
+      ThenCallback&& /* thenCallback */,
+      ElseCallback&& elseCallback) {
+    // The _identity instance passed in can be used to delay evaluation of an
+    // expression, because the compiler can't know that it's just the identity
+    // we're passing in.
     return elseCallback(_identity());
   }
 
-  template<class ThenCallback, class ElseCallback, std::enable_if_t<!function_takes_identity_argument<ElseCallback>::value, void*> = nullptr>
-  static decltype(auto) call(ThenCallback&& /* thenCallback */, ElseCallback&& elseCallback) {
+  template <
+      class ThenCallback,
+      class ElseCallback,
+      std::enable_if_t<
+          !function_takes_identity_argument<ElseCallback>::value,
+          void*> = nullptr>
+  static decltype(auto) call(
+      ThenCallback&& /* thenCallback */,
+      ElseCallback&& elseCallback) {
     return elseCallback();
   }
 };
@@ -249,38 +300,47 @@ struct _if_constexpr<false> final {
  *   template <class T>
  *   int func(T t) {
  *     return if_constexpr<std::is_same<T, MyClass1>::value>(
- *       [&](auto _) { return _(t).value; }, // this code is invalid for T == MyClass2, so a regular non-constexpr if statement wouldn't compile
- *       [&](auto _) { return _(t).val; }    // this code is invalid for T == MyClass1
+ *       [&](auto _) { return _(t).value; }, // this code is invalid for T ==
+ * MyClass2, so a regular non-constexpr if statement wouldn't compile
+ *       [&](auto _) { return _(t).val; }    // this code is invalid for T ==
+ * MyClass1
  *     );
  *   }
  *
- * Note: The _ argument passed in Example 3 is the identity function, i.e. it does nothing.
- *       It is used to force the compiler to delay type checking, because the compiler
- *       doesn't know what kind of _ is passed in. Without it, the compiler would fail
- *       when you try to access t.value but the member doesn't exist.
+ * Note: The _ argument passed in Example 3 is the identity function, i.e. it
+ * does nothing. It is used to force the compiler to delay type checking,
+ * because the compiler doesn't know what kind of _ is passed in. Without it,
+ * the compiler would fail when you try to access t.value but the member doesn't
+ * exist.
  *
- * Note: In Example 3, both branches return int, so func() returns int. This is not necessary.
- *       If func() had a return type of "auto", then both branches could return different
- *       types, say func<MyClass1>() could return int and func<MyClass2>() could return string.
+ * Note: In Example 3, both branches return int, so func() returns int. This is
+ * not necessary. If func() had a return type of "auto", then both branches
+ * could return different types, say func<MyClass1>() could return int and
+ * func<MyClass2>() could return string.
  *
- * Note: if_constexpr<cond, t, f> is *eager* w.r.t. template expansion - meaning this
- *       polyfill does not behave like a true "if statement at compilation time".
- *       The `_` trick above only defers typechecking, which happens after templates
- *       have been expanded. (Of course this is all that's necessary for many use cases).
+ * Note: if_constexpr<cond, t, f> is *eager* w.r.t. template expansion - meaning
+ * this polyfill does not behave like a true "if statement at compilation time".
+ *       The `_` trick above only defers typechecking, which happens after
+ * templates have been expanded. (Of course this is all that's necessary for
+ * many use cases).
  */
-template<bool Condition, class ThenCallback, class ElseCallback>
-decltype(auto) if_constexpr(ThenCallback&& thenCallback, ElseCallback&& elseCallback) {
+template <bool Condition, class ThenCallback, class ElseCallback>
+decltype(auto) if_constexpr(
+    ThenCallback&& thenCallback,
+    ElseCallback&& elseCallback) {
 #if defined(__cpp_if_constexpr)
-  // If we have C++17, just use it's "if constexpr" feature instead of wrapping it.
-  // This will give us better error messages.
-  if constexpr(Condition) {
-    if constexpr (detail::function_takes_identity_argument<ThenCallback>::value) {
+  // If we have C++17, just use it's "if constexpr" feature instead of wrapping
+  // it. This will give us better error messages.
+  if constexpr (Condition) {
+    if constexpr (detail::function_takes_identity_argument<
+                      ThenCallback>::value) {
       return ::std::forward<ThenCallback>(thenCallback)(detail::_identity());
     } else {
       return ::std::forward<ThenCallback>(thenCallback)();
     }
   } else {
-    if constexpr (detail::function_takes_identity_argument<ElseCallback>::value) {
+    if constexpr (detail::function_takes_identity_argument<
+                      ElseCallback>::value) {
       return ::std::forward<ElseCallback>(elseCallback)(detail::_identity());
     } else {
       return ::std::forward<ElseCallback>(elseCallback)();
@@ -288,18 +348,20 @@ decltype(auto) if_constexpr(ThenCallback&& thenCallback, ElseCallback&& elseCall
   }
 #else
   // C++14 implementation of if constexpr
-  return detail::_if_constexpr<Condition>::call(::std::forward<ThenCallback>(thenCallback),
-                                                 ::std::forward<ElseCallback>(elseCallback));
+  return detail::_if_constexpr<Condition>::call(
+      ::std::forward<ThenCallback>(thenCallback),
+      ::std::forward<ElseCallback>(elseCallback));
 #endif
 }
 
-template<bool Condition, class ThenCallback>
+template <bool Condition, class ThenCallback>
 decltype(auto) if_constexpr(ThenCallback&& thenCallback) {
 #if defined(__cpp_if_constexpr)
-  // If we have C++17, just use it's "if constexpr" feature instead of wrapping it.
-  // This will give us better error messages.
-  if constexpr(Condition) {
-    if constexpr (detail::function_takes_identity_argument<ThenCallback>::value) {
+  // If we have C++17, just use it's "if constexpr" feature instead of wrapping
+  // it. This will give us better error messages.
+  if constexpr (Condition) {
+    if constexpr (detail::function_takes_identity_argument<
+                      ThenCallback>::value) {
       return ::std::forward<ThenCallback>(thenCallback)(detail::_identity());
     } else {
       return ::std::forward<ThenCallback>(thenCallback)();
@@ -307,45 +369,53 @@ decltype(auto) if_constexpr(ThenCallback&& thenCallback) {
   }
 #else
   // C++14 implementation of if constexpr
-  return if_constexpr<Condition>(::std::forward<ThenCallback>(thenCallback), [] (auto) {});
+  return if_constexpr<Condition>(
+      ::std::forward<ThenCallback>(thenCallback), [](auto) {});
 #endif
 }
 
-
-
-// GCC 4.8 doesn't define std::to_string, even though that's in C++11. Let's define it.
+// GCC 4.8 doesn't define std::to_string, even though that's in C++11. Let's
+// define it.
 namespace detail {
 class DummyClassForToString final {};
-}}}
+} // namespace detail
+} // namespace guts
+} // namespace c10
 namespace std {
-// We use SFINAE to detect if std::to_string exists for a type, but that only works
-// if the function name is defined. So let's define a std::to_string for a dummy type.
-// If you're getting an error here saying that this overload doesn't match your
-// std::to_string() call, then you're calling std::to_string() but should be calling
-// c10::guts::to_string().
-inline std::string to_string(c10::guts::detail::DummyClassForToString) { return ""; }
-
+// We use SFINAE to detect if std::to_string exists for a type, but that only
+// works if the function name is defined. So let's define a std::to_string for a
+// dummy type. If you're getting an error here saying that this overload doesn't
+// match your std::to_string() call, then you're calling std::to_string() but
+// should be calling c10::guts::to_string().
+inline std::string to_string(c10::guts::detail::DummyClassForToString) {
+  return "";
 }
-namespace c10 { namespace guts { namespace detail {
 
-template<class T, class Enable = void>
+} // namespace std
+namespace c10 {
+namespace guts {
+namespace detail {
+
+template <class T, class Enable = void>
 struct to_string_ final {
-    static std::string call(T value) {
-        std::ostringstream str;
-        str << value;
-        return str.str();
-    }
+  static std::string call(T value) {
+    std::ostringstream str;
+    str << value;
+    return str.str();
+  }
 };
 // If a std::to_string exists, use that instead
-template<class T>
-struct to_string_<T, void_t<decltype(std::to_string(std::declval<T>()))>> final {
-    static std::string call(T value) {
-        return std::to_string(value);
-    }
+template <class T>
+struct to_string_<T, void_t<decltype(std::to_string(std::declval<T>()))>>
+    final {
+  static std::string call(T value) {
+    return std::to_string(value);
+  }
 };
-}
-template<class T> inline std::string to_string(T value) {
-    return detail::to_string_<T>::call(value);
+} // namespace detail
+template <class T>
+inline std::string to_string(T value) {
+  return detail::to_string_<T>::call(value);
 }
 
 template <class T>
@@ -358,6 +428,7 @@ constexpr const T& max(const T& a, const T& b) {
   return (a < b) ? b : a;
 }
 
-}}
+} // namespace guts
+} // namespace c10
 
 #endif // C10_UTIL_CPP17_H_
diff --git a/c10/util/Deprecated.h b/c10/util/Deprecated.h
index 545a9b1ab90..88440a0242e 100644
--- a/c10/util/Deprecated.h
+++ b/c10/util/Deprecated.h
@@ -16,26 +16,25 @@
 //    };
 
 // NB: __cplusplus doesn't work for MSVC, so for now MSVC always uses
-// the "__declspec(deprecated)" implementation and not the C++14 "[[deprecated]]"
-// attribute. We tried enabling "[[deprecated]]" for C++14 on MSVC, but
-// ran into issues with some older MSVC versions.
+// the "__declspec(deprecated)" implementation and not the C++14
+// "[[deprecated]]" attribute. We tried enabling "[[deprecated]]" for C++14 on
+// MSVC, but ran into issues with some older MSVC versions.
 #if (defined(__cplusplus) && __cplusplus >= 201402L)
-# define C10_DEPRECATED [[deprecated]]
-# define C10_DEPRECATED_MESSAGE(message) [[deprecated(message)]]
+#define C10_DEPRECATED [[deprecated]]
+#define C10_DEPRECATED_MESSAGE(message) [[deprecated(message)]]
 #elif defined(__GNUC__)
-# define C10_DEPRECATED __attribute__((deprecated))
+#define C10_DEPRECATED __attribute__((deprecated))
 // TODO Is there some way to implement this?
-# define C10_DEPRECATED_MESSAGE(message) __attribute__((deprecated))
+#define C10_DEPRECATED_MESSAGE(message) __attribute__((deprecated))
 
 #elif defined(_MSC_VER)
-# define C10_DEPRECATED __declspec(deprecated)
-# define C10_DEPRECATED_MESSAGE(message) __declspec(deprecated(message))
+#define C10_DEPRECATED __declspec(deprecated)
+#define C10_DEPRECATED_MESSAGE(message) __declspec(deprecated(message))
 #else
-# warning "You need to implement C10_DEPRECATED for this compiler"
-# define C10_DEPRECATED
+#warning "You need to implement C10_DEPRECATED for this compiler"
+#define C10_DEPRECATED
 #endif
 
-
 // Sample usage:
 //
 //    C10_DEFINE_DEPRECATED_USING(BadType, int)
@@ -48,7 +47,8 @@
 // many compilers.
 #if defined(__has_cpp_attribute)
 #if __has_cpp_attribute(deprecated) && !defined(__CUDACC__)
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName [[deprecated]] = TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName [[deprecated]] = TypeThingy;
 #endif
 #endif
 
@@ -61,18 +61,21 @@
 //
 // So we just turn the macro off in this case.
 #if defined(C10_DEFINE_DEPRECATED_USING)
-# undef C10_DEFINE_DEPRECATED_USING
+#undef C10_DEFINE_DEPRECATED_USING
 #endif
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName = TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName = TypeThingy;
 #else
 // [[deprecated]] does work in windows without nvcc, though msc doesn't support
-// `__has_cpp_attribute` when c++14 is supported, otherwise __declspec(deprecated)
-// is used as the alternative.
+// `__has_cpp_attribute` when c++14 is supported, otherwise
+// __declspec(deprecated) is used as the alternative.
 #ifndef C10_DEFINE_DEPRECATED_USING
 #if defined(_MSVC_LANG) && _MSVC_LANG >= 201402L
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName [[deprecated]] = TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName [[deprecated]] = TypeThingy;
 #else
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName = __declspec(deprecated) TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName = __declspec(deprecated) TypeThingy;
 #endif
 #endif
 #endif
@@ -84,14 +87,16 @@
 // attribute when not cuda, and when using a GCC compiler that doesn't support
 // the c++14 syntax we checked for above (available in __GNUC__ >= 5)
 #if !defined(__CUDACC__)
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName __attribute__((deprecated)) = TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName __attribute__((deprecated)) = TypeThingy;
 #else
 // using cuda + gcc < 5, neither deprecated syntax is available so turning off.
-# define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) using TypeName = TypeThingy;
+#define C10_DEFINE_DEPRECATED_USING(TypeName, TypeThingy) \
+  using TypeName = TypeThingy;
 #endif
 #endif
 
-#if ! defined(C10_DEFINE_DEPRECATED_USING)
-# warning "You need to implement C10_DEFINE_DEPRECATED_USING for this compiler"
-# define C10_DEFINE_DEPRECATED_USING
+#if !defined(C10_DEFINE_DEPRECATED_USING)
+#warning "You need to implement C10_DEFINE_DEPRECATED_USING for this compiler"
+#define C10_DEFINE_DEPRECATED_USING
 #endif
diff --git a/c10/util/Flags.h b/c10/util/Flags.h
index b4352510c99..d3f750016d7 100644
--- a/c10/util/Flags.h
+++ b/c10/util/Flags.h
@@ -115,7 +115,7 @@ namespace gflags = google;
 // flags defined in C10. This is done via a global reference, so the flag
 // itself is not duplicated - under the hood it is the same global gflags flag.
 #define C10_GFLAGS_DEF_WRAPPER(type, real_type, name, default_value, help_str) \
-  DEFINE_##type(name, default_value, help_str);                                \
+  DEFINE_##type(name, default_value, help_str);
 
 #define C10_DEFINE_int(name, default_value, help_str) \
   C10_GFLAGS_DEF_WRAPPER(int32, gflags::int32, name, default_value, help_str)
@@ -131,8 +131,7 @@ namespace gflags = google;
   C10_GFLAGS_DEF_WRAPPER(string, ::fLS::clstring, name, default_value, help_str)
 
 // DECLARE_typed_var should be used in header files and in the global namespace.
-#define C10_GFLAGS_DECLARE_WRAPPER(type, real_type, name) \
-  DECLARE_##type(name);                                   \
+#define C10_GFLAGS_DECLARE_WRAPPER(type, real_type, name) DECLARE_##type(name);
 
 #define C10_DECLARE_int(name) \
   C10_GFLAGS_DECLARE_WRAPPER(int32, gflags::int32, name)
diff --git a/c10/util/FunctionRef.h b/c10/util/FunctionRef.h
index 04b0ce09b65..929fd6552c2 100644
--- a/c10/util/FunctionRef.h
+++ b/c10/util/FunctionRef.h
@@ -30,40 +30,43 @@ namespace c10 {
 ///
 /// This class does not own the callable, so it is not in general safe to store
 /// a function_ref.
-template<typename Fn> class function_ref;
+template <typename Fn>
+class function_ref;
 
-template<typename Ret, typename ...Params>
+template <typename Ret, typename... Params>
 class function_ref<Ret(Params...)> {
-Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
-intptr_t callable;
+  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
+  intptr_t callable;
 
-template<typename Callable>
-static Ret callback_fn(intptr_t callable, Params ...params) {
+  template <typename Callable>
+  static Ret callback_fn(intptr_t callable, Params... params) {
     return (*reinterpret_cast<Callable*>(callable))(
         std::forward<Params>(params)...);
-}
+  }
 
-public:
-function_ref() = default;
-function_ref(std::nullptr_t) {}
+ public:
+  function_ref() = default;
+  function_ref(std::nullptr_t) {}
 
-template <typename Callable>
-function_ref(Callable &&callable,
-            typename std::enable_if<
-                !std::is_same<typename std::remove_reference<Callable>::type,
-                                function_ref>::value>::type * = nullptr,
-            typename std::enable_if<
-                 std::is_convertible<
-                   typename std::result_of<Callable&&(Params&&...)>::type,
-                   Ret>::value>::type * = nullptr)
-    : callback(callback_fn<typename std::remove_reference<Callable>::type>),
+  template <typename Callable>
+  function_ref(
+      Callable&& callable,
+      typename std::enable_if<!std::is_same<
+          typename std::remove_reference<Callable>::type,
+          function_ref>::value>::type* = nullptr,
+      typename std::enable_if<std::is_convertible<
+          typename std::result_of<Callable && (Params && ...)>::type,
+          Ret>::value>::type* = nullptr)
+      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
         callable(reinterpret_cast<intptr_t>(&callable)) {}
 
-Ret operator()(Params ...params) const {
+  Ret operator()(Params... params) const {
     return callback(callable, std::forward<Params>(params)...);
-}
+  }
 
-operator bool() const { return callback; }
+  operator bool() const {
+    return callback;
+  }
 };
 
-}
+} // namespace c10
diff --git a/c10/util/Half-inl.h b/c10/util/Half-inl.h
index 2a39e007b33..554787474e9 100644
--- a/c10/util/Half-inl.h
+++ b/c10/util/Half-inl.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <c10/macros/Macros.h>
 #include <cstring>
 #include <limits>
-#include <c10/macros/Macros.h>
 
 #ifdef __CUDACC__
 #include <cuda_fp16.h>
@@ -48,7 +48,7 @@ inline C10_HOST_DEVICE Half::operator __half() const {
 #if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 350)) || \
     (defined(__clang__) && defined(__CUDA__))
 inline __device__ Half __ldg(const Half* ptr) {
-    return __ldg(reinterpret_cast<const __half*>(ptr));
+  return __ldg(reinterpret_cast<const __half*>(ptr));
 }
 #endif
 
@@ -66,12 +66,14 @@ inline C10_HOST_DEVICE Half operator*(const Half& a, const Half& b) {
   return static_cast<float>(a) * static_cast<float>(b);
 }
 
-inline C10_HOST_DEVICE Half operator/(const Half& a, const Half& b) __ubsan_ignore_float_divide_by_zero__ {
+inline C10_HOST_DEVICE Half operator/(const Half& a, const Half& b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return static_cast<float>(a) / static_cast<float>(b);
 }
 
 inline C10_HOST_DEVICE Half operator-(const Half& a) {
-#if (defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 530) || defined(__HIP_DEVICE_COMPILE__)
+#if (defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 530) || \
+    defined(__HIP_DEVICE_COMPILE__)
   return __hneg(a);
 #else
   return -static_cast<float>(a);
@@ -109,7 +111,8 @@ inline C10_HOST_DEVICE float operator-(Half a, float b) {
 inline C10_HOST_DEVICE float operator*(Half a, float b) {
   return static_cast<float>(a) * b;
 }
-inline C10_HOST_DEVICE float operator/(Half a, float b) __ubsan_ignore_float_divide_by_zero__  {
+inline C10_HOST_DEVICE float operator/(Half a, float b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return static_cast<float>(a) / b;
 }
 
@@ -122,7 +125,8 @@ inline C10_HOST_DEVICE float operator-(float a, Half b) {
 inline C10_HOST_DEVICE float operator*(float a, Half b) {
   return a * static_cast<float>(b);
 }
-inline C10_HOST_DEVICE float operator/(float a, Half b) __ubsan_ignore_float_divide_by_zero__  {
+inline C10_HOST_DEVICE float operator/(float a, Half b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return a / static_cast<float>(b);
 }
 
@@ -150,7 +154,8 @@ inline C10_HOST_DEVICE double operator-(Half a, double b) {
 inline C10_HOST_DEVICE double operator*(Half a, double b) {
   return static_cast<double>(a) * b;
 }
-inline C10_HOST_DEVICE double operator/(Half a, double b) __ubsan_ignore_float_divide_by_zero__  {
+inline C10_HOST_DEVICE double operator/(Half a, double b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return static_cast<double>(a) / b;
 }
 
@@ -163,7 +168,8 @@ inline C10_HOST_DEVICE double operator-(double a, Half b) {
 inline C10_HOST_DEVICE double operator*(double a, Half b) {
   return a * static_cast<double>(b);
 }
-inline C10_HOST_DEVICE double operator/(double a, Half b) __ubsan_ignore_float_divide_by_zero__  {
+inline C10_HOST_DEVICE double operator/(double a, Half b)
+    __ubsan_ignore_float_divide_by_zero__ {
   return a / static_cast<double>(b);
 }
 
diff --git a/c10/util/Half.h b/c10/util/Half.h
index 86c7d0a7d47..c22db1fab24 100644
--- a/c10/util/Half.h
+++ b/c10/util/Half.h
@@ -26,8 +26,8 @@
 #endif
 
 #include <complex>
-#include <cstring>
 #include <cstdint>
+#include <cstring>
 #include <iosfwd>
 #include <limits>
 #include <sstream>
@@ -54,285 +54,313 @@ namespace c10 {
 
 namespace detail {
 
-  C10_DEVICE_HOST_FUNCTION inline float fp32_from_bits(uint32_t w) {
-  #if defined(__OPENCL_VERSION__)
-    return as_float(w);
-  #elif defined(__CUDA_ARCH__)
-    return __uint_as_float((unsigned int)w);
-  #elif defined(__INTEL_COMPILER)
-    return _castu32_f32(w);
-  #else
-    union {
-      uint32_t as_bits;
-      float as_value;
-    } fp32 = {w};
-    return fp32.as_value;
-  #endif
-  }
-
-  C10_DEVICE_HOST_FUNCTION inline uint32_t fp32_to_bits(float f) {
-  #if defined(__OPENCL_VERSION__)
-    return as_uint(f);
-  #elif defined(__CUDA_ARCH__)
-    return (uint32_t)__float_as_uint(f);
-  #elif defined(__INTEL_COMPILER)
-    return _castf32_u32(f);
-  #else
-    union {
-      float as_value;
-      uint32_t as_bits;
-    } fp32 = {f};
-    return fp32.as_bits;
-  #endif
-  }
-
-  /*
-   * Convert a 16-bit floating-point number in IEEE half-precision format, in bit representation, to
-   * a 32-bit floating-point number in IEEE single-precision format, in bit representation.
-   *
-   * @note The implementation doesn't use any floating-point operations.
-   */
-  inline uint32_t fp16_ieee_to_fp32_bits(uint16_t h) {
-          /*
-           * Extend the half-precision floating-point number to 32 bits and shift to the upper part of the 32-bit word:
-           *      +---+-----+------------+-------------------+
-           *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-           *      +---+-----+------------+-------------------+
-           * Bits  31  26-30    16-25            0-15
-           *
-           * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0 - zero bits.
-           */
-          const uint32_t w = (uint32_t) h << 16;
-          /*
-           * Extract the sign of the input number into the high bit of the 32-bit word:
-           *
-           *      +---+----------------------------------+
-           *      | S |0000000 00000000 00000000 00000000|
-           *      +---+----------------------------------+
-           * Bits  31                 0-31
-           */
-          const uint32_t sign = w & UINT32_C(0x80000000);
-          /*
-           * Extract mantissa and biased exponent of the input number into the bits 0-30 of the 32-bit word:
-           *
-           *      +---+-----+------------+-------------------+
-           *      | 0 |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-           *      +---+-----+------------+-------------------+
-           * Bits  30  27-31     17-26            0-16
-           */
-          const uint32_t nonsign = w & UINT32_C(0x7FFFFFFF);
-          /*
-           * Renorm shift is the number of bits to shift mantissa left to make the half-precision number normalized.
-           * If the initial number is normalized, some of its high 6 bits (sign == 0 and 5-bit exponent) equals one.
-           * In this case renorm_shift == 0. If the number is denormalize, renorm_shift > 0. Note that if we shift
-           * denormalized nonsign by renorm_shift, the unit bit of mantissa will shift into exponent, turning the
-           * biased exponent into 1, and making mantissa normalized (i.e. without leading 1).
-           */
-#ifdef _MSC_VER
-        unsigned long nonsign_bsr;
-        _BitScanReverse(&nonsign_bsr, (unsigned long)nonsign);
-        uint32_t renorm_shift = (uint32_t)nonsign_bsr ^ 31;
+C10_DEVICE_HOST_FUNCTION inline float fp32_from_bits(uint32_t w) {
+#if defined(__OPENCL_VERSION__)
+  return as_float(w);
+#elif defined(__CUDA_ARCH__)
+  return __uint_as_float((unsigned int)w);
+#elif defined(__INTEL_COMPILER)
+  return _castu32_f32(w);
 #else
-        uint32_t renorm_shift = __builtin_clz(nonsign);
+  union {
+    uint32_t as_bits;
+    float as_value;
+  } fp32 = {w};
+  return fp32.as_value;
 #endif
-        renorm_shift = renorm_shift > 5 ? renorm_shift - 5 : 0;
-        /*
-         * Iff half-precision number has exponent of 15, the addition overflows
-         * it into bit 31, and the subsequent shift turns the high 9 bits
-         * into 1. Thus inf_nan_mask == 0x7F800000 if the half-precision number
-         * had exponent of 15 (i.e. was NaN or infinity) 0x00000000 otherwise
-         */
-        const int32_t inf_nan_mask =
-            ((int32_t)(nonsign + 0x04000000) >> 8) & INT32_C(0x7F800000);
-        /*
-         * Iff nonsign is 0, it overflows into 0xFFFFFFFF, turning bit 31
-         * into 1. Otherwise, bit 31 remains 0. The signed shift right by 31
-         * broadcasts bit 31 into all bits of the zero_mask. Thus zero_mask ==
-         * 0xFFFFFFFF if the half-precision number was zero (+0.0h or -0.0h)
-         * 0x00000000 otherwise
-         */
-        const int32_t zero_mask = (int32_t)(nonsign - 1) >> 31;
-        /*
-         * 1. Shift nonsign left by renorm_shift to normalize it (if the input
-         * was denormal)
-         * 2. Shift nonsign right by 3 so the exponent (5 bits originally)
-         * becomes an 8-bit field and 10-bit mantissa shifts into the 10 high
-         * bits of the 23-bit mantissa of IEEE single-precision number.
-         * 3. Add 0x70 to the exponent (starting at bit 23) to compensate the
-         * different in exponent bias (0x7F for single-precision number less 0xF
-         * for half-precision number).
-         * 4. Subtract renorm_shift from the exponent (starting at bit 23) to
-         * account for renormalization. As renorm_shift is less than 0x70, this
-         * can be combined with step 3.
-         * 5. Binary OR with inf_nan_mask to turn the exponent into 0xFF if the
-         * input was NaN or infinity.
-         * 6. Binary ANDNOT with zero_mask to turn the mantissa and exponent
-         * into zero if the input was zero.
-         * 7. Combine with the sign of the input number.
-         */
-        return sign |
-            ((((nonsign << renorm_shift >> 3) + ((0x70 - renorm_shift) << 23)) |
-              inf_nan_mask) &
-             ~zero_mask);
-  }
+}
+
+C10_DEVICE_HOST_FUNCTION inline uint32_t fp32_to_bits(float f) {
+#if defined(__OPENCL_VERSION__)
+  return as_uint(f);
+#elif defined(__CUDA_ARCH__)
+  return (uint32_t)__float_as_uint(f);
+#elif defined(__INTEL_COMPILER)
+  return _castf32_u32(f);
+#else
+  union {
+    float as_value;
+    uint32_t as_bits;
+  } fp32 = {f};
+  return fp32.as_bits;
+#endif
+}
+
+/*
+ * Convert a 16-bit floating-point number in IEEE half-precision format, in bit
+ * representation, to a 32-bit floating-point number in IEEE single-precision
+ * format, in bit representation.
+ *
+ * @note The implementation doesn't use any floating-point operations.
+ */
+inline uint32_t fp16_ieee_to_fp32_bits(uint16_t h) {
+  /*
+   * Extend the half-precision floating-point number to 32 bits and shift to the
+   * upper part of the 32-bit word:
+   *      +---+-----+------------+-------------------+
+   *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
+   *      +---+-----+------------+-------------------+
+   * Bits  31  26-30    16-25            0-15
+   *
+   * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0
+   * - zero bits.
+   */
+  const uint32_t w = (uint32_t)h << 16;
+  /*
+   * Extract the sign of the input number into the high bit of the 32-bit word:
+   *
+   *      +---+----------------------------------+
+   *      | S |0000000 00000000 00000000 00000000|
+   *      +---+----------------------------------+
+   * Bits  31                 0-31
+   */
+  const uint32_t sign = w & UINT32_C(0x80000000);
+  /*
+   * Extract mantissa and biased exponent of the input number into the bits 0-30
+   * of the 32-bit word:
+   *
+   *      +---+-----+------------+-------------------+
+   *      | 0 |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
+   *      +---+-----+------------+-------------------+
+   * Bits  30  27-31     17-26            0-16
+   */
+  const uint32_t nonsign = w & UINT32_C(0x7FFFFFFF);
+  /*
+   * Renorm shift is the number of bits to shift mantissa left to make the
+   * half-precision number normalized. If the initial number is normalized, some
+   * of its high 6 bits (sign == 0 and 5-bit exponent) equals one. In this case
+   * renorm_shift == 0. If the number is denormalize, renorm_shift > 0. Note
+   * that if we shift denormalized nonsign by renorm_shift, the unit bit of
+   * mantissa will shift into exponent, turning the biased exponent into 1, and
+   * making mantissa normalized (i.e. without leading 1).
+   */
+#ifdef _MSC_VER
+  unsigned long nonsign_bsr;
+  _BitScanReverse(&nonsign_bsr, (unsigned long)nonsign);
+  uint32_t renorm_shift = (uint32_t)nonsign_bsr ^ 31;
+#else
+  uint32_t renorm_shift = __builtin_clz(nonsign);
+#endif
+  renorm_shift = renorm_shift > 5 ? renorm_shift - 5 : 0;
+  /*
+   * Iff half-precision number has exponent of 15, the addition overflows
+   * it into bit 31, and the subsequent shift turns the high 9 bits
+   * into 1. Thus inf_nan_mask == 0x7F800000 if the half-precision number
+   * had exponent of 15 (i.e. was NaN or infinity) 0x00000000 otherwise
+   */
+  const int32_t inf_nan_mask =
+      ((int32_t)(nonsign + 0x04000000) >> 8) & INT32_C(0x7F800000);
+  /*
+   * Iff nonsign is 0, it overflows into 0xFFFFFFFF, turning bit 31
+   * into 1. Otherwise, bit 31 remains 0. The signed shift right by 31
+   * broadcasts bit 31 into all bits of the zero_mask. Thus zero_mask ==
+   * 0xFFFFFFFF if the half-precision number was zero (+0.0h or -0.0h)
+   * 0x00000000 otherwise
+   */
+  const int32_t zero_mask = (int32_t)(nonsign - 1) >> 31;
+  /*
+   * 1. Shift nonsign left by renorm_shift to normalize it (if the input
+   * was denormal)
+   * 2. Shift nonsign right by 3 so the exponent (5 bits originally)
+   * becomes an 8-bit field and 10-bit mantissa shifts into the 10 high
+   * bits of the 23-bit mantissa of IEEE single-precision number.
+   * 3. Add 0x70 to the exponent (starting at bit 23) to compensate the
+   * different in exponent bias (0x7F for single-precision number less 0xF
+   * for half-precision number).
+   * 4. Subtract renorm_shift from the exponent (starting at bit 23) to
+   * account for renormalization. As renorm_shift is less than 0x70, this
+   * can be combined with step 3.
+   * 5. Binary OR with inf_nan_mask to turn the exponent into 0xFF if the
+   * input was NaN or infinity.
+   * 6. Binary ANDNOT with zero_mask to turn the mantissa and exponent
+   * into zero if the input was zero.
+   * 7. Combine with the sign of the input number.
+   */
+  return sign |
+      ((((nonsign << renorm_shift >> 3) + ((0x70 - renorm_shift) << 23)) |
+        inf_nan_mask) &
+       ~zero_mask);
+}
+
+/*
+ * Convert a 16-bit floating-point number in IEEE half-precision format, in bit
+ * representation, to a 32-bit floating-point number in IEEE single-precision
+ * format.
+ *
+ * @note The implementation relies on IEEE-like (no assumption about rounding
+ * mode and no operations on denormals) floating-point operations and bitcasts
+ * between integer and floating-point variables.
+ */
+inline float fp16_ieee_to_fp32_value(uint16_t h) {
+  /*
+   * Extend the half-precision floating-point number to 32 bits and shift to the
+   * upper part of the 32-bit word:
+   *      +---+-----+------------+-------------------+
+   *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
+   *      +---+-----+------------+-------------------+
+   * Bits  31  26-30    16-25            0-15
+   *
+   * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0
+   * - zero bits.
+   */
+  const uint32_t w = (uint32_t)h << 16;
+  /*
+   * Extract the sign of the input number into the high bit of the 32-bit word:
+   *
+   *      +---+----------------------------------+
+   *      | S |0000000 00000000 00000000 00000000|
+   *      +---+----------------------------------+
+   * Bits  31                 0-31
+   */
+  const uint32_t sign = w & UINT32_C(0x80000000);
+  /*
+   * Extract mantissa and biased exponent of the input number into the high bits
+   * of the 32-bit word:
+   *
+   *      +-----+------------+---------------------+
+   *      |EEEEE|MM MMMM MMMM|0 0000 0000 0000 0000|
+   *      +-----+------------+---------------------+
+   * Bits  27-31    17-26            0-16
+   */
+  const uint32_t two_w = w + w;
 
   /*
-   * Convert a 16-bit floating-point number in IEEE half-precision format, in bit representation, to
-   * a 32-bit floating-point number in IEEE single-precision format.
+   * Shift mantissa and exponent into bits 23-28 and bits 13-22 so they become
+   * mantissa and exponent of a single-precision floating-point number:
    *
-   * @note The implementation relies on IEEE-like (no assumption about rounding mode and no operations on denormals)
-   * floating-point operations and bitcasts between integer and floating-point variables.
+   *       S|Exponent |          Mantissa
+   *      +-+---+-----+------------+----------------+
+   *      |0|000|EEEEE|MM MMMM MMMM|0 0000 0000 0000|
+   *      +-+---+-----+------------+----------------+
+   * Bits   | 23-31   |           0-22
+   *
+   * Next, there are some adjustments to the exponent:
+   * - The exponent needs to be corrected by the difference in exponent bias
+   * between single-precision and half-precision formats (0x7F - 0xF = 0x70)
+   * - Inf and NaN values in the inputs should become Inf and NaN values after
+   * conversion to the single-precision number. Therefore, if the biased
+   * exponent of the half-precision input was 0x1F (max possible value), the
+   * biased exponent of the single-precision output must be 0xFF (max possible
+   * value). We do this correction in two steps:
+   *   - First, we adjust the exponent by (0xFF - 0x1F) = 0xE0 (see exp_offset
+   * below) rather than by 0x70 suggested by the difference in the exponent bias
+   * (see above).
+   *   - Then we multiply the single-precision result of exponent adjustment by
+   * 2**(-112) to reverse the effect of exponent adjustment by 0xE0 less the
+   * necessary exponent adjustment by 0x70 due to difference in exponent bias.
+   *     The floating-point multiplication hardware would ensure than Inf and
+   * NaN would retain their value on at least partially IEEE754-compliant
+   * implementations.
+   *
+   * Note that the above operations do not handle denormal inputs (where biased
+   * exponent == 0). However, they also do not operate on denormal inputs, and
+   * do not produce denormal results.
    */
-  inline float fp16_ieee_to_fp32_value(uint16_t h) {
-          /*
-           * Extend the half-precision floating-point number to 32 bits and shift to the upper part of the 32-bit word:
-           *      +---+-----+------------+-------------------+
-           *      | S |EEEEE|MM MMMM MMMM|0000 0000 0000 0000|
-           *      +---+-----+------------+-------------------+
-           * Bits  31  26-30    16-25            0-15
-           *
-           * S - sign bit, E - bits of the biased exponent, M - bits of the mantissa, 0 - zero bits.
-           */
-          const uint32_t w = (uint32_t) h << 16;
-          /*
-           * Extract the sign of the input number into the high bit of the 32-bit word:
-           *
-           *      +---+----------------------------------+
-           *      | S |0000000 00000000 00000000 00000000|
-           *      +---+----------------------------------+
-           * Bits  31                 0-31
-           */
-          const uint32_t sign = w & UINT32_C(0x80000000);
-          /*
-           * Extract mantissa and biased exponent of the input number into the high bits of the 32-bit word:
-           *
-           *      +-----+------------+---------------------+
-           *      |EEEEE|MM MMMM MMMM|0 0000 0000 0000 0000|
-           *      +-----+------------+---------------------+
-           * Bits  27-31    17-26            0-16
-           */
-          const uint32_t two_w = w + w;
-
-          /*
-           * Shift mantissa and exponent into bits 23-28 and bits 13-22 so they become mantissa and exponent
-           * of a single-precision floating-point number:
-           *
-           *       S|Exponent |          Mantissa
-           *      +-+---+-----+------------+----------------+
-           *      |0|000|EEEEE|MM MMMM MMMM|0 0000 0000 0000|
-           *      +-+---+-----+------------+----------------+
-           * Bits   | 23-31   |           0-22
-           *
-           * Next, there are some adjustments to the exponent:
-           * - The exponent needs to be corrected by the difference in exponent bias between single-precision and half-precision
-           *   formats (0x7F - 0xF = 0x70)
-           * - Inf and NaN values in the inputs should become Inf and NaN values after conversion to the single-precision number.
-           *   Therefore, if the biased exponent of the half-precision input was 0x1F (max possible value), the biased exponent
-           *   of the single-precision output must be 0xFF (max possible value). We do this correction in two steps:
-           *   - First, we adjust the exponent by (0xFF - 0x1F) = 0xE0 (see exp_offset below) rather than by 0x70 suggested
-           *     by the difference in the exponent bias (see above).
-           *   - Then we multiply the single-precision result of exponent adjustment by 2**(-112) to reverse the effect of
-           *     exponent adjustment by 0xE0 less the necessary exponent adjustment by 0x70 due to difference in exponent bias.
-           *     The floating-point multiplication hardware would ensure than Inf and NaN would retain their value on at least
-           *     partially IEEE754-compliant implementations.
-           *
-           * Note that the above operations do not handle denormal inputs (where biased exponent == 0). However, they also do not
-           * operate on denormal inputs, and do not produce denormal results.
-           */
-          const uint32_t exp_offset = UINT32_C(0xE0) << 23;
-    // const float exp_scale = 0x1.0p-112f;
-    uint32_t scale_bits = (uint32_t) 15 << 23;
-    float exp_scale_val;
-    std::memcpy(&exp_scale_val, &scale_bits, sizeof(exp_scale_val));
-    const float exp_scale = exp_scale_val;
-    const float normalized_value = fp32_from_bits((two_w >> 4) + exp_offset) * exp_scale;
-
-          /*
-           * Convert denormalized half-precision inputs into single-precision results (always normalized).
-           * Zero inputs are also handled here.
-           *
-           * In a denormalized number the biased exponent is zero, and mantissa has on-zero bits.
-           * First, we shift mantissa into bits 0-9 of the 32-bit word.
-           *
-           *                  zeros           |  mantissa
-           *      +---------------------------+------------+
-           *      |0000 0000 0000 0000 0000 00|MM MMMM MMMM|
-           *      +---------------------------+------------+
-           * Bits             10-31                0-9
-           *
-           * Now, remember that denormalized half-precision numbers are represented as:
-           *    FP16 = mantissa * 2**(-24).
-           * The trick is to construct a normalized single-precision number with the same mantissa and thehalf-precision input
-           * and with an exponent which would scale the corresponding mantissa bits to 2**(-24).
-           * A normalized single-precision floating-point number is represented as:
-           *    FP32 = (1 + mantissa * 2**(-23)) * 2**(exponent - 127)
-           * Therefore, when the biased exponent is 126, a unit change in the mantissa of the input denormalized half-precision
-           * number causes a change of the constructud single-precision number by 2**(-24), i.e. the same amount.
-           *
-           * The last step is to adjust the bias of the constructed single-precision number. When the input half-precision number
-           * is zero, the constructed single-precision number has the value of
-           *    FP32 = 1 * 2**(126 - 127) = 2**(-1) = 0.5
-           * Therefore, we need to subtract 0.5 from the constructed single-precision number to get the numerical equivalent of
-           * the input half-precision number.
-           */
-          const uint32_t magic_mask = UINT32_C(126) << 23;
-          const float magic_bias = 0.5f;
-          const float denormalized_value = fp32_from_bits((two_w >> 17) | magic_mask) - magic_bias;
-
-          /*
-           * - Choose either results of conversion of input as a normalized number, or as a denormalized number, depending on the
-           *   input exponent. The variable two_w contains input exponent in bits 27-31, therefore if its smaller than 2**27, the
-           *   input is either a denormal number, or zero.
-           * - Combine the result of conversion of exponent and mantissa with the sign of the input number.
-           */
-          const uint32_t denormalized_cutoff = UINT32_C(1) << 27;
-          const uint32_t result = sign |
-                  (two_w < denormalized_cutoff ? fp32_to_bits(denormalized_value) : fp32_to_bits(normalized_value));
-          return fp32_from_bits(result);
-  }
+  const uint32_t exp_offset = UINT32_C(0xE0) << 23;
+  // const float exp_scale = 0x1.0p-112f;
+  uint32_t scale_bits = (uint32_t)15 << 23;
+  float exp_scale_val;
+  std::memcpy(&exp_scale_val, &scale_bits, sizeof(exp_scale_val));
+  const float exp_scale = exp_scale_val;
+  const float normalized_value =
+      fp32_from_bits((two_w >> 4) + exp_offset) * exp_scale;
 
   /*
-   * Convert a 32-bit floating-point number in IEEE single-precision format to a 16-bit floating-point number in
-   * IEEE half-precision format, in bit representation.
+   * Convert denormalized half-precision inputs into single-precision results
+   * (always normalized). Zero inputs are also handled here.
    *
-   * @note The implementation relies on IEEE-like (no assumption about rounding mode and no operations on denormals)
-   * floating-point operations and bitcasts between integer and floating-point variables.
+   * In a denormalized number the biased exponent is zero, and mantissa has
+   * on-zero bits. First, we shift mantissa into bits 0-9 of the 32-bit word.
+   *
+   *                  zeros           |  mantissa
+   *      +---------------------------+------------+
+   *      |0000 0000 0000 0000 0000 00|MM MMMM MMMM|
+   *      +---------------------------+------------+
+   * Bits             10-31                0-9
+   *
+   * Now, remember that denormalized half-precision numbers are represented as:
+   *    FP16 = mantissa * 2**(-24).
+   * The trick is to construct a normalized single-precision number with the
+   * same mantissa and thehalf-precision input and with an exponent which would
+   * scale the corresponding mantissa bits to 2**(-24). A normalized
+   * single-precision floating-point number is represented as: FP32 = (1 +
+   * mantissa * 2**(-23)) * 2**(exponent - 127) Therefore, when the biased
+   * exponent is 126, a unit change in the mantissa of the input denormalized
+   * half-precision number causes a change of the constructud single-precision
+   * number by 2**(-24), i.e. the same amount.
+   *
+   * The last step is to adjust the bias of the constructed single-precision
+   * number. When the input half-precision number is zero, the constructed
+   * single-precision number has the value of FP32 = 1 * 2**(126 - 127) =
+   * 2**(-1) = 0.5 Therefore, we need to subtract 0.5 from the constructed
+   * single-precision number to get the numerical equivalent of the input
+   * half-precision number.
    */
-  inline uint16_t fp16_ieee_from_fp32_value(float f) {
-    // const float scale_to_inf = 0x1.0p+112f;
-    // const float scale_to_zero = 0x1.0p-110f;
-    uint32_t scale_to_inf_bits = (uint32_t) 239 << 23;
-    uint32_t scale_to_zero_bits = (uint32_t) 17 << 23;
-    float scale_to_inf_val, scale_to_zero_val;
-    std::memcpy(&scale_to_inf_val, &scale_to_inf_bits, sizeof(scale_to_inf_val));
-    std::memcpy(&scale_to_zero_val, &scale_to_zero_bits, sizeof(scale_to_zero_val));
-    const float scale_to_inf = scale_to_inf_val;
-    const float scale_to_zero = scale_to_zero_val;
+  const uint32_t magic_mask = UINT32_C(126) << 23;
+  const float magic_bias = 0.5f;
+  const float denormalized_value =
+      fp32_from_bits((two_w >> 17) | magic_mask) - magic_bias;
+
+  /*
+   * - Choose either results of conversion of input as a normalized number, or
+   * as a denormalized number, depending on the input exponent. The variable
+   * two_w contains input exponent in bits 27-31, therefore if its smaller than
+   * 2**27, the input is either a denormal number, or zero.
+   * - Combine the result of conversion of exponent and mantissa with the sign
+   * of the input number.
+   */
+  const uint32_t denormalized_cutoff = UINT32_C(1) << 27;
+  const uint32_t result = sign |
+      (two_w < denormalized_cutoff ? fp32_to_bits(denormalized_value)
+                                   : fp32_to_bits(normalized_value));
+  return fp32_from_bits(result);
+}
+
+/*
+ * Convert a 32-bit floating-point number in IEEE single-precision format to a
+ * 16-bit floating-point number in IEEE half-precision format, in bit
+ * representation.
+ *
+ * @note The implementation relies on IEEE-like (no assumption about rounding
+ * mode and no operations on denormals) floating-point operations and bitcasts
+ * between integer and floating-point variables.
+ */
+inline uint16_t fp16_ieee_from_fp32_value(float f) {
+  // const float scale_to_inf = 0x1.0p+112f;
+  // const float scale_to_zero = 0x1.0p-110f;
+  uint32_t scale_to_inf_bits = (uint32_t)239 << 23;
+  uint32_t scale_to_zero_bits = (uint32_t)17 << 23;
+  float scale_to_inf_val, scale_to_zero_val;
+  std::memcpy(&scale_to_inf_val, &scale_to_inf_bits, sizeof(scale_to_inf_val));
+  std::memcpy(
+      &scale_to_zero_val, &scale_to_zero_bits, sizeof(scale_to_zero_val));
+  const float scale_to_inf = scale_to_inf_val;
+  const float scale_to_zero = scale_to_zero_val;
 
 #if defined(_MSC_VER) && _MSC_VER == 1916
-          float base = ((signbit(f) != 0 ? -f : f) * scale_to_inf) * scale_to_zero;
+  float base = ((signbit(f) != 0 ? -f : f) * scale_to_inf) * scale_to_zero;
 #else
-          float base = (fabsf(f) * scale_to_inf) * scale_to_zero;
+  float base = (fabsf(f) * scale_to_inf) * scale_to_zero;
 #endif
 
-          const uint32_t w = fp32_to_bits(f);
-          const uint32_t shl1_w = w + w;
-          const uint32_t sign = w & UINT32_C(0x80000000);
-          uint32_t bias = shl1_w & UINT32_C(0xFF000000);
-          if (bias < UINT32_C(0x71000000)) {
-                  bias = UINT32_C(0x71000000);
-          }
-
-          base = fp32_from_bits((bias >> 1) + UINT32_C(0x07800000)) + base;
-          const uint32_t bits = fp32_to_bits(base);
-          const uint32_t exp_bits = (bits >> 13) & UINT32_C(0x00007C00);
-          const uint32_t mantissa_bits = bits & UINT32_C(0x00000FFF);
-          const uint32_t nonsign = exp_bits + mantissa_bits;
-          return static_cast<uint16_t>(
-            (sign >> 16) | (shl1_w > UINT32_C(0xFF000000) ? UINT16_C(0x7E00) : nonsign)
-          );
+  const uint32_t w = fp32_to_bits(f);
+  const uint32_t shl1_w = w + w;
+  const uint32_t sign = w & UINT32_C(0x80000000);
+  uint32_t bias = shl1_w & UINT32_C(0xFF000000);
+  if (bias < UINT32_C(0x71000000)) {
+    bias = UINT32_C(0x71000000);
   }
 
+  base = fp32_from_bits((bias >> 1) + UINT32_C(0x07800000)) + base;
+  const uint32_t bits = fp32_to_bits(base);
+  const uint32_t exp_bits = (bits >> 13) & UINT32_C(0x00007C00);
+  const uint32_t mantissa_bits = bits & UINT32_C(0x00000FFF);
+  const uint32_t nonsign = exp_bits + mantissa_bits;
+  return static_cast<uint16_t>(
+      (sign >> 16) |
+      (shl1_w > UINT32_C(0xFF000000) ? UINT16_C(0x7E00) : nonsign));
+}
+
 } // namespace detail
 
 struct alignas(2) Half {
@@ -362,7 +390,7 @@ struct alignas(2) Half {
 
 // This is just a placeholder for whatever complex representation we
 // end up deciding to use for half-precision complex numbers.
-template<>
+template <>
 struct alignas(4) complex<Half> {
   using value_type = Half;
   Half real_;
@@ -389,10 +417,10 @@ struct alignas(4) complex<Half> {
 // C4804: unsafe use of type 'bool' in operation
 // It can be addressed by disabling the following warning.
 #ifdef _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4146 )
-#pragma warning( disable : 4804 )
-#pragma warning( disable : 4018 )
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#pragma warning(disable : 4804)
+#pragma warning(disable : 4018)
 #endif
 
 // The overflow checks may involve float to int conversion which may
@@ -416,8 +444,10 @@ typename std::enable_if<std::is_same<From, bool>::value, bool>::type overflows(
 
 // skip isnan and isinf check for integral types
 template <typename To, typename From>
-typename std::enable_if<std::is_integral<From>::value && !std::is_same<From, bool>::value, bool>::type overflows(
-    From f) {
+typename std::enable_if<
+    std::is_integral<From>::value && !std::is_same<From, bool>::value,
+    bool>::type
+overflows(From f) {
   using limit = std::numeric_limits<typename scalar_value_type<To>::type>;
   if (!limit::is_signed && std::numeric_limits<From>::is_signed) {
     // allow for negative numbers to wrap using two's complement arithmetic.
@@ -448,12 +478,11 @@ overflows(From f) {
 #endif
 
 #ifdef _MSC_VER
-#pragma warning( pop )
+#pragma warning(pop)
 #endif
 
 template <typename To, typename From>
-typename std::enable_if<is_complex<From>::value, bool>::type overflows(
-    From f) {
+typename std::enable_if<is_complex<From>::value, bool>::type overflows(From f) {
   // casts from complex to real are considered to overflow if the
   // imaginary component is non-zero
   if (!is_complex<To>::value && f.imag() != 0) {
diff --git a/c10/util/IdWrapper.h b/c10/util/IdWrapper.h
index dc28141e539..a22a60cb9fc 100644
--- a/c10/util/IdWrapper.h
+++ b/c10/util/IdWrapper.h
@@ -66,12 +66,12 @@ class IdWrapper {
 
 } // namespace c10
 
-#define C10_DEFINE_HASH_FOR_IDWRAPPER(ClassName)\
-  namespace std {                               \
-  template <>                                   \
-  struct hash<ClassName> {                      \
-    size_t operator()(ClassName x) const {      \
-      return hash_value(x);                     \
-    }                                           \
-  };                                            \
+#define C10_DEFINE_HASH_FOR_IDWRAPPER(ClassName) \
+  namespace std {                                \
+  template <>                                    \
+  struct hash<ClassName> {                       \
+    size_t operator()(ClassName x) const {       \
+      return hash_value(x);                      \
+    }                                            \
+  };                                             \
   }
diff --git a/c10/util/LeftRight.h b/c10/util/LeftRight.h
index bb93ec512c7..4081540c58a 100644
--- a/c10/util/LeftRight.h
+++ b/c10/util/LeftRight.h
@@ -1,30 +1,31 @@
+#include <c10/macros/Macros.h>
+#include <array>
 #include <atomic>
 #include <functional>
 #include <mutex>
 #include <thread>
-#include <array>
-#include <c10/macros/Macros.h>
 
 namespace c10 {
 
 namespace detail {
 
 struct IncrementRAII final {
-public:
-    explicit IncrementRAII(std::atomic<int32_t> *counter): _counter(counter) {
-        _counter->fetch_add(1);
-    }
+ public:
+  explicit IncrementRAII(std::atomic<int32_t>* counter) : _counter(counter) {
+    _counter->fetch_add(1);
+  }
 
-    ~IncrementRAII() {
-        _counter->fetch_sub(1);
-    }
-private:
-    std::atomic<int32_t> *_counter;
+  ~IncrementRAII() {
+    _counter->fetch_sub(1);
+  }
 
-    C10_DISABLE_COPY_AND_ASSIGN(IncrementRAII);
+ private:
+  std::atomic<int32_t>* _counter;
+
+  C10_DISABLE_COPY_AND_ASSIGN(IncrementRAII);
 };
 
-}
+} // namespace detail
 
 // LeftRight wait-free readers synchronization primitive
 // https://hal.archives-ouvertes.fr/hal-01207881/document
@@ -48,135 +49,142 @@ private:
 //
 template <class T>
 class LeftRight final {
-public:
-    template<class... Args>
-    explicit LeftRight(const Args& ...args)
-    : _counters{{{0}, {0}}}
-    , _foregroundCounterIndex(0)
-    , _foregroundDataIndex(0)
-    , _data{{T{args...}, T{args...}}}
-    , _writeMutex()
-    {}
+ public:
+  template <class... Args>
+  explicit LeftRight(const Args&... args)
+      : _counters{{{0}, {0}}},
+        _foregroundCounterIndex(0),
+        _foregroundDataIndex(0),
+        _data{{T{args...}, T{args...}}},
+        _writeMutex() {}
 
-    // Copying and moving would not be threadsafe.
-    // Needs more thought and careful design to make that work.
-    LeftRight(const LeftRight&) = delete;
-    LeftRight(LeftRight&&) noexcept = delete;
-    LeftRight& operator=(const LeftRight&) = delete;
-    LeftRight& operator=(LeftRight&&) noexcept= delete;
+  // Copying and moving would not be threadsafe.
+  // Needs more thought and careful design to make that work.
+  LeftRight(const LeftRight&) = delete;
+  LeftRight(LeftRight&&) noexcept = delete;
+  LeftRight& operator=(const LeftRight&) = delete;
+  LeftRight& operator=(LeftRight&&) noexcept = delete;
 
-    ~LeftRight() {
-        // wait until any potentially running writers are finished
-        {
-            std::unique_lock<std::mutex> lock(_writeMutex);
-        }
+  ~LeftRight() {
+    // wait until any potentially running writers are finished
+    { std::unique_lock<std::mutex> lock(_writeMutex); }
 
-        // wait until any potentially running readers are finished
-        while (_counters[0].load() != 0 || _counters[1].load() != 0) {
-            std::this_thread::yield();
-        }
+    // wait until any potentially running readers are finished
+    while (_counters[0].load() != 0 || _counters[1].load() != 0) {
+      std::this_thread::yield();
     }
+  }
 
-    template <typename F>
-    auto read(F&& readFunc) const -> typename std::result_of<F(const T&)>::type {
-        detail::IncrementRAII _increment_counter(&_counters[_foregroundCounterIndex.load()]);
+  template <typename F>
+  auto read(F&& readFunc) const -> typename std::result_of<F(const T&)>::type {
+    detail::IncrementRAII _increment_counter(
+        &_counters[_foregroundCounterIndex.load()]);
 
-        return readFunc(_data[_foregroundDataIndex.load()]);
+    return readFunc(_data[_foregroundDataIndex.load()]);
+  }
+
+  // Throwing an exception in writeFunc is ok but causes the state to be either
+  // the old or the new state, depending on if the first or the second call to
+  // writeFunc threw.
+  template <typename F>
+  auto write(F&& writeFunc) -> typename std::result_of<F(T&)>::type {
+    std::unique_lock<std::mutex> lock(_writeMutex);
+
+    return _write(writeFunc);
+  }
+
+ private:
+  template <class F>
+  auto _write(const F& writeFunc) -> typename std::result_of<F(T&)>::type {
+    /*
+     * Assume, A is in background and B in foreground. In simplified terms, we
+     * want to do the following:
+     * 1. Write to A (old background)
+     * 2. Switch A/B
+     * 3. Write to B (new background)
+     *
+     * More detailed algorithm (explanations on why this is important are below
+     * in code):
+     * 1. Write to A
+     * 2. Switch A/B data pointers
+     * 3. Wait until A counter is zero
+     * 4. Switch A/B counters
+     * 5. Wait until B counter is zero
+     * 6. Write to B
+     */
+
+    auto localDataIndex = _foregroundDataIndex.load();
+
+    // 1. Write to A
+    _callWriteFuncOnBackgroundInstance(writeFunc, localDataIndex);
+
+    // 2. Switch A/B data pointers
+    localDataIndex = localDataIndex ^ 1;
+    _foregroundDataIndex = localDataIndex;
+
+    /*
+     * 3. Wait until A counter is zero
+     *
+     * In the previous write run, A was foreground and B was background.
+     * There was a time after switching _foregroundDataIndex (B to foreground)
+     * and before switching _foregroundCounterIndex, in which new readers could
+     * have read B but incremented A's counter.
+     *
+     * In this current run, we just switched _foregroundDataIndex (A back to
+     * foreground), but before writing to the new background B, we have to make
+     * sure A's counter was zero briefly, so all these old readers are gone.
+     */
+    auto localCounterIndex = _foregroundCounterIndex.load();
+    _waitForBackgroundCounterToBeZero(localCounterIndex);
+
+    /*
+     * 4. Switch A/B counters
+     *
+     * Now that we know all readers on B are really gone, we can switch the
+     * counters and have new readers increment A's counter again, which is the
+     * correct counter since they're reading A.
+     */
+    localCounterIndex = localCounterIndex ^ 1;
+    _foregroundCounterIndex = localCounterIndex;
+
+    /*
+     * 5. Wait until B counter is zero
+     *
+     * This waits for all the readers on B that came in while both data and
+     * counter for B was in foreground, i.e. normal readers that happened
+     * outside of that brief gap between switching data and counter.
+     */
+    _waitForBackgroundCounterToBeZero(localCounterIndex);
+
+    // 6. Write to B
+    return _callWriteFuncOnBackgroundInstance(writeFunc, localDataIndex);
+  }
+
+  template <class F>
+  auto _callWriteFuncOnBackgroundInstance(
+      const F& writeFunc,
+      uint8_t localDataIndex) -> typename std::result_of<F(T&)>::type {
+    try {
+      return writeFunc(_data[localDataIndex ^ 1]);
+    } catch (...) {
+      // recover invariant by copying from the foreground instance
+      _data[localDataIndex ^ 1] = _data[localDataIndex];
+      // rethrow
+      throw;
     }
+  }
 
-    // Throwing an exception in writeFunc is ok but causes the state to be either the old or the new state,
-    // depending on if the first or the second call to writeFunc threw.
-    template <typename F>
-    auto write(F&& writeFunc) -> typename std::result_of<F(T&)>::type {
-        std::unique_lock<std::mutex> lock(_writeMutex);
-
-        return _write(writeFunc);
+  void _waitForBackgroundCounterToBeZero(uint8_t counterIndex) {
+    while (_counters[counterIndex ^ 1].load() != 0) {
+      std::this_thread::yield();
     }
+  }
 
-private:
-    template <class F>
-    auto _write(const F& writeFunc) -> typename std::result_of<F(T&)>::type {
-        /*
-         * Assume, A is in background and B in foreground. In simplified terms, we want to do the following:
-         * 1. Write to A (old background)
-         * 2. Switch A/B
-         * 3. Write to B (new background)
-         *
-         * More detailed algorithm (explanations on why this is important are below in code):
-         * 1. Write to A
-         * 2. Switch A/B data pointers
-         * 3. Wait until A counter is zero
-         * 4. Switch A/B counters
-         * 5. Wait until B counter is zero
-         * 6. Write to B
-         */
-
-        auto localDataIndex = _foregroundDataIndex.load();
-
-        // 1. Write to A
-        _callWriteFuncOnBackgroundInstance(writeFunc, localDataIndex);
-
-        // 2. Switch A/B data pointers
-        localDataIndex = localDataIndex ^ 1;
-        _foregroundDataIndex = localDataIndex;
-
-        /*
-         * 3. Wait until A counter is zero
-         *
-         * In the previous write run, A was foreground and B was background.
-         * There was a time after switching _foregroundDataIndex (B to foreground) and before switching _foregroundCounterIndex,
-         * in which new readers could have read B but incremented A's counter.
-         *
-         * In this current run, we just switched _foregroundDataIndex (A back to foreground), but before writing to
-         * the new background B, we have to make sure A's counter was zero briefly, so all these old readers are gone.
-         */
-        auto localCounterIndex = _foregroundCounterIndex.load();
-        _waitForBackgroundCounterToBeZero(localCounterIndex);
-
-        /*
-         * 4. Switch A/B counters
-         *
-         * Now that we know all readers on B are really gone, we can switch the counters and have new readers
-         * increment A's counter again, which is the correct counter since they're reading A.
-         */
-        localCounterIndex = localCounterIndex ^ 1;
-        _foregroundCounterIndex = localCounterIndex;
-
-        /*
-         * 5. Wait until B counter is zero
-         *
-         * This waits for all the readers on B that came in while both data and counter for B was in foreground,
-         * i.e. normal readers that happened outside of that brief gap between switching data and counter.
-         */
-        _waitForBackgroundCounterToBeZero(localCounterIndex);
-
-        // 6. Write to B
-        return _callWriteFuncOnBackgroundInstance(writeFunc, localDataIndex);
-    }
-
-    template<class F>
-    auto _callWriteFuncOnBackgroundInstance(const F& writeFunc, uint8_t localDataIndex) -> typename std::result_of<F(T&)>::type {
-        try {
-            return writeFunc(_data[localDataIndex ^ 1]);
-        } catch (...) {
-            // recover invariant by copying from the foreground instance
-            _data[localDataIndex ^ 1] = _data[localDataIndex];
-            // rethrow
-            throw;
-        }
-    }
-
-    void _waitForBackgroundCounterToBeZero(uint8_t counterIndex) {
-        while (_counters[counterIndex ^ 1].load() != 0) {
-            std::this_thread::yield();
-        }
-    }
-
-    mutable std::array<std::atomic<int32_t>, 2> _counters;
-    std::atomic<uint8_t> _foregroundCounterIndex;
-    std::atomic<uint8_t> _foregroundDataIndex;
-    std::array<T, 2> _data;
-    std::mutex _writeMutex;
+  mutable std::array<std::atomic<int32_t>, 2> _counters;
+  std::atomic<uint8_t> _foregroundCounterIndex;
+  std::atomic<uint8_t> _foregroundDataIndex;
+  std::array<T, 2> _data;
+  std::mutex _writeMutex;
 };
 
-}
+} // namespace c10
diff --git a/c10/util/MathConstants.h b/c10/util/MathConstants.h
index d90d5d7effe..e169293f8a8 100644
--- a/c10/util/MathConstants.h
+++ b/c10/util/MathConstants.h
@@ -9,22 +9,24 @@ namespace c10 {
 namespace detail {
 template <typename T>
 C10_HOST_DEVICE inline constexpr T pi() {
-   return static_cast<T>(3.14159265358979323846L);
+  return static_cast<T>(3.14159265358979323846L);
 }
 
-template<>
+template <>
 C10_HOST_DEVICE inline constexpr BFloat16 pi<BFloat16>() {
-  // According to https://en.wikipedia.org/wiki/Bfloat16_floating-point_format#Special_values pi is encoded as 4049
+  // According to
+  // https://en.wikipedia.org/wiki/Bfloat16_floating-point_format#Special_values
+  // pi is encoded as 4049
   return BFloat16(0x4049, BFloat16::from_bits());
 }
-template<>
+template <>
 C10_HOST_DEVICE inline constexpr Half pi<Half>() {
   return Half(0x4248, Half::from_bits());
 }
 } // namespace detail
 
 // TODO: Replace me with std::numbers::pi when C++20 is there
-template<typename T>
+template <typename T>
 constexpr T pi = c10::detail::pi<T>();
 
 } // namespace c10
diff --git a/c10/util/MaybeOwned.h b/c10/util/MaybeOwned.h
index 49ca2186104..f4b48b613b0 100644
--- a/c10/util/MaybeOwned.h
+++ b/c10/util/MaybeOwned.h
@@ -68,20 +68,21 @@ class MaybeOwned final {
   };
 
   /// Don't use this; use borrowed() instead.
-  explicit MaybeOwned(const owned_type& t) : isBorrowed_(true), borrow_(MaybeOwnedTraits<T>::createBorrow(t)) {}
+  explicit MaybeOwned(const owned_type& t)
+      : isBorrowed_(true), borrow_(MaybeOwnedTraits<T>::createBorrow(t)) {}
 
   /// Don't use this; use owned() instead.
-  explicit MaybeOwned(T&& t) noexcept(std::is_nothrow_move_constructible<T>::value)
-  : isBorrowed_(false), own_(std::move(t)) {}
+  explicit MaybeOwned(T&& t) noexcept(
+      std::is_nothrow_move_constructible<T>::value)
+      : isBorrowed_(false), own_(std::move(t)) {}
 
   /// Don't use this; use owned() instead.
   template <class... Args>
   explicit MaybeOwned(in_place_t, Args&&... args)
-  : isBorrowed_(false)
-  , own_(std::forward<Args>(args)...) {}
+      : isBorrowed_(false), own_(std::forward<Args>(args)...) {}
 
  public:
-  explicit MaybeOwned(): isBorrowed_(true), borrow_() {}
+  explicit MaybeOwned() : isBorrowed_(true), borrow_() {}
 
   // Copying a borrow yields another borrow of the original, as with a
   // T*. Copying an owned T yields another owned T for safety: no
@@ -120,8 +121,9 @@ class MaybeOwned final {
     return *this;
   }
 
-  MaybeOwned(MaybeOwned&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value)
-  : isBorrowed_(rhs.isBorrowed_) {
+  MaybeOwned(MaybeOwned&& rhs) noexcept(
+      std::is_nothrow_move_constructible<T>::value)
+      : isBorrowed_(rhs.isBorrowed_) {
     if (C10_LIKELY(rhs.isBorrowed_)) {
       MaybeOwnedTraits<T>::assignBorrow(borrow_, rhs.borrow_);
     } else {
@@ -129,15 +131,16 @@ class MaybeOwned final {
     }
   }
 
-  MaybeOwned& operator=(MaybeOwned&& rhs) noexcept(std::is_nothrow_move_assignable<T>::value) {
+  MaybeOwned& operator=(MaybeOwned&& rhs) noexcept(
+      std::is_nothrow_move_assignable<T>::value) {
     if (this == &rhs) {
       return *this;
     }
     if (C10_UNLIKELY(!isBorrowed_)) {
       if (rhs.isBorrowed_) {
-          own_.~T();
-          MaybeOwnedTraits<T>::assignBorrow(borrow_, rhs.borrow_);
-          isBorrowed_ = true;
+        own_.~T();
+        MaybeOwnedTraits<T>::assignBorrow(borrow_, rhs.borrow_);
+        isBorrowed_ = true;
       } else {
         own_ = std::move(rhs.own_);
       }
@@ -158,7 +161,8 @@ class MaybeOwned final {
     return MaybeOwned(t);
   }
 
-  static MaybeOwned owned(T&& t) noexcept(std::is_nothrow_move_constructible<T>::value) {
+  static MaybeOwned owned(T&& t) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
     return MaybeOwned(std::move(t));
   }
 
@@ -175,22 +179,24 @@ class MaybeOwned final {
     }
   }
 
-  const T& operator*() const & {
+  const T& operator*() const& {
     if (isBorrowed_) {
-      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+          MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
     }
     return C10_LIKELY(isBorrowed_)
-      ? MaybeOwnedTraits<T>::referenceFromBorrow(borrow_)
-      : own_;
+        ? MaybeOwnedTraits<T>::referenceFromBorrow(borrow_)
+        : own_;
   }
 
   const T* operator->() const {
     if (isBorrowed_) {
-      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+          MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
     }
     return C10_LIKELY(isBorrowed_)
-      ? MaybeOwnedTraits<T>::pointerFromBorrow(borrow_)
-      : &own_;
+        ? MaybeOwnedTraits<T>::pointerFromBorrow(borrow_)
+        : &own_;
   }
 
   // If borrowed, copy the underlying T. If owned, move from
@@ -199,7 +205,8 @@ class MaybeOwned final {
   // T.
   T operator*() && {
     if (isBorrowed_) {
-      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
+      TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
+          MaybeOwnedTraits<T>::debugBorrowIsValid(borrow_));
       return MaybeOwnedTraits<T>::referenceFromBorrow(borrow_);
     } else {
       return std::move(own_);
@@ -207,5 +214,4 @@ class MaybeOwned final {
   }
 };
 
-
 } // namespace c10
diff --git a/c10/util/Metaprogramming.h b/c10/util/Metaprogramming.h
index 545240c2745..30f6d7c590a 100644
--- a/c10/util/Metaprogramming.h
+++ b/c10/util/Metaprogramming.h
@@ -1,25 +1,30 @@
 #pragma once
 
-#include <type_traits>
+#include <c10/util/Array.h>
+#include <c10/util/TypeList.h>
 #include <array>
 #include <functional>
-#include <c10/util/TypeList.h>
-#include <c10/util/Array.h>
+#include <type_traits>
 
-namespace c10 { namespace guts {
+namespace c10 {
+namespace guts {
 
 /**
  * Access information about result type or arguments from a function type.
  * Example:
  * using A = function_traits<int (float, double)>::return_type // A == int
- * using A = function_traits<int (float, double)>::parameter_types::tuple_type // A == tuple<float, double>
+ * using A = function_traits<int (float, double)>::parameter_types::tuple_type
+ * // A == tuple<float, double>
  */
-template<class Func> struct function_traits {
-  static_assert(!std::is_same<Func, Func>::value, "In function_traits<Func>, Func must be a plain function type.");
+template <class Func>
+struct function_traits {
+  static_assert(
+      !std::is_same<Func, Func>::value,
+      "In function_traits<Func>, Func must be a plain function type.");
 };
-template<class Result, class... Args>
-struct function_traits<Result (Args...)> {
-  using func_type = Result (Args...);
+template <class Result, class... Args>
+struct function_traits<Result(Args...)> {
+  using func_type = Result(Args...);
   using return_type = Result;
   using parameter_types = typelist::typelist<Args...>;
   static constexpr auto number_of_parameters = sizeof...(Args);
@@ -33,7 +38,8 @@ struct function_traits<Result (Args...)> {
 
 template <typename Functor>
 struct infer_function_traits {
-  using type = function_traits<c10::guts::detail::strip_class_t<decltype(&Functor::operator())>>;
+  using type = function_traits<
+      c10::guts::detail::strip_class_t<decltype(&Functor::operator())>>;
 };
 
 template <typename Result, typename... Args>
@@ -42,7 +48,7 @@ struct infer_function_traits<Result (*)(Args...)> {
 };
 
 template <typename Result, typename... Args>
-struct infer_function_traits<Result (Args...)> {
+struct infer_function_traits<Result(Args...)> {
   using type = function_traits<Result(Args...)>;
 };
 
@@ -56,10 +62,14 @@ using infer_function_traits_t = typename infer_function_traits<T>::type;
  * Example:
  * bool f(int, int);
  *
- * infer_function_traits_t<f> == make_function_traits_t<bool, typelist::typelist<int, int>>
+ * infer_function_traits_t<f> == make_function_traits_t<bool,
+ * typelist::typelist<int, int>>
  */
-template <typename Result, typename ArgList> struct make_function_traits {
-  static_assert(false_t<ArgList>::value, "In guts::make_function_traits<Result, TypeList>, the ArgList argument must be typelist<...>.");
+template <typename Result, typename ArgList>
+struct make_function_traits {
+  static_assert(
+      false_t<ArgList>::value,
+      "In guts::make_function_traits<Result, TypeList>, the ArgList argument must be typelist<...>.");
 };
 
 template <typename Result, typename... Args>
@@ -68,7 +78,8 @@ struct make_function_traits<Result, typelist::typelist<Args...>> {
 };
 
 template <typename Result, typename ArgList>
-using make_function_traits_t = typename make_function_traits<Result, ArgList>::type;
+using make_function_traits_t =
+    typename make_function_traits<Result, ArgList>::type;
 
 /**
  * Use extract_arg_by_filtered_index to return the i-th argument whose
@@ -77,80 +88,156 @@ using make_function_traits_t = typename make_function_traits<Result, ArgList>::t
  * Example:
  * std::string arg1 = "Hello";
  * std::string arg2 = "World";
- * std::string&& result = extract_arg_by_filtered_index<is_string, 1>(0, arg1, 2.0, std::move(arg2));
+ * std::string&& result = extract_arg_by_filtered_index<is_string, 1>(0,
+ * arg1, 2.0, std::move(arg2));
  *
- * Warning: Taking the result by rvalue reference can cause segfaults because ownership will not be passed on
- *          from the original reference. The original reference dies after the expression and the resulting
+ * Warning: Taking the result by rvalue reference can cause segfaults because
+ * ownership will not be passed on from the original reference. The original
+ * reference dies after the expression and the resulting
  */
 namespace detail {
-template<template <class> class Condition, size_t index, class Enable, class... Args> struct extract_arg_by_filtered_index_;
-template<template <class> class Condition, size_t index, class Head, class... Tail>
-struct extract_arg_by_filtered_index_<Condition, index, std::enable_if_t<!Condition<Head>::value>, Head, Tail...> {
+template <
+    template <class>
+    class Condition,
+    size_t index,
+    class Enable,
+    class... Args>
+struct extract_arg_by_filtered_index_;
+template <
+    template <class>
+    class Condition,
+    size_t index,
+    class Head,
+    class... Tail>
+struct extract_arg_by_filtered_index_<
+    Condition,
+    index,
+    std::enable_if_t<!Condition<Head>::value>,
+    Head,
+    Tail...> {
   static decltype(auto) call(Head&& /*head*/, Tail&&... tail) {
-    return extract_arg_by_filtered_index_<Condition, index, void, Tail...>::call(std::forward<Tail>(tail)...);
+    return extract_arg_by_filtered_index_<Condition, index, void, Tail...>::
+        call(std::forward<Tail>(tail)...);
   }
 };
-template<template <class> class Condition, size_t index, class Head, class... Tail>
-struct extract_arg_by_filtered_index_<Condition, index, std::enable_if_t<Condition<Head>::value && index != 0>, Head, Tail...> {
+template <
+    template <class>
+    class Condition,
+    size_t index,
+    class Head,
+    class... Tail>
+struct extract_arg_by_filtered_index_<
+    Condition,
+    index,
+    std::enable_if_t<Condition<Head>::value && index != 0>,
+    Head,
+    Tail...> {
   static decltype(auto) call(Head&& /*head*/, Tail&&... tail) {
-    return extract_arg_by_filtered_index_<Condition, index-1, void, Tail...>::call(std::forward<Tail>(tail)...);
+    return extract_arg_by_filtered_index_<Condition, index - 1, void, Tail...>::
+        call(std::forward<Tail>(tail)...);
   }
 };
-template<template <class> class Condition, size_t index>
+template <template <class> class Condition, size_t index>
 struct extract_arg_by_filtered_index_<Condition, index, void> {
   static void call() {
-    static_assert(index != index, "extract_arg_by_filtered_index out of range.");
+    static_assert(
+        index != index, "extract_arg_by_filtered_index out of range.");
   }
 };
-template<template <class> class Condition, size_t index, class Head, class... Tail>
-struct extract_arg_by_filtered_index_<Condition, index, std::enable_if_t<Condition<Head>::value && index == 0>, Head, Tail...> {
+template <
+    template <class>
+    class Condition,
+    size_t index,
+    class Head,
+    class... Tail>
+struct extract_arg_by_filtered_index_<
+    Condition,
+    index,
+    std::enable_if_t<Condition<Head>::value && index == 0>,
+    Head,
+    Tail...> {
   static decltype(auto) call(Head&& head, Tail&&... /*tail*/) {
     return std::forward<Head>(head);
   }
 };
-}
-template<template <class> class Condition, size_t index, class... Args>
+} // namespace detail
+template <template <class> class Condition, size_t index, class... Args>
 decltype(auto) extract_arg_by_filtered_index(Args&&... args) {
-  static_assert(is_type_condition<Condition>::value, "In extract_arg_by_filtered_index, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
-  return detail::extract_arg_by_filtered_index_<Condition, index, void, Args...>::call(std::forward<Args>(args)...);
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In extract_arg_by_filtered_index, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+  return detail::
+      extract_arg_by_filtered_index_<Condition, index, void, Args...>::call(
+          std::forward<Args>(args)...);
 }
 
-
-
 /**
  * Use filter_map to map a subset of the arguments to values.
  * The subset is defined by type traits, and will be evaluated at compile time.
- * At runtime, it will just loop over the pre-filtered arguments to create an std::array.
+ * At runtime, it will just loop over the pre-filtered arguments to create an
+ * std::array.
  *
  * Example:
- *  std::array<double, 2> result = filter_map<double, std::is_integral>([] (auto a) {return (double)a;}, 3, "bla", 4);
+ *  std::array<double, 2> result = filter_map<double, std::is_integral>([] (auto
+ * a) {return (double)a;}, 3, "bla", 4);
  *  // result == {3.0, 4.0}
  */
 namespace detail {
 
-template<class ResultType, size_t num_results> struct filter_map_ {
-   template<template <class> class Condition, class Mapper, class... Args, size_t... INDEX>
-   static guts::array<ResultType, num_results> call(const Mapper& mapper, std::index_sequence<INDEX...>, Args&&... args) {
-     return guts::array<ResultType, num_results> { mapper(extract_arg_by_filtered_index<Condition, INDEX>(std::forward<Args>(args)...))... };
-   }
-};
-template<class ResultType> struct filter_map_<ResultType, 0> {
-  template<template <class> class Condition, class Mapper, class... Args, size_t... INDEX>
-  static guts::array<ResultType, 0> call(const Mapper& /*mapper*/, std::index_sequence<INDEX...>, Args&&... /*args*/) {
-    return guts::array<ResultType, 0> { };
+template <class ResultType, size_t num_results>
+struct filter_map_ {
+  template <
+      template <class>
+      class Condition,
+      class Mapper,
+      class... Args,
+      size_t... INDEX>
+  static guts::array<ResultType, num_results> call(
+      const Mapper& mapper,
+      std::index_sequence<INDEX...>,
+      Args&&... args) {
+    return guts::array<ResultType, num_results>{
+        mapper(extract_arg_by_filtered_index<Condition, INDEX>(
+            std::forward<Args>(args)...))...};
   }
 };
-}
+template <class ResultType>
+struct filter_map_<ResultType, 0> {
+  template <
+      template <class>
+      class Condition,
+      class Mapper,
+      class... Args,
+      size_t... INDEX>
+  static guts::array<ResultType, 0> call(
+      const Mapper& /*mapper*/,
+      std::index_sequence<INDEX...>,
+      Args&&... /*args*/) {
+    return guts::array<ResultType, 0>{};
+  }
+};
+} // namespace detail
 
-template<class ResultType, template <class> class Condition, class Mapper, class... Args>
+template <
+    class ResultType,
+    template <class>
+    class Condition,
+    class Mapper,
+    class... Args>
 decltype(auto) filter_map(const Mapper& mapper, Args&&... args) {
-  static_assert(is_type_condition<Condition>::value, "In filter_map<Result, Condition>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In filter_map<Result, Condition>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
 
-  static constexpr size_t num_results = typelist::count_if<Condition, typelist::typelist<Args...>>::value;
-  return detail::filter_map_<ResultType, num_results>::template call<Condition, Mapper, Args...>(mapper, std::make_index_sequence<num_results>(), std::forward<Args>(args)...);
+  static constexpr size_t num_results =
+      typelist::count_if<Condition, typelist::typelist<Args...>>::value;
+  return detail::filter_map_<ResultType, num_results>::
+      template call<Condition, Mapper, Args...>(
+          mapper,
+          std::make_index_sequence<num_results>(),
+          std::forward<Args>(args)...);
 }
 
-
 /**
  * make_offset_index_sequence<Start, N>
  * Like make_index_sequence<N>, but starting from Start instead of 0.
@@ -158,22 +245,23 @@ decltype(auto) filter_map(const Mapper& mapper, Args&&... args) {
  * Example:
  *  make_offset_index_sequence<10, 3> == std::index_sequence<10, 11, 12>
  */
-template<size_t Start, size_t N, size_t... Is>
+template <size_t Start, size_t N, size_t... Is>
 struct make_offset_index_sequence_impl
-  : make_offset_index_sequence_impl<Start, N - 1, Start + N - 1, Is...>
-{
-  static_assert(static_cast<int>(Start) >= 0, "make_offset_index_sequence: Start < 0");
+    : make_offset_index_sequence_impl<Start, N - 1, Start + N - 1, Is...> {
+  static_assert(
+      static_cast<int>(Start) >= 0,
+      "make_offset_index_sequence: Start < 0");
   static_assert(static_cast<int>(N) >= 0, "make_offset_index_sequence: N < 0");
 };
 
-template<size_t Start, size_t... Is>
-struct make_offset_index_sequence_impl <Start, 0, Is...> {
+template <size_t Start, size_t... Is>
+struct make_offset_index_sequence_impl<Start, 0, Is...> {
   typedef std::index_sequence<Is...> type;
 };
 
-template<size_t Start, size_t N>
-using make_offset_index_sequence = typename make_offset_index_sequence_impl<Start, N>::type;
-
+template <size_t Start, size_t N>
+using make_offset_index_sequence =
+    typename make_offset_index_sequence_impl<Start, N>::type;
 
 /**
  * Use tuple_elements to extract a position-indexed subset of elements
@@ -181,7 +269,8 @@ using make_offset_index_sequence = typename make_offset_index_sequence_impl<Star
  *
  * Example:
  *  std::tuple<int, const char*, double> t = std::make_tuple(0, "HEY", 2.0);
- *  std::tuple<int, double> result = tuple_elements(t, std::index_sequence<0, 2>());
+ *  std::tuple<int, double> result = tuple_elements(t, std::index_sequence<0,
+ * 2>());
  */
 template <class Tuple, size_t... Is>
 constexpr auto tuple_elements(Tuple t, std::index_sequence<Is...>) {
@@ -210,7 +299,8 @@ struct TupleTake<Tuple, N, std::enable_if_t<N >= 0, void>> {
 };
 
 template <class Tuple, int N>
-struct TupleTake<Tuple, N, std::enable_if_t<N < 0, void>> {
+    struct TupleTake < Tuple,
+    N, std::enable_if_t<N<0, void>> {
   static auto call(Tuple t) {
     constexpr size_t size = std::tuple_size<Tuple>();
     static_assert(-N <= size, "tuple_take: -N > size");
@@ -227,8 +317,9 @@ auto tuple_take(Tuple t) {
  * Use tuple_slice to extract a contiguous subtuple from the argument.
  *
  * Example:
- *  std::tuple<int, const char*, double, bool> t = std::make_tuple(0, "HEY", 2.0, false);
- *  std::tuple<int, const char*> middle_two = tuple_slice<decltype(t), 1, 2>(t);
+ *  std::tuple<int, const char*, double, bool> t = std::make_tuple(0,
+ * "HEY", 2.0, false); std::tuple<int, const char*> middle_two =
+ * tuple_slice<decltype(t), 1, 2>(t);
  */
 template <class Tuple, size_t Start, size_t N>
 constexpr auto tuple_slice(Tuple t) {
@@ -237,12 +328,12 @@ constexpr auto tuple_slice(Tuple t) {
   return tuple_elements(t, make_offset_index_sequence<Start, N>{});
 }
 
-
 /**
  * Use tuple_map to run a mapping function over a tuple to get a new tuple.
  *
  * Example 1:
- *   auto result = tuple_map(std::tuple<int32_t, int32_t, int32_t>(3, 4, 5), [] (int32_t a) -> int16_t {return a+1;});
+ *   auto result = tuple_map(std::tuple<int32_t, int32_t, int32_t>(3, 4, 5), []
+ * (int32_t a) -> int16_t {return a+1;});
  *   // result == std::tuple<int16_t, int16_t, int16_t>(4, 5, 6)
  *
  * Example 2:
@@ -254,7 +345,8 @@ constexpr auto tuple_slice(Tuple t) {
  *        return atoi(a.c_str());
  *     }
  *   };
- *   auto result = tuple_map(std::tuple<int32_t, std::string>(3, "4"), Mapper());
+ *   auto result = tuple_map(std::tuple<int32_t, std::string>(3, "4"),
+ * Mapper());
  *   // result == std::tuple<std::string, int64_t>("3", 4)
  *
  * Example 3:
@@ -268,91 +360,126 @@ constexpr auto tuple_slice(Tuple t) {
  *      return "5";
  *    }
  *  };
- *  auto result = tuple_map(std::make_tuple(A(), B()), [] (auto a) { return a.func(); });
+ *  auto result = tuple_map(std::make_tuple(A(), B()), [] (auto a) { return
+ * a.func(); });
  *  // result == std::tuple<int32_t, std::string>(5, "5");
  */
 namespace detail {
-  template<class Mapper, class... Args, size_t... Indices>
-  auto tuple_map(std::tuple<Args...>&& tuple, const Mapper& mapper, std::index_sequence<Indices...>) {
-    return std::tuple<decltype(mapper(std::forward<Args>(std::get<Indices>(tuple))))...>(
-      mapper(std::forward<Args>(std::get<Indices>(tuple)))...
-    );
-  }
+template <class Mapper, class... Args, size_t... Indices>
+auto tuple_map(
+    std::tuple<Args...>&& tuple,
+    const Mapper& mapper,
+    std::index_sequence<Indices...>) {
+  return std::tuple<decltype(mapper(std::forward<Args>(std::get<Indices>(
+      tuple))))...>(mapper(std::forward<Args>(std::get<Indices>(tuple)))...);
 }
+} // namespace detail
 
-template<class Mapper, class... Args>
+template <class Mapper, class... Args>
 auto tuple_map(std::tuple<Args...>&& tuple, const Mapper& mapper) {
-  return detail::tuple_map(std::move(tuple), mapper, std::index_sequence_for<Args...>());
+  return detail::tuple_map(
+      std::move(tuple), mapper, std::index_sequence_for<Args...>());
 }
 
-
 /**
  * tuple_concat concatenates several tuples into one.
  */
 
 namespace detail {
-  // extract_tuple_element_by_index is a helper that takes a list of tuples and extracts the i-th element
-  // in a flattened view of the tuples.
-  // Example: extract_tuple_element_by_index<3>(tuple(2,3), tuple(4,5), tuple(6,7)) == 5.
+// extract_tuple_element_by_index is a helper that takes a list of tuples and
+// extracts the i-th element in a flattened view of the tuples. Example:
+// extract_tuple_element_by_index<3>(tuple(2,3), tuple(4,5), tuple(6,7)) == 5.
 
-  template<size_t index, class HeadTuple, class... TailTuples, std::enable_if_t<index < std::tuple_size<HeadTuple>::value, int> = 0>
-  decltype(auto) extract_tuple_element_by_index(HeadTuple&& head_tuple, TailTuples&&... tail_tuples) {
-    // TODO if constexpr instead of enable_if
-    return std::get<index>(std::forward<HeadTuple>(head_tuple));
-  }
-
-  template<size_t index, class HeadTuple, class... TailTuples, std::enable_if_t<index >= std::tuple_size<HeadTuple>::value, int> = 0>
-  decltype(auto) extract_tuple_element_by_index(HeadTuple&& head_tuple, TailTuples&&... tail_tuples) {
-    // TODO if constexpr instead of enable_if
-    return extract_tuple_element_by_index<index - std::tuple_size<HeadTuple>::value, TailTuples...>(std::forward<TailTuples>(tail_tuples)...);
-  }
-
-  static_assert(
-    std::is_same<
-      int&&,
-      decltype(extract_tuple_element_by_index<2>(std::tuple<int32_t>(2), std::tuple<int32_t&&, int32_t>(std::declval<int32_t>(), 3)))
-    >::value,
-    "extract_tuple_element_by_index should return rvalue references if the tuple contains them. It should not move them into a value"
-  );
-
-  template<class ConcatenatedTuple, class... Tuples, size_t... ElementIndices>
-  auto tuple_concat(Tuples&&... tuples, std::index_sequence<ElementIndices...>) {
-    return ConcatenatedTuple(extract_tuple_element_by_index<ElementIndices>(std::forward<Tuples>(tuples)...)...);
-  }
+template <
+    size_t index,
+    class HeadTuple,
+    class... TailTuples,
+    std::enable_if_t<
+        index<std::tuple_size<HeadTuple>::value, int> = 0> decltype(auto)
+        extract_tuple_element_by_index(
+            HeadTuple&& head_tuple,
+            TailTuples&&... tail_tuples) {
+  // TODO if constexpr instead of enable_if
+  return std::get<index>(std::forward<HeadTuple>(head_tuple));
 }
 
-template<class... Tuples>
-  auto tuple_concat(Tuples&&... tuples) {
-    using flattened_types = guts::typelist::concat_t<guts::typelist::from_tuple_t<Tuples>...>;
-    using concatenated_tuple = guts::typelist::to_tuple_t<flattened_types>;
-    constexpr size_t num_elements = guts::typelist::size<flattened_types>::value;
-    return detail::tuple_concat<concatenated_tuple, Tuples...>(std::forward<Tuples>(tuples)..., std::make_index_sequence<num_elements>());
-  }
+template <
+    size_t index,
+    class HeadTuple,
+    class... TailTuples,
+    std::enable_if_t<index >= std::tuple_size<HeadTuple>::value, int> = 0>
+decltype(auto) extract_tuple_element_by_index(
+    HeadTuple&& head_tuple,
+    TailTuples&&... tail_tuples) {
+  // TODO if constexpr instead of enable_if
+  return extract_tuple_element_by_index<
+      index - std::tuple_size<HeadTuple>::value,
+      TailTuples...>(std::forward<TailTuples>(tail_tuples)...);
+}
 
+static_assert(
+    std::is_same<
+        int&&,
+        decltype(extract_tuple_element_by_index<2>(
+            std::tuple<int32_t>(2),
+            std::tuple<int32_t&&, int32_t>(std::declval<int32_t>(), 3)))>::
+        value,
+    "extract_tuple_element_by_index should return rvalue references if the tuple contains them. It should not move them into a value");
+
+template <class ConcatenatedTuple, class... Tuples, size_t... ElementIndices>
+auto tuple_concat(Tuples&&... tuples, std::index_sequence<ElementIndices...>) {
+  return ConcatenatedTuple(extract_tuple_element_by_index<ElementIndices>(
+      std::forward<Tuples>(tuples)...)...);
+}
+} // namespace detail
+
+template <class... Tuples>
+auto tuple_concat(Tuples&&... tuples) {
+  using flattened_types =
+      guts::typelist::concat_t<guts::typelist::from_tuple_t<Tuples>...>;
+  using concatenated_tuple = guts::typelist::to_tuple_t<flattened_types>;
+  constexpr size_t num_elements = guts::typelist::size<flattened_types>::value;
+  return detail::tuple_concat<concatenated_tuple, Tuples...>(
+      std::forward<Tuples>(tuples)...,
+      std::make_index_sequence<num_elements>());
+}
 
 /**
  * Concatenate multiple integer sequences
  * Example:
- *   concat_iseq_t<std::index_sequence<2, 5, 3>, std::index_sequence<4, 2>, std::index_sequence<5>>
+ *   concat_iseq_t<std::index_sequence<2, 5, 3>, std::index_sequence<4, 2>,
+ * std::index_sequence<5>>
  *     == std::index_sequence<2, 5, 3, 4, 2, 5>
  */
-template<class... ISeqs> struct concat_iseq {
-  static_assert(false_t<ISeqs...>::value, "In concat_iseq<T1, ...>, the T arguments each must be std::integer_sequence<...> with the same IntType.");
+template <class... ISeqs>
+struct concat_iseq {
+  static_assert(
+      false_t<ISeqs...>::value,
+      "In concat_iseq<T1, ...>, the T arguments each must be std::integer_sequence<...> with the same IntType.");
 };
-template<>
+template <>
 struct concat_iseq<> {
   using type = std::index_sequence<>;
 };
-template<class IntType, IntType... Indices>
+template <class IntType, IntType... Indices>
 struct concat_iseq<std::integer_sequence<IntType, Indices...>> {
   using type = std::integer_sequence<IntType, Indices...>;
 };
-template<class IntType, IntType... Head1Indices, IntType... Head2Indices, class... TailISeqs>
-struct concat_iseq<std::integer_sequence<IntType, Head1Indices...>, std::integer_sequence<IntType, Head2Indices...>, TailISeqs...> {
-    using type = typename concat_iseq<std::integer_sequence<IntType, Head1Indices..., Head2Indices...>, TailISeqs...>::type;
+template <
+    class IntType,
+    IntType... Head1Indices,
+    IntType... Head2Indices,
+    class... TailISeqs>
+struct concat_iseq<
+    std::integer_sequence<IntType, Head1Indices...>,
+    std::integer_sequence<IntType, Head2Indices...>,
+    TailISeqs...> {
+  using type = typename concat_iseq<
+      std::integer_sequence<IntType, Head1Indices..., Head2Indices...>,
+      TailISeqs...>::type;
 };
-template<class... ISeqs>
+template <class... ISeqs>
 using concat_iseq_t = typename concat_iseq<ISeqs...>::type;
 
-
-}}
+} // namespace guts
+} // namespace c10
diff --git a/c10/util/Optional.cpp b/c10/util/Optional.cpp
index ce2ee24e35d..426e4f3bcd6 100644
--- a/c10/util/Optional.cpp
+++ b/c10/util/Optional.cpp
@@ -5,6 +5,10 @@
 // CUDA 9.2 and below fail while trying to compile default move constructor
 // see https://github.com/pytorch/csprng/issues/84
 #if (!defined(__CUDA_ARCH__) || !defined(CUDA_VERSION) || CUDA_VERSION > 9200)
-static_assert(C10_IS_TRIVIALLY_COPYABLE(c10::optional<int>), "c10::optional<int> should be trivially copyable");
-static_assert(C10_IS_TRIVIALLY_COPYABLE(c10::optional<bool>), "c10::optional<bool> should be trivially copyable");
+static_assert(
+    C10_IS_TRIVIALLY_COPYABLE(c10::optional<int>),
+    "c10::optional<int> should be trivially copyable");
+static_assert(
+    C10_IS_TRIVIALLY_COPYABLE(c10::optional<bool>),
+    "c10::optional<bool> should be trivially copyable");
 #endif
diff --git a/c10/util/Optional.h b/c10/util/Optional.h
index 440adb6a165..3e3e44b2a4e 100644
--- a/c10/util/Optional.h
+++ b/c10/util/Optional.h
@@ -11,13 +11,15 @@
 //
 // C10
 // - Move file to `c10` namespace.
-// - Remove macro use in line 478 because the nvcc device compiler cannot handle it
-// it.
-// - Revise constructor logic so that it is 1) consistent with c++ 17 standard documented
-// here in (8): https://en.cppreference.com/w/cpp/utility/optional/optional, and 2)
-// able to support initialization of optionals from convertible type U.
-// - Remove the constructors for `optional(const T&)` and `optional(T&&)`, as they can be
-// handled by the template<U=T> case with the default template argument.
+// - Remove macro use in line 478 because the nvcc device compiler cannot handle
+// it it.
+// - Revise constructor logic so that it is 1) consistent with c++ 17 standard
+// documented here in (8):
+// https://en.cppreference.com/w/cpp/utility/optional/optional, and 2) able to
+// support initialization of optionals from convertible type U.
+// - Remove the constructors for `optional(const T&)` and `optional(T&&)`, as
+// they can be handled by the template<U=T> case with the default template
+// argument.
 // - Move `constexpr struct in_place_t {} in_place{}` to `c10/util/in_place.h`
 // so that it can also be used in `c10/util/variant.h`.
 // - Remove special cases for pre-c++14 compilers to make code simpler.
@@ -142,7 +144,7 @@ constexpr struct trivial_init_t {
 struct nullopt_t {
   constexpr explicit nullopt_t(int) {}
 };
-constexpr nullopt_t nullopt {0};
+constexpr nullopt_t nullopt{0};
 
 // 20.5.8, class bad_optional_access
 class bad_optional_access : public std::logic_error {
@@ -187,7 +189,8 @@ struct optional_base {
 
   constexpr optional_base() noexcept : init_(false), storage_(trivial_init){};
 
-  explicit constexpr optional_base(const optional_base<T>& v) : init_(v.init_), storage_(trivial_init) {
+  explicit constexpr optional_base(const optional_base<T>& v)
+      : init_(v.init_), storage_(trivial_init) {
     if (init_) {
       ::new (dataptr()) T(v.storage_.value_);
     }
@@ -233,7 +236,7 @@ struct optional_base {
   }
 
   optional_base& operator=(optional_base&& rhs) noexcept(
-      std::is_nothrow_move_assignable<T>::value &&
+      std::is_nothrow_move_assignable<T>::value&&
           std::is_nothrow_move_constructible<T>::value) {
     if (init_ && !rhs.init_) {
       clear();
@@ -276,14 +279,17 @@ struct constexpr_optional_base {
   constexpr constexpr_optional_base() noexcept
       : init_(false), storage_(trivial_init){};
 
-  explicit constexpr constexpr_optional_base(const constexpr_optional_base<T>& v) : init_(v.init_), storage_(trivial_init) {
+  explicit constexpr constexpr_optional_base(
+      const constexpr_optional_base<T>& v)
+      : init_(v.init_), storage_(trivial_init) {
     if (init_) {
       ::new (dataptr()) T(v.storage_.value_);
     }
   }
 
-  explicit constexpr constexpr_optional_base(constexpr_optional_base<T>&& v) noexcept(
-      std::is_nothrow_move_constructible<T>::value)
+  explicit constexpr constexpr_optional_base(
+      constexpr_optional_base<T>&&
+          v) noexcept(std::is_nothrow_move_constructible<T>::value)
       : init_(v.init_), storage_(trivial_init) {
     if (init_) {
       ::new (dataptr()) T(std::move(v.storage_.value_));
@@ -325,7 +331,7 @@ struct constexpr_optional_base {
   }
 
   constexpr_optional_base& operator=(constexpr_optional_base&& rhs) noexcept(
-      std::is_nothrow_move_assignable<T>::value &&
+      std::is_nothrow_move_assignable<T>::value&&
           std::is_nothrow_move_constructible<T>::value) {
     if (init_ && !rhs.init_) {
       clear();
@@ -361,7 +367,7 @@ struct trivially_copyable_optimization_optional_base {
   constexpr_storage_t<T> storage_;
 
   constexpr trivially_copyable_optimization_optional_base() noexcept
-  : init_(false), storage_(trivial_init) {}
+      : init_(false), storage_(trivial_init) {}
 
   explicit constexpr trivially_copyable_optimization_optional_base(const T& v)
       : init_(true), storage_(v) {}
@@ -370,7 +376,9 @@ struct trivially_copyable_optimization_optional_base {
       : init_(true), storage_(constexpr_move(v)) {}
 
   template <class... Args>
-  explicit constexpr trivially_copyable_optimization_optional_base(in_place_t, Args&&... args)
+  explicit constexpr trivially_copyable_optimization_optional_base(
+      in_place_t,
+      Args&&... args)
       : init_(true), storage_(constexpr_forward<Args>(args)...) {}
 
   template <
@@ -391,14 +399,15 @@ struct trivially_copyable_optimization_optional_base {
 #if (!defined(__CUDA_ARCH__) || !defined(CUDA_VERSION) || CUDA_VERSION > 9200)
 template <class T>
 using OptionalBase = typename std::conditional<
-    std::is_trivially_destructible<T>::value &&
-    C10_IS_TRIVIALLY_COPYABLE(T) &&
-    // Avoid using is_trivially_copy_{constructible,assignable}
-    // because old GCC versions don't support them. Also,
-    // is_trivially_copyable seems not to do what I expect, so check
-    // trivially_copyable_optimization_optional_base directly.
-    std::is_copy_constructible<trivially_copyable_optimization_optional_base<T>>::value &&
-    std::is_copy_assignable<trivially_copyable_optimization_optional_base<T>>::value,
+    std::is_trivially_destructible<T>::value && C10_IS_TRIVIALLY_COPYABLE(T) &&
+        // Avoid using is_trivially_copy_{constructible,assignable}
+        // because old GCC versions don't support them. Also,
+        // is_trivially_copyable seems not to do what I expect, so check
+        // trivially_copyable_optimization_optional_base directly.
+        std::is_copy_constructible<
+            trivially_copyable_optimization_optional_base<T>>::value &&
+        std::is_copy_assignable<
+            trivially_copyable_optimization_optional_base<T>>::value,
     trivially_copyable_optimization_optional_base<T>,
     typename std::conditional<
         std::is_trivially_destructible<T>::value, // if possible
@@ -408,10 +417,10 @@ using OptionalBase = typename std::conditional<
 #else
 template <class T>
 using OptionalBase = typename std::conditional<
-        std::is_trivially_destructible<T>::value, // if possible
-        constexpr_optional_base<typename std::remove_const<
-            T>::type>, // use base with trivial destructor
-        optional_base<typename std::remove_const<T>::type>>::type;
+    std::is_trivially_destructible<T>::value, // if possible
+    constexpr_optional_base<typename std::remove_const<
+        T>::type>, // use base with trivial destructor
+    optional_base<typename std::remove_const<T>::type>>::type;
 #endif
 
 template <class T>
@@ -422,9 +431,11 @@ class optional : private OptionalBase<T> {
   template <class U> // re-declaration for nvcc on Windows.
   using OptionalBase = typename std::conditional<
       std::is_trivially_destructible<U>::value &&
-      C10_IS_TRIVIALLY_COPYABLE(U) &&
-      std::is_copy_constructible<trivially_copyable_optimization_optional_base<U>>::value &&
-      std::is_copy_assignable<trivially_copyable_optimization_optional_base<U>>::value,
+          C10_IS_TRIVIALLY_COPYABLE(U) &&
+          std::is_copy_constructible<
+              trivially_copyable_optimization_optional_base<U>>::value &&
+          std::is_copy_assignable<
+              trivially_copyable_optimization_optional_base<U>>::value,
       trivially_copyable_optimization_optional_base<U>,
       typename std::conditional<
           std::is_trivially_destructible<U>::value, // if possible
@@ -434,10 +445,10 @@ class optional : private OptionalBase<T> {
 #else
   template <class U>
   using OptionalBase = typename std::conditional<
-          std::is_trivially_destructible<U>::value, // if possible
-          constexpr_optional_base<typename std::remove_const<
-              U>::type>, // use base with trivial destructor
-          optional_base<typename std::remove_const<U>::type>>::type;
+      std::is_trivially_destructible<U>::value, // if possible
+      constexpr_optional_base<typename std::remove_const<
+          U>::type>, // use base with trivial destructor
+      optional_base<typename std::remove_const<U>::type>>::type;
 #endif
 
   static_assert(
@@ -518,27 +529,23 @@ class optional : private OptionalBase<T> {
   // of optionals from convertible type U
   //
   // 8 - implicit move construct from value
-  template<
+  template <
       typename U = T,
       TR2_OPTIONAL_REQUIRES(
-          std::is_constructible<T, U&&>::value
-          && !std::is_same<typename std::decay<U>::type, in_place_t>::value
-          && !std::is_same<typename std::decay<U>::type, optional<T>>::value
-          && std::is_convertible<U&&, T>
-      )
-    >
+          std::is_constructible<T, U&&>::value &&
+          !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
+          !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
+          std::is_convertible<U&&, T>)>
   constexpr optional(U&& u) : OptionalBase<T>(std::forward<U>(u)) {}
 
   // 8 - explicit move construct from value
-  template<
+  template <
       typename U = T,
       TR2_OPTIONAL_REQUIRES(
-          std::is_constructible<T, U&&>::value
-          && !std::is_same<typename std::decay<U>::type, in_place_t>::value
-          && !std::is_same<typename std::decay<U>::type, optional<T>>::value
-          && !std::is_convertible<U&&, T>
-      )
-    >
+          std::is_constructible<T, U&&>::value &&
+          !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
+          !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
+          !std::is_convertible<U&&, T>)>
   explicit constexpr optional(U&& u) : OptionalBase<T>(std::forward<U>(u)) {}
 
   template <class... Args>
@@ -568,12 +575,13 @@ class optional : private OptionalBase<T> {
 
   optional& operator=(optional&& rhs) = default;
 
-  template<class U = T>
+  template <class U = T>
   auto operator=(U&& v) -> typename std::enable_if<
-          std::is_constructible<T, U>::value
-          && !std::is_same<typename std::decay<U>::type, optional<T>>::value
-          && (std::is_scalar<T>::value || std::is_same<typename std::decay<U>::type, T>::value)
-          && std::is_assignable<T&, U>::value,
+      std::is_constructible<T, U>::value &&
+          !std::is_same<typename std::decay<U>::type, optional<T>>::value &&
+          (std::is_scalar<T>::value ||
+           std::is_same<typename std::decay<U>::type, T>::value) &&
+          std::is_assignable<T&, U>::value,
       optional&>::type {
     if (initialized()) {
       contained_val() = std::forward<U>(v);
@@ -681,32 +689,40 @@ class optional : private OptionalBase<T> {
 
 template <class T, class F>
 constexpr T value_or_else(const optional<T>& v, F&& func) {
-  static_assert(std::is_convertible<typename guts::infer_function_traits_t<F>::return_type, T>::value,
-    "func parameters must be a callable that returns a type convertible to the value stored in the optional");
+  static_assert(
+      std::is_convertible<
+          typename guts::infer_function_traits_t<F>::return_type,
+          T>::value,
+      "func parameters must be a callable that returns a type convertible to the value stored in the optional");
   return v.has_value() ? *v : detail_::convert<T>(std::forward<F>(func)());
 }
 
 template <class T, class F>
 constexpr T value_or_else(optional<T>&& v, F&& func) {
-  static_assert(std::is_convertible<typename guts::infer_function_traits_t<F>::return_type, T>::value,
-    "func parameters must be a callable that returns a type convertible to the value stored in the optional");
-  return v.has_value()
-    ? constexpr_move(std::move(v).contained_val())
-    : detail_::convert<T>(std::forward<F>(func)());
+  static_assert(
+      std::is_convertible<
+          typename guts::infer_function_traits_t<F>::return_type,
+          T>::value,
+      "func parameters must be a callable that returns a type convertible to the value stored in the optional");
+  return v.has_value() ? constexpr_move(std::move(v).contained_val())
+                       : detail_::convert<T>(std::forward<F>(func)());
 }
 
-
 // XXX: please refrain from using optional<T&>, since it is being against with
 // the optional standard in c++ 17, see the debate and the details here:
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3406#rationale.refs
-// if you need it, consider using optional<std::reference_wrapper<T>> or * pointer
+// if you need it, consider using optional<std::reference_wrapper<T>> or *
+// pointer
 //
-// we leave the implementation here in case we want to reconsider using it in the
-// future if it becomes a definitely necessary case.
+// we leave the implementation here in case we want to reconsider using it in
+// the future if it becomes a definitely necessary case.
 template <class T>
 class optional<T&> {
-  // add this assert to prevent user from using optional reference as indicated above
-  static_assert(sizeof(T) == 0, "optional references is ill-formed, \
+  // add this assert to prevent user from using optional reference as indicated
+  // above
+  static_assert(
+      sizeof(T) == 0,
+      "optional references is ill-formed, \
     consider use optional of a std::reference_wrapper of type T to \
     hold a reference if you really need to");
 
@@ -720,10 +736,10 @@ class optional<T&> {
 
   constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
 
-  template<typename U = T>
+  template <typename U = T>
   constexpr optional(U& u) noexcept : ref(detail_::static_addressof(u)) {}
 
-  template<typename U = T>
+  template <typename U = T>
   optional(U&&) = delete;
 
   constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
diff --git a/c10/util/Registry.h b/c10/util/Registry.h
index b0135f2157c..a4aca4c63d4 100644
--- a/c10/util/Registry.h
+++ b/c10/util/Registry.h
@@ -56,7 +56,7 @@ class Registry {
   typedef std::function<ObjectPtrType(Args...)> Creator;
 
   Registry(bool warning = true)
-    : registry_(), priority_(), terminate_(true), warning_(warning) {}
+      : registry_(), priority_(), terminate_(true), warning_(warning) {}
 
   void Register(
       const SrcType& key,
@@ -72,11 +72,11 @@ class Registry {
     if (registry_.count(key) != 0) {
       auto cur_priority = priority_[key];
       if (priority > cur_priority) {
-  #ifdef DEBUG
+#ifdef DEBUG
         std::string warn_msg =
             "Overwriting already registered item for key " + KeyStrRepr(key);
         fprintf(stderr, "%s\n", warn_msg.c_str());
-  #endif
+#endif
         registry_[key] = creator;
         priority_[key] = priority;
       } else if (priority == cur_priority) {
@@ -222,14 +222,15 @@ class Registerer {
     return registry;                                                       \
   }
 
-#define C10_DEFINE_TYPED_REGISTRY_WITHOUT_WARNING(                         \
-    RegistryName, SrcType, ObjectType, PtrType, ...)                       \
-  C10_EXPORT ::c10::Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>* \
-  RegistryName() {                                                         \
-    static ::c10::Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>*   \
-        registry = new ::c10::                                             \
-            Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>(false);  \
-    return registry;                                                       \
+#define C10_DEFINE_TYPED_REGISTRY_WITHOUT_WARNING(                            \
+    RegistryName, SrcType, ObjectType, PtrType, ...)                          \
+  C10_EXPORT ::c10::Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>*    \
+  RegistryName() {                                                            \
+    static ::c10::Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>*      \
+        registry =                                                            \
+            new ::c10::Registry<SrcType, PtrType<ObjectType>, ##__VA_ARGS__>( \
+                false);                                                       \
+    return registry;                                                          \
   }
 
 // Note(Yangqing): The __VA_ARGS__ below allows one to specify a templated
diff --git a/c10/util/SmallVector.h b/c10/util/SmallVector.h
index 9b32d8edfe7..3b2bc04eda9 100644
--- a/c10/util/SmallVector.h
+++ b/c10/util/SmallVector.h
@@ -20,8 +20,8 @@
 
 #pragma once
 
-#include <c10/util/AlignOf.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/AlignOf.h>
 
 #include <algorithm>
 #include <cassert>
@@ -244,16 +244,16 @@ class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
     }
   }
 
-  /// Move the range [Iit, Eit) into the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
+  /// Move the range [Iit, Eit) into the uninitialized memory starting with
+  /// "Dest", constructing elements as needed.
   template <typename It1, typename It2>
   static void uninitialized_move(It1 Iit, It1 Eit, It2 Dest) {
     std::uninitialized_copy(
         std::make_move_iterator(Iit), std::make_move_iterator(Eit), Dest);
   }
 
-  /// Copy the range [Iit, Eit) onto the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
+  /// Copy the range [Iit, Eit) onto the uninitialized memory starting with
+  /// "Dest", constructing elements as needed.
   template <typename It1, typename It2>
   static void uninitialized_copy(It1 Iit, It1 Eit, It2 Dest) {
     std::uninitialized_copy(Iit, Eit, Dest);
@@ -394,8 +394,8 @@ class SmallVectorImpl
  protected:
   // Default ctor - Initialize to empty.
   explicit SmallVectorImpl(unsigned N)
-      : SmallVectorTemplateBase<T, C10_IS_TRIVIALLY_COPYABLE(T)>(N * sizeof(T)) {
-  }
+      : SmallVectorTemplateBase<T, C10_IS_TRIVIALLY_COPYABLE(T)>(
+            N * sizeof(T)) {}
 
  public:
   SmallVectorImpl(const SmallVectorImpl&) = delete;
@@ -960,17 +960,20 @@ class SmallVector : public SmallVectorImpl<T> {
     this->append(S, E);
   }
 
-  // note: The enable_if restricts Container to types that have a .begin() and .end()
-  // that return valid input iterators.
-  template <typename Container, std::enable_if_t<
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().begin())>::iterator_category,
-          std::input_iterator_tag
-      >::value &&
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().end())>::iterator_category,
-          std::input_iterator_tag
-      >::value, int> = 0>
+  // note: The enable_if restricts Container to types that have a .begin() and
+  // .end() that return valid input iterators.
+  template <
+      typename Container,
+      std::enable_if_t<
+          std::is_convertible<
+              typename std::iterator_traits<decltype(
+                  std::declval<Container>().begin())>::iterator_category,
+              std::input_iterator_tag>::value &&
+              std::is_convertible<
+                  typename std::iterator_traits<decltype(
+                      std::declval<Container>().end())>::iterator_category,
+                  std::input_iterator_tag>::value,
+          int> = 0>
   explicit SmallVector(Container&& c) : SmallVectorImpl<T>(N) {
     this->append(c.begin(), c.end());
   }
@@ -994,17 +997,20 @@ class SmallVector : public SmallVectorImpl<T> {
       SmallVectorImpl<T>::operator=(::std::move(RHS));
   }
 
-  // note: The enable_if restricts Container to types that have a .begin() and .end()
-  // that return valid input iterators.
-  template <typename Container, std::enable_if_t<
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().begin())>::iterator_category,
-          std::input_iterator_tag
-      >::value &&
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().end())>::iterator_category,
-          std::input_iterator_tag
-      >::value, int> = 0>
+  // note: The enable_if restricts Container to types that have a .begin() and
+  // .end() that return valid input iterators.
+  template <
+      typename Container,
+      std::enable_if_t<
+          std::is_convertible<
+              typename std::iterator_traits<decltype(
+                  std::declval<Container>().begin())>::iterator_category,
+              std::input_iterator_tag>::value &&
+              std::is_convertible<
+                  typename std::iterator_traits<decltype(
+                      std::declval<Container>().end())>::iterator_category,
+                  std::input_iterator_tag>::value,
+          int> = 0>
   const SmallVector& operator=(const Container& RHS) {
     this->assign(RHS.begin(), RHS.end());
     return *this;
@@ -1025,17 +1031,20 @@ class SmallVector : public SmallVectorImpl<T> {
     return *this;
   }
 
-  // note: The enable_if restricts Container to types that have a .begin() and .end()
-  // that return valid input iterators.
-  template <typename Container, std::enable_if_t<
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().begin())>::iterator_category,
-          std::input_iterator_tag
-      >::value &&
-      std::is_convertible<
-          typename std::iterator_traits<decltype(std::declval<Container>().end())>::iterator_category,
-          std::input_iterator_tag
-      >::value, int> = 0>
+  // note: The enable_if restricts Container to types that have a .begin() and
+  // .end() that return valid input iterators.
+  template <
+      typename Container,
+      std::enable_if_t<
+          std::is_convertible<
+              typename std::iterator_traits<decltype(
+                  std::declval<Container>().begin())>::iterator_category,
+              std::input_iterator_tag>::value &&
+              std::is_convertible<
+                  typename std::iterator_traits<decltype(
+                      std::declval<Container>().end())>::iterator_category,
+                  std::input_iterator_tag>::value,
+          int> = 0>
   const SmallVector& operator=(Container&& C) {
     this->assign(C.begin(), C.end());
     return *this;
@@ -1053,10 +1062,10 @@ inline size_t capacity_in_bytes(const SmallVector<T, N>& X) {
 }
 
 template <typename T, unsigned N>
-std::ostream& operator<<(std::ostream & out, const SmallVector<T, N>& list) {
+std::ostream& operator<<(std::ostream& out, const SmallVector<T, N>& list) {
   int i = 0;
   out << "[";
-  for(auto e : list) {
+  for (auto e : list) {
     if (i++ > 0)
       out << ", ";
     out << e;
diff --git a/c10/util/StringUtil.cpp b/c10/util/StringUtil.cpp
index 244ca0582bd..ba7bb81fb8e 100644
--- a/c10/util/StringUtil.cpp
+++ b/c10/util/StringUtil.cpp
@@ -1,5 +1,5 @@
-#include <c10/util/StringUtil.h>
 #include <c10/util/Exception.h>
+#include <c10/util/StringUtil.h>
 
 #include <cstring>
 #include <string>
diff --git a/c10/util/StringUtil.h b/c10/util/StringUtil.h
index 794b9517c8d..69dcf99dc90 100644
--- a/c10/util/StringUtil.h
+++ b/c10/util/StringUtil.h
@@ -36,10 +36,9 @@ struct CanonicalizeStrTypes {
 
 template <size_t N>
 struct CanonicalizeStrTypes<char[N]> {
-  using type = const char *;
+  using type = const char*;
 };
 
-
 inline std::ostream& _str(std::ostream& ss) {
   return ss;
 }
@@ -52,7 +51,9 @@ inline std::ostream& _str(std::ostream& ss, const T& t) {
 }
 
 template <>
-inline std::ostream& _str<CompileTimeEmptyString>(std::ostream& ss, const CompileTimeEmptyString&) {
+inline std::ostream& _str<CompileTimeEmptyString>(
+    std::ostream& ss,
+    const CompileTimeEmptyString&) {
   return ss;
 }
 
@@ -61,7 +62,7 @@ inline std::ostream& _str(std::ostream& ss, const T& t, const Args&... args) {
   return _str(_str(ss, t), args...);
 }
 
-template<typename... Args>
+template <typename... Args>
 struct _str_wrapper final {
   static std::string call(const Args&... args) {
     std::ostringstream ss;
@@ -71,7 +72,7 @@ struct _str_wrapper final {
 };
 
 // Specializations for already-a-string types.
-template<>
+template <>
 struct _str_wrapper<std::string> final {
   // return by reference to avoid the binary size of a string copy
   static const std::string& call(const std::string& str) {
@@ -79,17 +80,17 @@ struct _str_wrapper<std::string> final {
   }
 };
 
-template<>
+template <>
 struct _str_wrapper<const char*> final {
   static const char* call(const char* str) {
     return str;
   }
 };
 
-// For c10::str() with an empty argument list (which is common in our assert macros),
-// we don't want to pay the binary size for constructing and destructing a stringstream
-// or even constructing a string.
-template<>
+// For c10::str() with an empty argument list (which is common in our assert
+// macros), we don't want to pay the binary size for constructing and
+// destructing a stringstream or even constructing a string.
+template <>
 struct _str_wrapper<> final {
   static CompileTimeEmptyString call() {
     return CompileTimeEmptyString();
@@ -101,7 +102,8 @@ struct _str_wrapper<> final {
 // Convert a list of string-like arguments into a single string.
 template <typename... Args>
 inline decltype(auto) str(const Args&... args) {
-  return detail::_str_wrapper<typename detail::CanonicalizeStrTypes<Args>::type...>::call(args...);
+  return detail::_str_wrapper<
+      typename detail::CanonicalizeStrTypes<Args>::type...>::call(args...);
 }
 
 template <class Container>
diff --git a/c10/util/ThreadLocalDebugInfo.cpp b/c10/util/ThreadLocalDebugInfo.cpp
index 668f1b4599e..21fab9363f0 100644
--- a/c10/util/ThreadLocalDebugInfo.cpp
+++ b/c10/util/ThreadLocalDebugInfo.cpp
@@ -5,7 +5,7 @@ namespace c10 {
 namespace {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 thread_local std::shared_ptr<ThreadLocalDebugInfo> debug_info = nullptr;
-}
+} // namespace
 
 /* static */
 DebugInfoBase* ThreadLocalDebugInfo::get(DebugInfoKind kind) {
@@ -45,7 +45,8 @@ void ThreadLocalDebugInfo::_push(
 std::shared_ptr<DebugInfoBase> ThreadLocalDebugInfo::_pop(DebugInfoKind kind) {
   TORCH_CHECK(
       debug_info && debug_info->kind_ == kind,
-      "Expected debug info of type ", (size_t)kind);
+      "Expected debug info of type ",
+      (size_t)kind);
   auto res = debug_info;
   debug_info = debug_info->parent_info_;
   return res->info_;
@@ -60,9 +61,9 @@ std::shared_ptr<DebugInfoBase> ThreadLocalDebugInfo::_peek(DebugInfoKind kind) {
   return debug_info->info_;
 }
 
-
 DebugInfoGuard::DebugInfoGuard(
-    DebugInfoKind kind, std::shared_ptr<DebugInfoBase> info) {
+    DebugInfoKind kind,
+    std::shared_ptr<DebugInfoBase> info) {
   if (!info) {
     return;
   }
@@ -80,8 +81,7 @@ DebugInfoGuard::~DebugInfoGuard() {
 // Used only for setting a debug info after crossing the thread boundary;
 // in this case we assume that thread pool's thread does not have an
 // active debug info
-DebugInfoGuard::DebugInfoGuard(
-    std::shared_ptr<ThreadLocalDebugInfo> info) {
+DebugInfoGuard::DebugInfoGuard(std::shared_ptr<ThreadLocalDebugInfo> info) {
   if (!info) {
     return;
   }
diff --git a/c10/util/ThreadLocalDebugInfo.h b/c10/util/ThreadLocalDebugInfo.h
index 89b2d559e26..e4405a5c650 100644
--- a/c10/util/ThreadLocalDebugInfo.h
+++ b/c10/util/ThreadLocalDebugInfo.h
@@ -68,11 +68,9 @@ class C10_API ThreadLocalDebugInfo {
 // Users can access the values through the ThreadLocalDebugInfo::get() call;
 class C10_API DebugInfoGuard {
  public:
-  DebugInfoGuard(
-      DebugInfoKind kind, std::shared_ptr<DebugInfoBase> info);
+  DebugInfoGuard(DebugInfoKind kind, std::shared_ptr<DebugInfoBase> info);
 
-  explicit DebugInfoGuard(
-      std::shared_ptr<ThreadLocalDebugInfo> info);
+  explicit DebugInfoGuard(std::shared_ptr<ThreadLocalDebugInfo> info);
 
   ~DebugInfoGuard();
 
diff --git a/c10/util/TypeCast.h b/c10/util/TypeCast.h
index 85513ecc5e2..f4333f97a7b 100644
--- a/c10/util/TypeCast.h
+++ b/c10/util/TypeCast.h
@@ -1,27 +1,27 @@
 #pragma once
 #include <c10/core/ScalarType.h>
-#include <c10/util/Half.h>
-#include <c10/util/BFloat16.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
 
 #include <type_traits>
 
-
 namespace c10 {
 
-template<typename dest_t, typename src_t>
+template <typename dest_t, typename src_t>
 struct needs_real {
-  constexpr static bool value = (is_complex<src_t>::value && !is_complex<dest_t>::value);
+  constexpr static bool value =
+      (is_complex<src_t>::value && !is_complex<dest_t>::value);
 };
 
-template<bool, typename src_t>
+template <bool, typename src_t>
 struct maybe_real {
   C10_HOST_DEVICE static inline src_t apply(src_t src) {
     return src;
   }
 };
 
-template<typename src_t>
+template <typename src_t>
 struct maybe_real<true, src_t> {
   C10_HOST_DEVICE static inline decltype(auto) apply(src_t src) {
     return src.real();
@@ -34,7 +34,8 @@ struct maybe_real<true, src_t> {
 // Some of this undefined behavior is addressed below.
 template <typename dest_t, typename src_t>
 struct static_cast_with_inter_type {
-  C10_HOST_DEVICE __ubsan_ignore_undefined__ static inline dest_t apply(src_t src) {
+  C10_HOST_DEVICE __ubsan_ignore_undefined__ static inline dest_t apply(
+      src_t src) {
     constexpr bool real = needs_real<dest_t, src_t>::value;
     return static_cast<dest_t>(maybe_real<real, src_t>::apply(src));
   }
@@ -51,10 +52,11 @@ struct static_cast_with_inter_type {
 // and divergent behavior.
 template <typename src_t>
 struct static_cast_with_inter_type<uint8_t, src_t> {
-  C10_HOST_DEVICE __ubsan_ignore_undefined__ static inline uint8_t apply(src_t src) {
+  C10_HOST_DEVICE __ubsan_ignore_undefined__ static inline uint8_t apply(
+      src_t src) {
     constexpr bool real = needs_real<uint8_t, src_t>::value;
     return static_cast<uint8_t>(
-      static_cast<int64_t>(maybe_real<real, src_t>::apply(src)));
+        static_cast<int64_t>(maybe_real<real, src_t>::apply(src)));
   }
 };
 
@@ -110,10 +112,15 @@ struct static_cast_with_inter_type<uint8_t, src_t> {
 #define ERROR_UNSUPPORTED_CAST TORCH_CHECK(false, "Unexpected scalar type");
 #endif
 
-// Fetch a value with dynamic type src_type from ptr, and cast it to static type dest_t.
-#define FETCH_AND_CAST_CASE(type, scalartype) case ScalarType::scalartype: return static_cast_with_inter_type<dest_t, type>::apply(*(const type *)ptr);
-template<typename dest_t>
-C10_HOST_DEVICE inline dest_t fetch_and_cast(const ScalarType src_type, const void *ptr) {
+// Fetch a value with dynamic type src_type from ptr, and cast it to static type
+// dest_t.
+#define FETCH_AND_CAST_CASE(type, scalartype) \
+  case ScalarType::scalartype:                \
+    return static_cast_with_inter_type<dest_t, type>::apply(*(const type*)ptr);
+template <typename dest_t>
+C10_HOST_DEVICE inline dest_t fetch_and_cast(
+    const ScalarType src_type,
+    const void* ptr) {
   switch (src_type) {
     AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(FETCH_AND_CAST_CASE)
     default:
@@ -122,10 +129,17 @@ C10_HOST_DEVICE inline dest_t fetch_and_cast(const ScalarType src_type, const vo
   return dest_t(0); // just to avoid compiler warning
 }
 
-// Cast a value with static type src_t into dynamic dest_type, and store it to ptr.
-#define CAST_AND_STORE_CASE(type, scalartype) case ScalarType::scalartype: *(type *)ptr = static_cast_with_inter_type<type, src_t>::apply(value); return;
-template<typename src_t>
-C10_HOST_DEVICE inline void cast_and_store(const ScalarType dest_type, void *ptr, src_t value) {
+// Cast a value with static type src_t into dynamic dest_type, and store it to
+// ptr.
+#define CAST_AND_STORE_CASE(type, scalartype)                             \
+  case ScalarType::scalartype:                                            \
+    *(type*)ptr = static_cast_with_inter_type<type, src_t>::apply(value); \
+    return;
+template <typename src_t>
+C10_HOST_DEVICE inline void cast_and_store(
+    const ScalarType dest_type,
+    void* ptr,
+    src_t value) {
   switch (dest_type) {
     AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_EXCEPT_COMPLEX_HALF(CAST_AND_STORE_CASE)
     default:;
@@ -133,17 +147,19 @@ C10_HOST_DEVICE inline void cast_and_store(const ScalarType dest_type, void *ptr
   ERROR_UNSUPPORTED_CAST
 }
 
-#define DEFINE_UNCASTABLE(T, scalartype_)                                                         \
-template<>                                                                                        \
-C10_HOST_DEVICE inline T fetch_and_cast<T>(const ScalarType src_type, const void *ptr) {          \
-  CUDA_KERNEL_ASSERT(ScalarType::scalartype_ == src_type);                                        \
-  return *(const T *)ptr;                                                                         \
-}                                                                                                 \
-template<>                                                                                        \
-C10_HOST_DEVICE inline void cast_and_store<T>(const ScalarType dest_type, void *ptr, T value) {   \
-  CUDA_KERNEL_ASSERT(ScalarType::scalartype_ == dest_type);                                       \
-  *(T *)ptr = value;                                                                              \
-}
+#define DEFINE_UNCASTABLE(T, scalartype_)                     \
+  template <>                                                 \
+  C10_HOST_DEVICE inline T fetch_and_cast<T>(                 \
+      const ScalarType src_type, const void* ptr) {           \
+    CUDA_KERNEL_ASSERT(ScalarType::scalartype_ == src_type);  \
+    return *(const T*)ptr;                                    \
+  }                                                           \
+  template <>                                                 \
+  C10_HOST_DEVICE inline void cast_and_store<T>(              \
+      const ScalarType dest_type, void* ptr, T value) {       \
+    CUDA_KERNEL_ASSERT(ScalarType::scalartype_ == dest_type); \
+    *(T*)ptr = value;                                         \
+  }
 
 AT_FORALL_QINT_TYPES(DEFINE_UNCASTABLE)
 
@@ -164,11 +180,12 @@ To checked_convert(From f, const char* name) {
     std::ostringstream oss;
     oss << "value cannot be converted to type " << name
         << " without overflow: " << f;
-    throw std::runtime_error(oss.str());  // rather than domain_error (issue 33562)
+    throw std::runtime_error(
+        oss.str()); // rather than domain_error (issue 33562)
   }
   return convert<To, From>(f);
 }
 
-}  // namespace c10
+} // namespace c10
 
 // Trigger tests for D25440771. TODO: Remove this line any time you want.
diff --git a/c10/util/TypeIndex.h b/c10/util/TypeIndex.h
index 3f9ebae97fa..57596eb14d0 100644
--- a/c10/util/TypeIndex.h
+++ b/c10/util/TypeIndex.h
@@ -97,17 +97,17 @@ inline constexpr string_view extract(
 template <typename T>
 inline C10_TYPENAME_CONSTEXPR c10::string_view fully_qualified_type_name_impl() {
 #if defined(_MSC_VER) && !defined(__clang__)
-    #if defined(__NVCC__)
+#if defined(__NVCC__)
   return extract(
       "c10::basic_string_view<char> c10::util::detail::fully_qualified_type_name_impl<",
       ">()",
       __FUNCSIG__);
-    #else
+#else
   return extract(
       "class c10::basic_string_view<char> __cdecl c10::util::detail::fully_qualified_type_name_impl<",
       ">(void)",
       __FUNCSIG__);
-    #endif
+#endif
 #elif defined(__clang__)
   return extract(
       "c10::string_view c10::util::detail::fully_qualified_type_name_impl() [T = ",
@@ -115,11 +115,11 @@ inline C10_TYPENAME_CONSTEXPR c10::string_view fully_qualified_type_name_impl()
       __PRETTY_FUNCTION__);
 #elif defined(__GNUC__)
   return extract(
-    #if C10_TYPENAME_SUPPORTS_CONSTEXPR
+#if C10_TYPENAME_SUPPORTS_CONSTEXPR
       "constexpr c10::string_view c10::util::detail::fully_qualified_type_name_impl() [with T = ",
-    #else
+#else
       "c10::string_view c10::util::detail::fully_qualified_type_name_impl() [with T = ",
-    #endif
+#endif
       "; c10::string_view = c10::basic_string_view<char>]",
       __PRETTY_FUNCTION__);
 #endif
@@ -155,20 +155,19 @@ inline constexpr type_index get_type_index() {
 #else
   // There's nothing in theory preventing us from running this on device code
   // except for nvcc throwing a compiler error if we enable it.
-  return (
-      abort(),
-      type_index(0));
+  return (abort(), type_index(0));
 #endif
 }
 
 template <typename T>
-inline C10_TYPENAME_CONSTEXPR string_view get_fully_qualified_type_name() noexcept {
-  #if C10_TYPENAME_SUPPORTS_CONSTEXPR
+inline C10_TYPENAME_CONSTEXPR string_view
+get_fully_qualified_type_name() noexcept {
+#if C10_TYPENAME_SUPPORTS_CONSTEXPR
   constexpr
-  #else
+#else
   static
-  #endif
-  string_view name = detail::fully_qualified_type_name_impl<T>();
+#endif
+      string_view name = detail::fully_qualified_type_name_impl<T>();
   return name;
 }
 } // namespace util
diff --git a/c10/util/TypeList.h b/c10/util/TypeList.h
index 685a6f4701c..ac3083dc9db 100644
--- a/c10/util/TypeList.h
+++ b/c10/util/TypeList.h
@@ -3,135 +3,159 @@
 #include <c10/util/C++17.h>
 #include <c10/util/TypeTraits.h>
 
-namespace c10 { namespace guts {
+namespace c10 {
+namespace guts {
 
-template<class... T> struct false_t : std::false_type {};
-template<template<class> class... T> struct false_higher_t : std::false_type {};
+template <class... T>
+struct false_t : std::false_type {};
+template <template <class> class... T>
+struct false_higher_t : std::false_type {};
 
 namespace typelist {
 
-
-
 /**
  * Type holding a list of types for compile time type computations
  */
-template<class... Items> struct typelist final {
-private:
-    typelist() = delete; // not for instantiation
+template <class... Items>
+struct typelist final {
+ private:
+  typelist() = delete; // not for instantiation
 };
 
-
-
 /**
  * Returns the number of types in a typelist
  * Example:
  *   3  ==  size<typelist<int, int, double>>::value
  */
-template<class TypeList> struct size final {
-    static_assert(false_t<TypeList>::value, "In typelist::size<T>, T must be typelist<...>.");
+template <class TypeList>
+struct size final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::size<T>, T must be typelist<...>.");
 };
-template<class... Types> struct size<typelist<Types...>> final {
-    static constexpr size_t value = sizeof...(Types);
+template <class... Types>
+struct size<typelist<Types...>> final {
+  static constexpr size_t value = sizeof...(Types);
 };
 
-
-
 /**
  * Transforms a list of types into a tuple holding these types.
  * Example:
  *   std::tuple<int, string>  ==  to_tuple_t<typelist<int, string>>
  */
-template<class TypeList> struct to_tuple final {
-    static_assert(false_t<TypeList>::value, "In typelist::to_tuple<T>, T must be typelist<...>.");
+template <class TypeList>
+struct to_tuple final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::to_tuple<T>, T must be typelist<...>.");
 };
-template<class... Types> struct to_tuple<typelist<Types...>> final {
-    using type = std::tuple<Types...>;
+template <class... Types>
+struct to_tuple<typelist<Types...>> final {
+  using type = std::tuple<Types...>;
 };
-template<class TypeList> using to_tuple_t = typename to_tuple<TypeList>::type;
-
-
-
+template <class TypeList>
+using to_tuple_t = typename to_tuple<TypeList>::type;
 
 /**
  * Creates a typelist containing the types of a given tuple.
  * Example:
  *   typelist<int, string>  ==  from_tuple_t<std::tuple<int, string>>
  */
-template<class Tuple> struct from_tuple final {
-    static_assert(false_t<Tuple>::value, "In typelist::from_tuple<T>, T must be std::tuple<...>.");
+template <class Tuple>
+struct from_tuple final {
+  static_assert(
+      false_t<Tuple>::value,
+      "In typelist::from_tuple<T>, T must be std::tuple<...>.");
 };
-template<class... Types> struct from_tuple<std::tuple<Types...>> final {
+template <class... Types>
+struct from_tuple<std::tuple<Types...>> final {
   using type = typelist<Types...>;
 };
-template<class Tuple> using from_tuple_t = typename from_tuple<Tuple>::type;
-
-
+template <class Tuple>
+using from_tuple_t = typename from_tuple<Tuple>::type;
 
 /**
  * Concatenates multiple type lists.
  * Example:
- *   typelist<int, string, int>  ==  concat_t<typelist<int, string>, typelist<int>>
+ *   typelist<int, string, int>  ==  concat_t<typelist<int, string>,
+ * typelist<int>>
  */
-template<class... TypeLists> struct concat final {
-    static_assert(false_t<TypeLists...>::value, "In typelist::concat<T1, ...>, the T arguments each must be typelist<...>.");
+template <class... TypeLists>
+struct concat final {
+  static_assert(
+      false_t<TypeLists...>::value,
+      "In typelist::concat<T1, ...>, the T arguments each must be typelist<...>.");
 };
-template<class... Head1Types, class... Head2Types, class... TailLists>
-struct concat<typelist<Head1Types...>, typelist<Head2Types...>, TailLists...> final {
-  using type = typename concat<typelist<Head1Types..., Head2Types...>, TailLists...>::type;
+template <class... Head1Types, class... Head2Types, class... TailLists>
+struct concat<typelist<Head1Types...>, typelist<Head2Types...>, TailLists...>
+    final {
+  using type =
+      typename concat<typelist<Head1Types..., Head2Types...>, TailLists...>::
+          type;
 };
-template<class... HeadTypes>
+template <class... HeadTypes>
 struct concat<typelist<HeadTypes...>> final {
   using type = typelist<HeadTypes...>;
 };
-template<>
+template <>
 struct concat<> final {
   using type = typelist<>;
 };
-template<class... TypeLists> using concat_t = typename concat<TypeLists...>::type;
-
-
+template <class... TypeLists>
+using concat_t = typename concat<TypeLists...>::type;
 
 /**
  * Filters the types in a type list by a type trait.
  * Examples:
- *   typelist<int&, const string&&>  ==  filter_t<std::is_reference, typelist<void, string, int&, bool, const string&&, int>>
+ *   typelist<int&, const string&&>  ==  filter_t<std::is_reference,
+ * typelist<void, string, int&, bool, const string&&, int>>
  */
-template<template <class> class Condition, class TypeList> struct filter final {
-  static_assert(false_t<TypeList>::value, "In typelist::filter<Condition, TypeList>, the TypeList argument must be typelist<...>.");
+template <template <class> class Condition, class TypeList>
+struct filter final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::filter<Condition, TypeList>, the TypeList argument must be typelist<...>.");
 };
-template<template <class> class Condition, class Head, class... Tail>
+template <template <class> class Condition, class Head, class... Tail>
 struct filter<Condition, typelist<Head, Tail...>> final {
-  static_assert(is_type_condition<Condition>::value, "In typelist::filter<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In typelist::filter<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
   using type = std::conditional_t<
-    Condition<Head>::value,
-    concat_t<typelist<Head>, typename filter<Condition, typelist<Tail...>>::type>,
-    typename filter<Condition, typelist<Tail...>>::type
-  >;
+      Condition<Head>::value,
+      concat_t<
+          typelist<Head>,
+          typename filter<Condition, typelist<Tail...>>::type>,
+      typename filter<Condition, typelist<Tail...>>::type>;
 };
-template<template <class> class Condition>
+template <template <class> class Condition>
 struct filter<Condition, typelist<>> final {
-  static_assert(is_type_condition<Condition>::value, "In typelist::filter<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In typelist::filter<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
   using type = typelist<>;
 };
-template<template <class> class Condition, class TypeList>
+template <template <class> class Condition, class TypeList>
 using filter_t = typename filter<Condition, TypeList>::type;
 
-
-
 /**
  * Counts how many types in the list fulfill a type trait
  * Examples:
- *   2  ==  count_if<std::is_reference, typelist<void, string, int&, bool, const string&&, int>>
+ *   2  ==  count_if<std::is_reference, typelist<void, string, int&, bool, const
+ * string&&, int>>
  */
-template<template <class> class Condition, class TypeList>
+template <template <class> class Condition, class TypeList>
 struct count_if final {
-  static_assert(is_type_condition<Condition>::value, "In typelist::count_if<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
-  static_assert(is_instantiation_of<typelist, TypeList>::value, "In typelist::count_if<Condition, TypeList>, the TypeList argument must be typelist<...>.");
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In typelist::count_if<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+  static_assert(
+      is_instantiation_of<typelist, TypeList>::value,
+      "In typelist::count_if<Condition, TypeList>, the TypeList argument must be typelist<...>.");
   // TODO Direct implementation might be faster
   static constexpr size_t value = size<filter_t<Condition, TypeList>>::value;
 };
 
-
 /**
  * Checks if a typelist contains a certain type.
  * Examples:
@@ -139,93 +163,120 @@ struct count_if final {
  *  contains<typelist<int, string>, double> == false_type
  */
 namespace detail {
-template<class TypeList, class Type, class Enable = void> struct contains {};
-template<class Type> struct contains<typelist<>, Type, void> : std::false_type {};
-template<class Type, class Head, class... Tail>
-struct contains<typelist<Head, Tail...>, Type, std::enable_if_t<std::is_same<Head, Type>::value>> : std::true_type {};
-template<class Type, class Head, class... Tail>
-struct contains<typelist<Head, Tail...>, Type, std::enable_if_t<!std::is_same<Head, Type>::value>> : contains<typelist<Tail...>, Type> {};
-}
-template<class TypeList, class Type>
+template <class TypeList, class Type, class Enable = void>
+struct contains {};
+template <class Type>
+struct contains<typelist<>, Type, void> : std::false_type {};
+template <class Type, class Head, class... Tail>
+struct contains<
+    typelist<Head, Tail...>,
+    Type,
+    std::enable_if_t<std::is_same<Head, Type>::value>> : std::true_type {};
+template <class Type, class Head, class... Tail>
+struct contains<
+    typelist<Head, Tail...>,
+    Type,
+    std::enable_if_t<!std::is_same<Head, Type>::value>>
+    : contains<typelist<Tail...>, Type> {};
+} // namespace detail
+template <class TypeList, class Type>
 using contains = typename detail::contains<TypeList, Type>::type;
 
-
 /**
  * Returns true iff the type trait is true for all types in the type list
  * Examples:
- *   true   ==  all<std::is_reference, typelist<int&, const float&&, const MyClass&>>::value
- *   false  ==  all<std::is_reference, typelist<int&, const float&&, MyClass>>::value
+ *   true   ==  all<std::is_reference, typelist<int&, const float&&, const
+ * MyClass&>>::value false  ==  all<std::is_reference, typelist<int&, const
+ * float&&, MyClass>>::value
  */
-template<template <class> class Condition, class TypeList> struct all {
-    static_assert(false_t<TypeList>::value, "In typelist::all<Condition, TypeList>, the TypeList argument must be typelist<...>.");
+template <template <class> class Condition, class TypeList>
+struct all {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::all<Condition, TypeList>, the TypeList argument must be typelist<...>.");
 };
-template<template <class> class Condition, class... Types>
+template <template <class> class Condition, class... Types>
 struct all<Condition, typelist<Types...>>
-: guts::conjunction<Condition<Types>...> {
-    static_assert(is_type_condition<Condition>::value, "In typelist::all<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+    : guts::conjunction<Condition<Types>...> {
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In typelist::all<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
 };
 
 /**
  * Returns true iff the type trait is true for any type in the type list
  * Examples:
- *   true   ==  true_for_any_type<std::is_reference, typelist<int, const float&&, const MyClass>>::value
- *   false  ==  true_for_any_type<std::is_reference, typelist<int, const float, MyClass>>::value
+ *   true   ==  true_for_any_type<std::is_reference, typelist<int, const
+ * float&&, const MyClass>>::value false  ==
+ * true_for_any_type<std::is_reference, typelist<int, const float,
+ * MyClass>>::value
  */
-template<template <class> class Condition, class TypeList> struct true_for_any_type final {
-    static_assert(false_t<TypeList>::value, "In typelist::true_for_any_type<Condition, TypeList>, the TypeList argument must be typelist<...>.");
+template <template <class> class Condition, class TypeList>
+struct true_for_any_type final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::true_for_any_type<Condition, TypeList>, the TypeList argument must be typelist<...>.");
 };
-template<template <class> class Condition, class... Types>
+template <template <class> class Condition, class... Types>
 struct true_for_any_type<Condition, typelist<Types...>> final
-: guts::disjunction<Condition<Types>...> {
-    static_assert(is_type_condition<Condition>::value, "In typelist::true_for_any_type<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
+    : guts::disjunction<Condition<Types>...> {
+  static_assert(
+      is_type_condition<Condition>::value,
+      "In typelist::true_for_any_type<Condition, TypeList>, the Condition argument must be a condition type trait, i.e. have a static constexpr bool ::value member.");
 };
 
-
 /**
  * Maps types of a type list using a type trait
  * Example:
- *  typelist<int&, double&, string&>  ==  map_t<std::add_lvalue_reference_t, typelist<int, double, string>>
+ *  typelist<int&, double&, string&>  ==  map_t<std::add_lvalue_reference_t,
+ * typelist<int, double, string>>
  */
-template<template <class> class Mapper, class TypeList> struct map final {
-    static_assert(false_t<TypeList>::value, "In typelist::map<Mapper, TypeList>, the TypeList argument must be typelist<...>.");
+template <template <class> class Mapper, class TypeList>
+struct map final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::map<Mapper, TypeList>, the TypeList argument must be typelist<...>.");
 };
-template<template <class> class Mapper, class... Types>
+template <template <class> class Mapper, class... Types>
 struct map<Mapper, typelist<Types...>> final {
   using type = typelist<Mapper<Types>...>;
 };
-template<template <class> class Mapper, class TypeList>
+template <template <class> class Mapper, class TypeList>
 using map_t = typename map<Mapper, TypeList>::type;
 
-
-
 /**
  * Returns the first element of a type list.
  * Example:
  *   int  ==  head_t<typelist<int, string>>
  */
-template<class TypeList> struct head final {
-    static_assert(false_t<TypeList>::value, "In typelist::head<T>, the T argument must be typelist<...>.");
+template <class TypeList>
+struct head final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::head<T>, the T argument must be typelist<...>.");
 };
-template<class Head, class... Tail> struct head<typelist<Head, Tail...>> final {
+template <class Head, class... Tail>
+struct head<typelist<Head, Tail...>> final {
   using type = Head;
 };
-template<class TypeList> using head_t = typename head<TypeList>::type;
-
+template <class TypeList>
+using head_t = typename head<TypeList>::type;
 
 /**
- * Returns the first element of a type list, or the specified default if the type list is empty.
- * Example:
- *   int  ==  head_t<bool, typelist<int, string>>
+ * Returns the first element of a type list, or the specified default if the
+ * type list is empty. Example: int  ==  head_t<bool, typelist<int, string>>
  *   bool  ==  head_t<bool, typelist<>>
  */
-template<class Default, class TypeList> struct head_with_default final {
+template <class Default, class TypeList>
+struct head_with_default final {
   using type = Default;
 };
-template<class Default, class Head, class... Tail> struct head_with_default<Default, typelist<Head, Tail...>> final {
+template <class Default, class Head, class... Tail>
+struct head_with_default<Default, typelist<Head, Tail...>> final {
   using type = Head;
 };
-template<class Default, class TypeList> using head_with_default_t = typename head_with_default<Default, TypeList>::type;
-
+template <class Default, class TypeList>
+using head_with_default_t = typename head_with_default<Default, TypeList>::type;
 
 /**
  * Returns the N-th element of a type list.
@@ -234,28 +285,38 @@ template<class Default, class TypeList> using head_with_default_t = typename hea
  */
 
 /// Base template.
-template<size_t Index, class TypeList> struct element final {
-    static_assert(false_t<TypeList>::value, "In typelist::element<T>, the T argument must be typelist<...>.");
+template <size_t Index, class TypeList>
+struct element final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::element<T>, the T argument must be typelist<...>.");
 };
 
-/// Successful case, we have reached the zero index and can "return" the head type.
-template<class Head, class... Tail> struct element<0, typelist<Head, Tail...>> { using type = Head; };
+/// Successful case, we have reached the zero index and can "return" the head
+/// type.
+template <class Head, class... Tail>
+struct element<0, typelist<Head, Tail...>> {
+  using type = Head;
+};
 
 /// Error case, we have an index but ran out of types! It will only be selected
 /// if `Ts...` is actually empty!
 template <size_t Index, class... Ts>
 struct element<Index, typelist<Ts...>> {
-  static_assert(Index < sizeof...(Ts), "Index is out of bounds in typelist::element");
+  static_assert(
+      Index < sizeof...(Ts),
+      "Index is out of bounds in typelist::element");
 };
 
 /// Shave off types until we hit the <0, Head, Tail...> or <Index> case.
-template<size_t Index, class Head, class... Tail> struct element<Index, typelist<Head, Tail...>> : element<Index-1, typelist<Tail...>> { };
+template <size_t Index, class Head, class... Tail>
+struct element<Index, typelist<Head, Tail...>>
+    : element<Index - 1, typelist<Tail...>> {};
 
 /// Convenience alias.
-template<size_t Index, class TypeList>
+template <size_t Index, class TypeList>
 using element_t = typename element<Index, TypeList>::type;
 
-
 /**
  * Returns the last element of a type list.
  * Example:
@@ -281,7 +342,6 @@ static_assert(
     std::is_same<int, last_t<typelist<double, float, int>>>::value,
     "");
 
-
 /**
  * Take/drop a number of arguments from a typelist.
  * Example:
@@ -289,28 +349,44 @@ static_assert(
  *   typelist<bool> == drop_t<typelist<int, string, bool>, 2>
  */
 namespace detail {
-  template<class TypeList, size_t offset, class IndexSequence>
-  struct take_elements final {};
+template <class TypeList, size_t offset, class IndexSequence>
+struct take_elements final {};
 
-  template<class TypeList, size_t offset, size_t... Indices>
-  struct take_elements<TypeList, offset, std::index_sequence<Indices...>> final {
-    using type = typelist<typename element<offset + Indices, TypeList>::type...>;
-  };
-}
-
-template<class TypeList, size_t num> struct take final {
-  static_assert(is_instantiation_of<typelist, TypeList>::value, "In typelist::take<T, num>, the T argument must be typelist<...>.");
-  static_assert(num <= size<TypeList>::value, "Tried to typelist::take more elements than there are in the list");
-  using type = typename detail::take_elements<TypeList, 0, std::make_index_sequence<num>>::type;
+template <class TypeList, size_t offset, size_t... Indices>
+struct take_elements<TypeList, offset, std::index_sequence<Indices...>> final {
+  using type = typelist<typename element<offset + Indices, TypeList>::type...>;
 };
-template<class TypeList, size_t num> using take_t = typename take<TypeList, num>::type;
+} // namespace detail
 
-template<class TypeList, size_t num> struct drop final {
-  static_assert(is_instantiation_of<typelist, TypeList>::value, "In typelist::drop<T, num>, the T argument must be typelist<...>.");
-  static_assert(num <= size<TypeList>::value, "Tried to typelist::drop more elements than there are in the list");
-  using type = typename detail::take_elements<TypeList, num, std::make_index_sequence<size<TypeList>::value - num>>::type;
+template <class TypeList, size_t num>
+struct take final {
+  static_assert(
+      is_instantiation_of<typelist, TypeList>::value,
+      "In typelist::take<T, num>, the T argument must be typelist<...>.");
+  static_assert(
+      num <= size<TypeList>::value,
+      "Tried to typelist::take more elements than there are in the list");
+  using type = typename detail::
+      take_elements<TypeList, 0, std::make_index_sequence<num>>::type;
 };
-template<class TypeList, size_t num> using drop_t = typename drop<TypeList, num>::type;
+template <class TypeList, size_t num>
+using take_t = typename take<TypeList, num>::type;
+
+template <class TypeList, size_t num>
+struct drop final {
+  static_assert(
+      is_instantiation_of<typelist, TypeList>::value,
+      "In typelist::drop<T, num>, the T argument must be typelist<...>.");
+  static_assert(
+      num <= size<TypeList>::value,
+      "Tried to typelist::drop more elements than there are in the list");
+  using type = typename detail::take_elements<
+      TypeList,
+      num,
+      std::make_index_sequence<size<TypeList>::value - num>>::type;
+};
+template <class TypeList, size_t num>
+using drop_t = typename drop<TypeList, num>::type;
 
 /**
  * Like drop, but returns an empty list rather than an assertion error if `num`
@@ -319,52 +395,77 @@ template<class TypeList, size_t num> using drop_t = typename drop<TypeList, num>
  *   typelist<> == drop_if_nonempty_t<typelist<string, bool>, 2>
  *   typelist<> == drop_if_nonempty_t<typelist<int, string, bool>, 3>
  */
-template<class TypeList, size_t num> struct drop_if_nonempty final {
-  static_assert(is_instantiation_of<typelist, TypeList>::value, "In typelist::drop<T, num>, the T argument must be typelist<...>.");
+template <class TypeList, size_t num>
+struct drop_if_nonempty final {
+  static_assert(
+      is_instantiation_of<typelist, TypeList>::value,
+      "In typelist::drop<T, num>, the T argument must be typelist<...>.");
   using type = typename detail::take_elements<
-    TypeList,
-    min(num, size<TypeList>::value),
-    std::make_index_sequence<size<TypeList>::value - min(num, size<TypeList>::value)>>::type;
+      TypeList,
+      min(num, size<TypeList>::value),
+      std::make_index_sequence<
+          size<TypeList>::value - min(num, size<TypeList>::value)>>::type;
 };
-template<class TypeList, size_t num> using drop_if_nonempty_t = typename drop_if_nonempty<TypeList, num>::type;
-
+template <class TypeList, size_t num>
+using drop_if_nonempty_t = typename drop_if_nonempty<TypeList, num>::type;
 
 /**
  * Reverses a typelist.
  * Example:
  *   typelist<int, string>  == reverse_t<typelist<string, int>>
  */
-template<class TypeList> struct reverse final {
-    static_assert(false_t<TypeList>::value, "In typelist::reverse<T>, the T argument must be typelist<...>.");
+template <class TypeList>
+struct reverse final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::reverse<T>, the T argument must be typelist<...>.");
 };
-template<class Head, class... Tail> struct reverse<typelist<Head, Tail...>> final {
-  using type = concat_t<typename reverse<typelist<Tail...>>::type, typelist<Head>>;
+template <class Head, class... Tail>
+struct reverse<typelist<Head, Tail...>> final {
+  using type =
+      concat_t<typename reverse<typelist<Tail...>>::type, typelist<Head>>;
 };
-template<> struct reverse<typelist<>> final {
+template <>
+struct reverse<typelist<>> final {
   using type = typelist<>;
 };
-template<class TypeList> using reverse_t = typename reverse<TypeList>::type;
-
+template <class TypeList>
+using reverse_t = typename reverse<TypeList>::type;
 
 /**
- * Find the index of the first type in a typelist fulfilling a type trait condition.
- * Example:
+ * Find the index of the first type in a typelist fulfilling a type trait
+ * condition. Example:
  *
  * 2 == find_if<typelist<char, int, char&, int&>, std::is_reference>::value
  */
-template<class TypeList, template<class> class Condition, class Enable = void> struct find_if final {
-  static_assert(false_t<TypeList>::value, "In typelist::find_if<TypeList, Condition>, the TypeList argument must be typelist<...>.");
+template <class TypeList, template <class> class Condition, class Enable = void>
+struct find_if final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::find_if<TypeList, Condition>, the TypeList argument must be typelist<...>.");
 };
-template<template<class> class Condition> struct find_if<typelist<>, Condition, void> final {
-  static_assert(false_higher_t<Condition>::value, "In typelist::find_if<Type/List, Condition>, didn't find any type fulfilling the Condition.");
+template <template <class> class Condition>
+struct find_if<typelist<>, Condition, void> final {
+  static_assert(
+      false_higher_t<Condition>::value,
+      "In typelist::find_if<Type/List, Condition>, didn't find any type fulfilling the Condition.");
 };
-template<class Head, class... Tail, template<class> class Condition>
-struct find_if<typelist<Head, Tail...>, Condition, std::enable_if_t<Condition<Head>::value>> final {
+template <class Head, class... Tail, template <class> class Condition>
+struct find_if<
+    typelist<Head, Tail...>,
+    Condition,
+    std::enable_if_t<Condition<Head>::value>>
+    final {
   static constexpr size_t value = 0;
 };
-template<class Head, class... Tail, template<class> class Condition>
-struct find_if<typelist<Head, Tail...>, Condition, std::enable_if_t<!Condition<Head>::value>> final {
-  static constexpr size_t value = 1 + find_if<typelist<Tail...>, Condition>::value;
+template <class Head, class... Tail, template <class> class Condition>
+struct find_if<
+    typelist<Head, Tail...>,
+    Condition,
+    std::enable_if_t<!Condition<Head>::value>>
+    final {
+  static constexpr size_t value =
+      1 + find_if<typelist<Tail...>, Condition>::value;
 };
 
 /**
@@ -385,24 +486,31 @@ struct find_if<typelist<Head, Tail...>, Condition, std::enable_if_t<!Condition<H
  *   // shared_ptrs == std::tuple<shared_ptr<int>, shared_ptr<double>>()
  */
 namespace detail {
-template<class T> struct type_ final {
-    using type = T;
+template <class T>
+struct type_ final {
+  using type = T;
 };
-template<class TypeList> struct map_types_to_values final {
-    static_assert(false_t<TypeList>::value, "In typelist::map_types_to_values<T>, the T argument must be typelist<...>.");
+template <class TypeList>
+struct map_types_to_values final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::map_types_to_values<T>, the T argument must be typelist<...>.");
 };
-template<class... Types> struct map_types_to_values<typelist<Types...>> final {
-  template<class Func>
+template <class... Types>
+struct map_types_to_values<typelist<Types...>> final {
+  template <class Func>
   static std::tuple<std::result_of_t<Func(type_<Types>)>...> call(Func&& func) {
-    return std::tuple<std::result_of_t<Func(type_<Types>)>...> { std::forward<Func>(func)(type_<Types>())... };
+    return std::tuple<std::result_of_t<Func(type_<Types>)>...>{
+        std::forward<Func>(func)(type_<Types>())...};
   }
 };
-}
+} // namespace detail
 
-template<class TypeList, class Func>
+template <class TypeList, class Func>
 decltype(auto) map_types_to_values(Func&& func) {
   return detail::map_types_to_values<TypeList>::call(std::forward<Func>(func));
 }
 
-
-}}}
+} // namespace typelist
+} // namespace guts
+} // namespace c10
diff --git a/c10/util/TypeTraits.h b/c10/util/TypeTraits.h
index a5756dbc8cc..4b63b6a1e33 100644
--- a/c10/util/TypeTraits.h
+++ b/c10/util/TypeTraits.h
@@ -6,39 +6,45 @@
 namespace c10 {
 namespace guts {
 
-
 /**
- * is_equality_comparable<T> is true_type iff the equality operator is defined for T.
+ * is_equality_comparable<T> is true_type iff the equality operator is defined
+ * for T.
  */
-template<class T, class Enable = void> struct is_equality_comparable : std::false_type {};
-template<class T> struct is_equality_comparable<T, void_t<decltype(std::declval<T&>() == std::declval<T&>())>> : std::true_type {};
-template<class T> using is_equality_comparable_t = typename is_equality_comparable<T>::type;
-
-
+template <class T, class Enable = void>
+struct is_equality_comparable : std::false_type {};
+template <class T>
+struct is_equality_comparable<
+    T,
+    void_t<decltype(std::declval<T&>() == std::declval<T&>())>>
+    : std::true_type {};
+template <class T>
+using is_equality_comparable_t = typename is_equality_comparable<T>::type;
 
 /**
  * is_hashable<T> is true_type iff std::hash is defined for T
  */
-template<class T, class Enable = void> struct is_hashable : std::false_type {};
-template<class T> struct is_hashable<T, void_t<decltype(std::hash<T>()(std::declval<T&>()))>> : std::true_type {};
-template<class T> using is_hashable_t = typename is_hashable<T>::type;
-
-
+template <class T, class Enable = void>
+struct is_hashable : std::false_type {};
+template <class T>
+struct is_hashable<T, void_t<decltype(std::hash<T>()(std::declval<T&>()))>>
+    : std::true_type {};
+template <class T>
+using is_hashable_t = typename is_hashable<T>::type;
 
 /**
- * is_function_type<T> is true_type iff T is a plain function type (i.e. "Result(Args...)")
+ * is_function_type<T> is true_type iff T is a plain function type (i.e.
+ * "Result(Args...)")
  */
-template<class T>
+template <class T>
 struct is_function_type : std::false_type {};
-template<class Result, class... Args>
-struct is_function_type<Result (Args...)> : std::true_type {};
-template<class T> using is_function_type_t = typename is_function_type<T>::type;
-
-
+template <class Result, class... Args>
+struct is_function_type<Result(Args...)> : std::true_type {};
+template <class T>
+using is_function_type_t = typename is_function_type<T>::type;
 
 /**
- * is_instantiation_of<T, I> is true_type iff I is a template instantiation of T (e.g. vector<int> is an instantiation of vector)
- *  Example:
+ * is_instantiation_of<T, I> is true_type iff I is a template instantiation of T
+ * (e.g. vector<int> is an instantiation of vector) Example:
  *    is_instantiation_of_t<vector, vector<int>> // true
  *    is_instantiation_of_t<pair, pair<int, string>> // true
  *    is_instantiation_of_t<vector, pair<int, string>> // false
@@ -47,7 +53,8 @@ template <template <class...> class Template, class T>
 struct is_instantiation_of : std::false_type {};
 template <template <class...> class Template, class... Args>
 struct is_instantiation_of<Template, Template<Args...>> : std::true_type {};
-template<template<class...> class Template, class T> using is_instantiation_of_t = typename is_instantiation_of<Template, T>::type;
+template <template <class...> class Template, class T>
+using is_instantiation_of_t = typename is_instantiation_of<Template, T>::type;
 
 namespace detail {
 /**
@@ -73,11 +80,14 @@ using strip_class_t = typename strip_class<T>::type;
  * (i.e. has a call operator with some set of arguments)
  */
 
-template<class Functor, class Enable = void>
+template <class Functor, class Enable = void>
 struct is_functor : std::false_type {};
-template<class Functor>
-struct is_functor<Functor, std::enable_if_t<is_function_type<detail::strip_class_t<decltype(&Functor::operator())>>::value>> : std::true_type {};
-
+template <class Functor>
+struct is_functor<
+    Functor,
+    std::enable_if_t<is_function_type<
+        detail::strip_class_t<decltype(&Functor::operator())>>::value>>
+    : std::true_type {};
 
 /**
  * lambda_is_stateless<T> is true iff the lambda type T is stateless
@@ -89,45 +99,55 @@ struct is_functor<Functor, std::enable_if_t<is_function_type<detail::strip_class
  *  lambda_is_stateless<decltype(stateful_lambda)> // false
  */
 namespace detail {
-template<class LambdaType, class FuncType> struct is_stateless_lambda__ final {
-    static_assert(!std::is_same<LambdaType, LambdaType>::value, "Base case shouldn't be hit");
+template <class LambdaType, class FuncType>
+struct is_stateless_lambda__ final {
+  static_assert(
+      !std::is_same<LambdaType, LambdaType>::value,
+      "Base case shouldn't be hit");
 };
-// implementation idea: According to the C++ standard, stateless lambdas are convertible to function pointers
-template<class LambdaType, class C, class Result, class... Args>
-struct is_stateless_lambda__<LambdaType, Result (C::*)(Args...) const> : std::is_convertible<LambdaType, Result(*)(Args...)> {};
-template<class LambdaType, class C, class Result, class... Args>
-struct is_stateless_lambda__<LambdaType, Result (C::*)(Args...)> : std::is_convertible<LambdaType, Result(*)(Args...)> {};
+// implementation idea: According to the C++ standard, stateless lambdas are
+// convertible to function pointers
+template <class LambdaType, class C, class Result, class... Args>
+struct is_stateless_lambda__<LambdaType, Result (C::*)(Args...) const>
+    : std::is_convertible<LambdaType, Result (*)(Args...)> {};
+template <class LambdaType, class C, class Result, class... Args>
+struct is_stateless_lambda__<LambdaType, Result (C::*)(Args...)>
+    : std::is_convertible<LambdaType, Result (*)(Args...)> {};
 
 // case where LambdaType is not even a functor
-template<class LambdaType, class Enable = void> struct is_stateless_lambda_ final : std::false_type {};
+template <class LambdaType, class Enable = void>
+struct is_stateless_lambda_ final : std::false_type {};
 // case where LambdaType is a functor
-template<class LambdaType> struct is_stateless_lambda_<LambdaType, std::enable_if_t<is_functor<LambdaType>::value>>
-: is_stateless_lambda__<LambdaType, decltype(&LambdaType::operator())> {};
-}
-template<class T>
+template <class LambdaType>
+struct is_stateless_lambda_<
+    LambdaType,
+    std::enable_if_t<is_functor<LambdaType>::value>>
+    : is_stateless_lambda__<LambdaType, decltype(&LambdaType::operator())> {};
+} // namespace detail
+template <class T>
 using is_stateless_lambda = detail::is_stateless_lambda_<std::decay_t<T>>;
 
-
-
 /**
- * is_type_condition<C> is true_type iff C<...> is a type trait representing a condition (i.e. has a constexpr static bool ::value member)
- * Example:
+ * is_type_condition<C> is true_type iff C<...> is a type trait representing a
+ * condition (i.e. has a constexpr static bool ::value member) Example:
  *   is_type_condition<std::is_reference>  // true
  */
-template<template<class> class C, class Enable = void>
+template <template <class> class C, class Enable = void>
 struct is_type_condition : std::false_type {};
-template<template<class> class C>
-struct is_type_condition<C, std::enable_if_t<std::is_same<bool, std::remove_cv_t<decltype(C<int>::value)>>::value>> : std::true_type {};
-
+template <template <class> class C>
+struct is_type_condition<
+    C,
+    std::enable_if_t<
+        std::is_same<bool, std::remove_cv_t<decltype(C<int>::value)>>::value>>
+    : std::true_type {};
 
 /**
- * is_fundamental<T> is true_type iff the lambda type T is a fundamental type (that is, arithmetic type, void, or nullptr_t).
- * Example:
- *  is_fundamental<int> // true
- * We define it here to resolve a MSVC bug.
- * See https://github.com/pytorch/pytorch/issues/30932 for details.
+ * is_fundamental<T> is true_type iff the lambda type T is a fundamental type
+ * (that is, arithmetic type, void, or nullptr_t). Example: is_fundamental<int>
+ * // true We define it here to resolve a MSVC bug. See
+ * https://github.com/pytorch/pytorch/issues/30932 for details.
  */
 template <class T>
 struct is_fundamental : std::is_fundamental<T> {};
-}
-}
+} // namespace guts
+} // namespace c10
diff --git a/c10/util/Unicode.cpp b/c10/util/Unicode.cpp
index 1c7eefc57b5..01b8013832d 100644
--- a/c10/util/Unicode.cpp
+++ b/c10/util/Unicode.cpp
@@ -3,47 +3,47 @@
 namespace c10 {
 #if defined(_WIN32)
 std::wstring u8u16(const std::string& str) {
-    if (str.empty()) {
-        return std::wstring();
-    }
-    int size_needed = MultiByteToWideChar(
-            CP_UTF8, 0, str.c_str(), static_cast<int>(str.size()), NULL, 0);
-    TORCH_CHECK(size_needed > 0, "Error converting the content to Unicode");
-    std::wstring wstr(size_needed, 0);
-    MultiByteToWideChar(
-            CP_UTF8,
-            0,
-            str.c_str(),
-            static_cast<int>(str.size()),
-            &wstr[0],
-            size_needed);
-    return wstr;
+  if (str.empty()) {
+    return std::wstring();
+  }
+  int size_needed = MultiByteToWideChar(
+      CP_UTF8, 0, str.c_str(), static_cast<int>(str.size()), NULL, 0);
+  TORCH_CHECK(size_needed > 0, "Error converting the content to Unicode");
+  std::wstring wstr(size_needed, 0);
+  MultiByteToWideChar(
+      CP_UTF8,
+      0,
+      str.c_str(),
+      static_cast<int>(str.size()),
+      &wstr[0],
+      size_needed);
+  return wstr;
 }
 std::string u16u8(const std::wstring& wstr) {
-    if (wstr.empty()) {
-        return std::string();
-    }
-    int size_needed = WideCharToMultiByte(
-            CP_UTF8,
-            0,
-            wstr.c_str(),
-            static_cast<int>(wstr.size()),
-            NULL,
-            0,
-            NULL,
-            NULL);
-    TORCH_CHECK(size_needed > 0, "Error converting the content to UTF8");
-    std::string str(size_needed, 0);
-    WideCharToMultiByte(
-            CP_UTF8,
-            0,
-            wstr.c_str(),
-            static_cast<int>(wstr.size()),
-            &str[0],
-            size_needed,
-            NULL,
-            NULL);
-    return str;
+  if (wstr.empty()) {
+    return std::string();
+  }
+  int size_needed = WideCharToMultiByte(
+      CP_UTF8,
+      0,
+      wstr.c_str(),
+      static_cast<int>(wstr.size()),
+      NULL,
+      0,
+      NULL,
+      NULL);
+  TORCH_CHECK(size_needed > 0, "Error converting the content to UTF8");
+  std::string str(size_needed, 0);
+  WideCharToMultiByte(
+      CP_UTF8,
+      0,
+      wstr.c_str(),
+      static_cast<int>(wstr.size()),
+      &str[0],
+      size_needed,
+      NULL,
+      NULL);
+  return str;
 }
 #endif
-}  // namespace c10
+} // namespace c10
diff --git a/c10/util/Unicode.h b/c10/util/Unicode.h
index ccdea5a62c1..7c0c15dd0d9 100644
--- a/c10/util/Unicode.h
+++ b/c10/util/Unicode.h
@@ -1,9 +1,9 @@
 #pragma once
 
 #if defined(_WIN32)
-#include <string>
-#include <c10/util/win32-headers.h>
 #include <c10/util/Exception.h>
+#include <c10/util/win32-headers.h>
+#include <string>
 #endif
 
 namespace c10 {
@@ -11,4 +11,4 @@ namespace c10 {
 C10_API std::wstring u8u16(const std::string& str);
 C10_API std::string u16u8(const std::wstring& wstr);
 #endif
-}
+} // namespace c10
diff --git a/c10/util/UniqueVoidPtr.h b/c10/util/UniqueVoidPtr.h
index c4e3158ae10..7d9e422f3c6 100644
--- a/c10/util/UniqueVoidPtr.h
+++ b/c10/util/UniqueVoidPtr.h
@@ -66,8 +66,11 @@ class UniqueVoidPtr {
   std::unique_ptr<void, DeleterFnPtr>&& move_context() {
     return std::move(ctx_);
   }
-  C10_NODISCARD bool compare_exchange_deleter(DeleterFnPtr expected_deleter, DeleterFnPtr new_deleter) {
-    if (get_deleter() != expected_deleter) return false;
+  C10_NODISCARD bool compare_exchange_deleter(
+      DeleterFnPtr expected_deleter,
+      DeleterFnPtr new_deleter) {
+    if (get_deleter() != expected_deleter)
+      return false;
     ctx_ = std::unique_ptr<void, DeleterFnPtr>(ctx_.release(), new_deleter);
     return true;
   }
diff --git a/c10/util/accumulate.h b/c10/util/accumulate.h
index 5243dfda8fb..086a7977401 100644
--- a/c10/util/accumulate.h
+++ b/c10/util/accumulate.h
@@ -10,60 +10,96 @@
 
 namespace c10 {
 
-///Sum of a list of integers; accumulates into the int64_t datatype
-template<typename C, typename std::enable_if<std::is_integral<typename C::value_type>::value, int>::type = 0>
-inline int64_t sum_integers(const C &container){
-    //std::accumulate infers return type from `init` type, so if the `init` type is not large
-    //enough to hold the result, computation can overflow. We use `int64_t` here to avoid this.
-    return std::accumulate(container.begin(), container.end(), static_cast<int64_t>(0));
+/// Sum of a list of integers; accumulates into the int64_t datatype
+template <
+    typename C,
+    typename std::enable_if<
+        std::is_integral<typename C::value_type>::value,
+        int>::type = 0>
+inline int64_t sum_integers(const C& container) {
+  // std::accumulate infers return type from `init` type, so if the `init` type
+  // is not large enough to hold the result, computation can overflow. We use
+  // `int64_t` here to avoid this.
+  return std::accumulate(
+      container.begin(), container.end(), static_cast<int64_t>(0));
 }
 
-///Sum of integer elements referred to by iterators; accumulates into the int64_t datatype
-template<typename Iter,
-typename std::enable_if<std::is_integral<typename std::iterator_traits<Iter>::value_type>::value, int>::type = 0>
-inline int64_t sum_integers(Iter begin, Iter end){
-    //std::accumulate infers return type from `init` type, so if the `init` type is not large
-    //enough to hold the result, computation can overflow. We use `int64_t` here to avoid this.
-    return std::accumulate(begin, end, static_cast<int64_t>(0));
+/// Sum of integer elements referred to by iterators; accumulates into the
+/// int64_t datatype
+template <
+    typename Iter,
+    typename std::enable_if<
+        std::is_integral<
+            typename std::iterator_traits<Iter>::value_type>::value,
+        int>::type = 0>
+inline int64_t sum_integers(Iter begin, Iter end) {
+  // std::accumulate infers return type from `init` type, so if the `init` type
+  // is not large enough to hold the result, computation can overflow. We use
+  // `int64_t` here to avoid this.
+  return std::accumulate(begin, end, static_cast<int64_t>(0));
 }
 
-///Product of a list of integers; accumulates into the int64_t datatype
-template<typename C, typename std::enable_if<std::is_integral<typename C::value_type>::value, int>::type = 0>
-inline int64_t multiply_integers(const C &container){
-    //std::accumulate infers return type from `init` type, so if the `init` type is not large
-    //enough to hold the result, computation can overflow. We use `int64_t` here to avoid this.
-    return std::accumulate(container.begin(), container.end(), static_cast<int64_t>(1), std::multiplies<int64_t>());
+/// Product of a list of integers; accumulates into the int64_t datatype
+template <
+    typename C,
+    typename std::enable_if<
+        std::is_integral<typename C::value_type>::value,
+        int>::type = 0>
+inline int64_t multiply_integers(const C& container) {
+  // std::accumulate infers return type from `init` type, so if the `init` type
+  // is not large enough to hold the result, computation can overflow. We use
+  // `int64_t` here to avoid this.
+  return std::accumulate(
+      container.begin(),
+      container.end(),
+      static_cast<int64_t>(1),
+      std::multiplies<int64_t>());
 }
 
-///Product of integer elements referred to by iterators; accumulates into the int64_t datatype
-template<typename Iter,
-typename std::enable_if<std::is_integral<typename std::iterator_traits<Iter>::value_type>::value, int>::type = 0>
-inline int64_t multiply_integers(Iter begin, Iter end){
-    //std::accumulate infers return type from `init` type, so if the `init` type is not large
-    //enough to hold the result, computation can overflow. We use `int64_t` here to avoid this.
-    return std::accumulate(begin, end, static_cast<int64_t>(1), std::multiplies<int64_t>());
+/// Product of integer elements referred to by iterators; accumulates into the
+/// int64_t datatype
+template <
+    typename Iter,
+    typename std::enable_if<
+        std::is_integral<
+            typename std::iterator_traits<Iter>::value_type>::value,
+        int>::type = 0>
+inline int64_t multiply_integers(Iter begin, Iter end) {
+  // std::accumulate infers return type from `init` type, so if the `init` type
+  // is not large enough to hold the result, computation can overflow. We use
+  // `int64_t` here to avoid this.
+  return std::accumulate(
+      begin, end, static_cast<int64_t>(1), std::multiplies<int64_t>());
 }
 
-///Return product of all dimensions starting from k
-///Returns 1 if k>=dims.size()
-template<typename C, typename std::enable_if<std::is_integral<typename C::value_type>::value, int>::type = 0>
-inline int64_t numelements_from_dim(const int k, const C &dims) {
-  TORCH_INTERNAL_ASSERT_DEBUG_ONLY(k>=0);
+/// Return product of all dimensions starting from k
+/// Returns 1 if k>=dims.size()
+template <
+    typename C,
+    typename std::enable_if<
+        std::is_integral<typename C::value_type>::value,
+        int>::type = 0>
+inline int64_t numelements_from_dim(const int k, const C& dims) {
+  TORCH_INTERNAL_ASSERT_DEBUG_ONLY(k >= 0);
 
-  if(k>dims.size()){
-      return 1;
+  if (k > dims.size()) {
+    return 1;
   } else {
-      auto cbegin = dims.cbegin();
-      std::advance(cbegin, k);
-      return multiply_integers(cbegin, dims.cend());
+    auto cbegin = dims.cbegin();
+    std::advance(cbegin, k);
+    return multiply_integers(cbegin, dims.cend());
   }
 }
 
-///Product of all dims up to k (not including dims[k])
-///Throws an error if k>dims.size()
-template<typename C, typename std::enable_if<std::is_integral<typename C::value_type>::value, int>::type = 0>
-inline int64_t numelements_to_dim(const int k, const C &dims) {
-  TORCH_INTERNAL_ASSERT(0<=k);
+/// Product of all dims up to k (not including dims[k])
+/// Throws an error if k>dims.size()
+template <
+    typename C,
+    typename std::enable_if<
+        std::is_integral<typename C::value_type>::value,
+        int>::type = 0>
+inline int64_t numelements_to_dim(const int k, const C& dims) {
+  TORCH_INTERNAL_ASSERT(0 <= k);
   TORCH_INTERNAL_ASSERT((unsigned)k <= dims.size());
 
   auto cend = dims.cbegin();
@@ -71,15 +107,19 @@ inline int64_t numelements_to_dim(const int k, const C &dims) {
   return multiply_integers(dims.cbegin(), cend);
 }
 
-///Product of all dims between k and l (including dims[k] and excluding dims[l])
-///k and l may be supplied in either order
-template<typename C, typename std::enable_if<std::is_integral<typename C::value_type>::value, int>::type = 0>
-inline int64_t numelements_between_dim(int k, int l, const C &dims) {
-  TORCH_INTERNAL_ASSERT(0<=k);
-  TORCH_INTERNAL_ASSERT(0<=l);
+/// Product of all dims between k and l (including dims[k] and excluding
+/// dims[l]) k and l may be supplied in either order
+template <
+    typename C,
+    typename std::enable_if<
+        std::is_integral<typename C::value_type>::value,
+        int>::type = 0>
+inline int64_t numelements_between_dim(int k, int l, const C& dims) {
+  TORCH_INTERNAL_ASSERT(0 <= k);
+  TORCH_INTERNAL_ASSERT(0 <= l);
 
-  if(k>l){
-      std::swap(k,l);
+  if (k > l) {
+    std::swap(k, l);
   }
 
   TORCH_INTERNAL_ASSERT((unsigned)l < dims.size());
@@ -91,4 +131,4 @@ inline int64_t numelements_between_dim(int k, int l, const C &dims) {
   return multiply_integers(cbegin, cend);
 }
 
-} // namespace facebook::detail
+} // namespace c10
diff --git a/c10/util/complex.h b/c10/util/complex.h
index 3bc0b932b0d..2a565f8f2bf 100644
--- a/c10/util/complex.h
+++ b/c10/util/complex.h
@@ -18,9 +18,10 @@ namespace c10 {
 // Reference: https://en.cppreference.com/w/cpp/numeric/complex
 //
 // [NOTE: Complex Operator Unification]
-// Operators currently use a mix of std::complex, thrust::complex, and c10::complex internally.
-// The end state is that all operators will use c10::complex internally.  Until then, there may
-// be some hacks to support all variants.
+// Operators currently use a mix of std::complex, thrust::complex, and
+// c10::complex internally. The end state is that all operators will use
+// c10::complex internally.  Until then, there may be some hacks to support all
+// variants.
 //
 //
 // [Note on Constructors]
@@ -37,7 +38,8 @@ namespace c10 {
 // - converting constructors
 //
 // Converting constructors:
-// - std::complex defines converting constructor between float/double/long double,
+// - std::complex defines converting constructor between float/double/long
+// double,
 //   while we define converting constructor between float/double.
 // - For these converting constructors, upcasting is implicit, downcasting is
 //   explicit.
@@ -57,41 +59,50 @@ namespace c10 {
 // There are three types of assign operator:
 // - Assign a real value from the same scalar type
 //   - In std, this is templated as complex& operator=(const T& x)
-//     with specialization `complex& operator=(T x)` for float/double/long double
-//     Since we only support float and double, on will use `complex& operator=(T x)`
+//     with specialization `complex& operator=(T x)` for float/double/long
+//     double Since we only support float and double, on will use `complex&
+//     operator=(T x)`
 // - Copy assignment operator and converting assignment operator
-//   - There is no specialization of converting assignment operators, which type is
+//   - There is no specialization of converting assignment operators, which type
+//   is
 //     convertible is solely dependent on whether the scalar type is convertible
 //
-// In addition to the standard assignment, we also provide assignment operators with std and thrust
+// In addition to the standard assignment, we also provide assignment operators
+// with std and thrust
 //
 //
 // [Casting operators]
 //
-// std::complex does not have casting operators. We define casting operators casting to std::complex and thrust::complex
+// std::complex does not have casting operators. We define casting operators
+// casting to std::complex and thrust::complex
 //
 //
 // [Operator ""]
 //
-// std::complex has custom literals `i`, `if` and `il` defined in namespace `std::literals::complex_literals`.
-// We define our own custom literals in the namespace `c10::complex_literals`. Our custom literals does not
-// follow the same behavior as in std::complex, instead, we define _if, _id to construct float/double
-// complex literals.
+// std::complex has custom literals `i`, `if` and `il` defined in namespace
+// `std::literals::complex_literals`. We define our own custom literals in the
+// namespace `c10::complex_literals`. Our custom literals does not follow the
+// same behavior as in std::complex, instead, we define _if, _id to construct
+// float/double complex literals.
 //
 //
 // [real() and imag()]
 //
-// In C++20, there are two overload of these functions, one it to return the real/imag, another is to set real/imag,
-// they are both constexpr. We follow this design.
+// In C++20, there are two overload of these functions, one it to return the
+// real/imag, another is to set real/imag, they are both constexpr. We follow
+// this design.
 //
 //
 // [Operator +=,-=,*=,/=]
 //
-// Since C++20, these operators become constexpr. In our implementation, they are also constexpr.
+// Since C++20, these operators become constexpr. In our implementation, they
+// are also constexpr.
 //
-// There are two types of such operators: operating with a real number, or operating with another complex number.
-// For the operating with a real number, the generic template form has argument type `const T &`, while the overload
-// for float/double/long double has `T`. We will follow the same type as float/double/long double in std.
+// There are two types of such operators: operating with a real number, or
+// operating with another complex number. For the operating with a real number,
+// the generic template form has argument type `const T &`, while the overload
+// for float/double/long double has `T`. We will follow the same type as
+// float/double/long double in std.
 //
 // [Unary operator +-]
 //
@@ -119,11 +130,12 @@ namespace c10 {
 //
 //
 //
-// TODO(@zasdfgbnm): c10::complex<c10::Half> is not currently supported, because:
+// TODO(@zasdfgbnm): c10::complex<c10::Half> is not currently supported,
+// because:
 //  - lots of members and functions of c10::Half are not constexpr
 //  - thrust::complex only support float and double
 
-template<typename T>
+template <typename T>
 struct alignas(sizeof(T) * 2) complex {
   using value_type = T;
 
@@ -131,75 +143,84 @@ struct alignas(sizeof(T) * 2) complex {
   T imag_ = T(0);
 
   constexpr complex() = default;
-  C10_HOST_DEVICE constexpr complex(const T& re, const T& im = T()): real_(re), imag_(im) {}
-  template<typename U>
-  explicit constexpr complex(const std::complex<U> &other): complex(other.real(), other.imag()) {}
+  C10_HOST_DEVICE constexpr complex(const T& re, const T& im = T())
+      : real_(re), imag_(im) {}
+  template <typename U>
+  explicit constexpr complex(const std::complex<U>& other)
+      : complex(other.real(), other.imag()) {}
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  template<typename U>
-  explicit C10_HOST_DEVICE complex(const thrust::complex<U> &other): real_(other.real()), imag_(other.imag()) {}
+  template <typename U>
+  explicit C10_HOST_DEVICE complex(const thrust::complex<U>& other)
+      : real_(other.real()), imag_(other.imag()) {}
 // NOTE can not be implemented as follow due to ROCm bug:
-//   explicit C10_HOST_DEVICE complex(const thrust::complex<U> &other): complex(other.real(), other.imag()) {}
+//   explicit C10_HOST_DEVICE complex(const thrust::complex<U> &other):
+//   complex(other.real(), other.imag()) {}
 #endif
 
-  // Use SFINAE to specialize casting constructor for c10::complex<float> and c10::complex<double>
-  template<typename U = T>
-  C10_HOST_DEVICE explicit constexpr complex(const std::enable_if_t<std::is_same<U, float>::value, complex<double>> &other):
-    real_(other.real_), imag_(other.imag_) {}
-  template<typename U = T>
-  C10_HOST_DEVICE constexpr complex(const std::enable_if_t<std::is_same<U, double>::value, complex<float>> &other):
-    real_(other.real_), imag_(other.imag_) {}
+  // Use SFINAE to specialize casting constructor for c10::complex<float> and
+  // c10::complex<double>
+  template <typename U = T>
+  C10_HOST_DEVICE explicit constexpr complex(
+      const std::enable_if_t<std::is_same<U, float>::value, complex<double>>&
+          other)
+      : real_(other.real_), imag_(other.imag_) {}
+  template <typename U = T>
+  C10_HOST_DEVICE constexpr complex(
+      const std::enable_if_t<std::is_same<U, double>::value, complex<float>>&
+          other)
+      : real_(other.real_), imag_(other.imag_) {}
 
-  constexpr complex<T> &operator =(T re) {
+  constexpr complex<T>& operator=(T re) {
     real_ = re;
     imag_ = 0;
     return *this;
   }
 
-  constexpr complex<T> &operator +=(T re) {
+  constexpr complex<T>& operator+=(T re) {
     real_ += re;
     return *this;
   }
 
-  constexpr complex<T> &operator -=(T re) {
+  constexpr complex<T>& operator-=(T re) {
     real_ -= re;
     return *this;
   }
 
-  constexpr complex<T> &operator *=(T re) {
+  constexpr complex<T>& operator*=(T re) {
     real_ *= re;
     imag_ *= re;
     return *this;
   }
 
-  constexpr complex<T> &operator /=(T re) {
+  constexpr complex<T>& operator/=(T re) {
     real_ /= re;
     imag_ /= re;
     return *this;
   }
 
-  template<typename U>
-  constexpr complex<T> &operator =(const complex<U> &rhs) {
+  template <typename U>
+  constexpr complex<T>& operator=(const complex<U>& rhs) {
     real_ = rhs.real();
     imag_ = rhs.imag();
     return *this;
   }
 
-  template<typename U>
-  constexpr complex<T> &operator +=(const complex<U> &rhs) {
+  template <typename U>
+  constexpr complex<T>& operator+=(const complex<U>& rhs) {
     real_ += rhs.real();
     imag_ += rhs.imag();
     return *this;
   }
 
-  template<typename U>
-  constexpr complex<T> &operator -=(const complex<U> &rhs) {
+  template <typename U>
+  constexpr complex<T>& operator-=(const complex<U>& rhs) {
     real_ -= rhs.real();
     imag_ -= rhs.imag();
     return *this;
   }
 
-  template<typename U>
-  constexpr complex<T> &operator *=(const complex<U> &rhs) {
+  template <typename U>
+  constexpr complex<T>& operator*=(const complex<U>& rhs) {
     // (a + bi) * (c + di) = (a*c - b*d) + (a * d + b * c) i
     T a = real_;
     T b = imag_;
@@ -215,8 +236,9 @@ struct alignas(sizeof(T) * 2) complex {
 #else
 #define FORCE_INLINE_APPLE
 #endif
-  template<typename U>
-  constexpr FORCE_INLINE_APPLE complex<T> &operator /=(const complex<U> &rhs) __ubsan_ignore_float_divide_by_zero__ {
+  template <typename U>
+  constexpr FORCE_INLINE_APPLE complex<T>& operator/=(const complex<U>& rhs)
+      __ubsan_ignore_float_divide_by_zero__ {
     // (a + bi) / (c + di) = (ac + bd)/(c^2 + d^2) + (bc - ad)/(c^2 + d^2) i
     T a = real_;
     T b = imag_;
@@ -229,29 +251,29 @@ struct alignas(sizeof(T) * 2) complex {
   }
 #undef FORCE_INLINE_APPLE
 
-  template<typename U>
-  constexpr complex<T> &operator =(const std::complex<U> &rhs) {
+  template <typename U>
+  constexpr complex<T>& operator=(const std::complex<U>& rhs) {
     real_ = rhs.real();
     imag_ = rhs.imag();
     return *this;
   }
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  template<typename U>
-  C10_HOST_DEVICE complex<T> &operator =(const thrust::complex<U> &rhs) {
+  template <typename U>
+  C10_HOST_DEVICE complex<T>& operator=(const thrust::complex<U>& rhs) {
     real_ = rhs.real();
     imag_ = rhs.imag();
     return *this;
   }
 #endif
 
-  template<typename U>
+  template <typename U>
   explicit constexpr operator std::complex<U>() const {
     return std::complex<U>(std::complex<T>(real(), imag()));
   }
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  template<typename U>
+  template <typename U>
   C10_HOST_DEVICE explicit operator thrust::complex<U>() const {
     return static_cast<thrust::complex<U>>(thrust::complex<T>(real(), imag()));
   }
@@ -296,175 +318,179 @@ constexpr complex<double> operator"" _id(unsigned long long imag) {
 
 } // namespace complex_literals
 
-
-template<typename T>
+template <typename T>
 constexpr complex<T> operator+(const complex<T>& val) {
   return val;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator-(const complex<T>& val) {
   return complex<T>(-val.real(), -val.imag());
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs) {
   complex<T> result = lhs;
   return result += rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator+(const complex<T>& lhs, const T& rhs) {
   complex<T> result = lhs;
   return result += rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator+(const T& lhs, const complex<T>& rhs) {
   return complex<T>(lhs + rhs.real(), rhs.imag());
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs) {
   complex<T> result = lhs;
   return result -= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator-(const complex<T>& lhs, const T& rhs) {
   complex<T> result = lhs;
   return result -= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator-(const T& lhs, const complex<T>& rhs) {
   complex<T> result = -rhs;
   return result += lhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs) {
   complex<T> result = lhs;
   return result *= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator*(const complex<T>& lhs, const T& rhs) {
   complex<T> result = lhs;
   return result *= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator*(const T& lhs, const complex<T>& rhs) {
   complex<T> result = rhs;
   return result *= lhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs) {
   complex<T> result = lhs;
   return result /= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator/(const complex<T>& lhs, const T& rhs) {
   complex<T> result = lhs;
   return result /= rhs;
 }
 
-template<typename T>
+template <typename T>
 constexpr complex<T> operator/(const T& lhs, const complex<T>& rhs) {
   complex<T> result(lhs, T());
   return result /= rhs;
 }
 
+// Define operators between integral scalars and c10::complex. std::complex does
+// not support this when T is a floating-point number. This is useful because it
+// saves a lot of "static_cast" when operate a complex and an integer. This
+// makes the code both less verbose and potentially more efficient.
+#define COMPLEX_INTEGER_OP_TEMPLATE_CONDITION                           \
+  typename std::enable_if_t<                                            \
+      std::is_floating_point<fT>::value && std::is_integral<iT>::value, \
+      int> = 0
 
-// Define operators between integral scalars and c10::complex. std::complex does not support this when T is a
-// floating-point number. This is useful because it saves a lot of "static_cast" when operate a complex and an integer.
-// This makes the code both less verbose and potentially more efficient.
-#define COMPLEX_INTEGER_OP_TEMPLATE_CONDITION \
-  typename std::enable_if_t<std::is_floating_point<fT>::value && std::is_integral<iT>::value, int> = 0
-
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator+(const c10::complex<fT>& a, const iT& b) {
   return a + static_cast<fT>(b);
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator+(const iT& a, const c10::complex<fT>& b) {
   return static_cast<fT>(a) + b;
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator-(const c10::complex<fT>& a, const iT& b) {
   return a - static_cast<fT>(b);
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator-(const iT& a, const c10::complex<fT>& b) {
   return static_cast<fT>(a) - b;
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator*(const c10::complex<fT>& a, const iT& b) {
   return a * static_cast<fT>(b);
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator*(const iT& a, const c10::complex<fT>& b) {
   return static_cast<fT>(a) * b;
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator/(const c10::complex<fT>& a, const iT& b) {
   return a / static_cast<fT>(b);
 }
 
-template<typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
+template <typename fT, typename iT, COMPLEX_INTEGER_OP_TEMPLATE_CONDITION>
 constexpr c10::complex<fT> operator/(const iT& a, const c10::complex<fT>& b) {
   return static_cast<fT>(a) / b;
 }
 
 #undef COMPLEX_INTEGER_OP_TEMPLATE_CONDITION
 
-
-template<typename T>
+template <typename T>
 constexpr bool operator==(const complex<T>& lhs, const complex<T>& rhs) {
   return (lhs.real() == rhs.real()) && (lhs.imag() == rhs.imag());
 }
 
-template<typename T>
+template <typename T>
 constexpr bool operator==(const complex<T>& lhs, const T& rhs) {
   return (lhs.real() == rhs) && (lhs.imag() == T());
 }
 
-template<typename T>
+template <typename T>
 constexpr bool operator==(const T& lhs, const complex<T>& rhs) {
   return (lhs == rhs.real()) && (T() == rhs.imag());
 }
 
-template<typename T>
+template <typename T>
 constexpr bool operator!=(const complex<T>& lhs, const complex<T>& rhs) {
   return !(lhs == rhs);
 }
 
-template<typename T>
+template <typename T>
 constexpr bool operator!=(const complex<T>& lhs, const T& rhs) {
   return !(lhs == rhs);
 }
 
-template<typename T>
+template <typename T>
 constexpr bool operator!=(const T& lhs, const complex<T>& rhs) {
   return !(lhs == rhs);
 }
 
 template <typename T, typename CharT, typename Traits>
-std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const complex<T>& x) {
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,
+    const complex<T>& x) {
   return (os << static_cast<std::complex<T>>(x));
 }
 
 template <typename T, typename CharT, typename Traits>
-std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, complex<T>& x) {
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,
+    complex<T>& x) {
   std::complex<T> tmp;
   is >> tmp;
   x = tmp;
@@ -479,35 +505,38 @@ std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>&
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
 namespace c10_internal {
-  template<typename T>
-  C10_HOST_DEVICE constexpr thrust::complex<T> cuda101bug_cast_c10_complex_to_thrust_complex(const c10::complex<T>& x) {
+template <typename T>
+C10_HOST_DEVICE constexpr thrust::complex<T>
+cuda101bug_cast_c10_complex_to_thrust_complex(const c10::complex<T>& x) {
 #if defined(CUDA_VERSION) && (CUDA_VERSION < 10200)
-    // This is to circumvent a CUDA compilation bug. See https://github.com/pytorch/pytorch/pull/38941 .
-    // When the bug is fixed, we should do static_cast directly.
-    return thrust::complex<T>(x.real(), x.imag());
+  // This is to circumvent a CUDA compilation bug. See
+  // https://github.com/pytorch/pytorch/pull/38941 . When the bug is fixed, we
+  // should do static_cast directly.
+  return thrust::complex<T>(x.real(), x.imag());
 #else
-    return static_cast<thrust::complex<T>>(x);
+  return static_cast<thrust::complex<T>>(x);
 #endif
-  }
+}
 } // namespace c10_internal
 #endif
 
 namespace std {
 
-template<typename T>
+template <typename T>
 constexpr T real(const c10::complex<T>& z) {
   return z.real();
 }
 
-template<typename T>
+template <typename T>
 constexpr T imag(const c10::complex<T>& z) {
   return z.imag();
 }
 
-template<typename T>
+template <typename T>
 C10_HOST_DEVICE T abs(const c10::complex<T>& z) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return thrust::abs(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(z));
+  return thrust::abs(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(z));
 #else
   return std::abs(static_cast<std::complex<T>>(z));
 #endif
@@ -519,14 +548,14 @@ C10_HOST_DEVICE T abs(const c10::complex<T>& z) {
 #define ROCm_Bug(x) x
 #endif
 
-template<typename T>
+template <typename T>
 C10_HOST_DEVICE T arg(const c10::complex<T>& z) {
   return ROCm_Bug(std)::atan2(std::imag(z), std::real(z));
 }
 
 #undef ROCm_Bug
 
-template<typename T>
+template <typename T>
 constexpr T norm(const c10::complex<T>& z) {
   return z.real() * z.real() + z.imag() * z.imag();
 }
@@ -538,7 +567,7 @@ constexpr T norm(const c10::complex<T>& z) {
 //   constexpr std::complex<long double> conj( long double z );
 // These are not implemented
 // TODO(@zasdfgbnm): implement them as c10::conj
-template<typename T>
+template <typename T>
 constexpr c10::complex<T> conj(const c10::complex<T>& z) {
   return c10::complex<T>(z.real(), -z.imag());
 }
@@ -554,7 +583,7 @@ constexpr c10::complex<T> conj(const c10::complex<T>& z) {
 
 namespace c10 {
 
-template<typename T>
+template <typename T>
 C10_HOST_DEVICE complex<T> polar(const T& r, const T& theta = T()) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
   return static_cast<complex<T>>(thrust::polar(r, theta));
diff --git a/c10/util/complex_math.cpp b/c10/util/complex_math.cpp
index 9653dce36c5..4029133c33b 100644
--- a/c10/util/complex_math.cpp
+++ b/c10/util/complex_math.cpp
@@ -13,7 +13,8 @@
 // In libstdc++ complex square root yield invalid results
 // for -x-0.0j unless C99 csqrt/csqrtf fallbacks are used
 
-#if defined(_LIBCPP_VERSION) || (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
+#if defined(_LIBCPP_VERSION) || \
+    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
 
 namespace {
 template <typename T>
@@ -21,9 +22,10 @@ c10::complex<T> compute_csqrt(const c10::complex<T>& z) {
   constexpr auto half = T(.5);
 
   // Trust standard library to correctly handle infs and NaNs
-  if (std::isinf(z.real()) || std::isinf(z.imag()) ||
-      std::isnan(z.real()) || std::isnan(z.imag())) {
-    return static_cast<c10::complex<T>>(std::sqrt(static_cast<std::complex<T>>(z)));
+  if (std::isinf(z.real()) || std::isinf(z.imag()) || std::isnan(z.real()) ||
+      std::isnan(z.imag())) {
+    return static_cast<c10::complex<T>>(
+        std::sqrt(static_cast<std::complex<T>>(z)));
   }
 
   // Special case for square root of pure imaginary values
@@ -42,10 +44,10 @@ c10::complex<T> compute_csqrt(const c10::complex<T>& z) {
   }
 
   auto t = std::sqrt((-z.real() + std::abs(z)) * half);
-  return c10::complex<T>(half * std::abs(z.imag() / t), std::copysign(t, z.imag()));
+  return c10::complex<T>(
+      half * std::abs(z.imag() / t), std::copysign(t, z.imag()));
 }
 
-
 // Compute complex arccosine using formula from W. Kahan
 // "Branch Cuts for Complex Elementary Functions" 1986 paper:
 // cacos(z).re = 2*atan2(sqrt(1-z).re(), sqrt(1+z).re())
@@ -54,12 +56,13 @@ template <typename T>
 c10::complex<T> compute_cacos(const c10::complex<T>& z) {
   auto constexpr one = T(1);
   // Trust standard library to correctly handle infs and NaNs
-  if (std::isinf(z.real()) || std::isinf(z.imag()) ||
-      std::isnan(z.real()) || std::isnan(z.imag())) {
-    return static_cast<c10::complex<T>>(std::acos(static_cast<std::complex<T>>(z)));
+  if (std::isinf(z.real()) || std::isinf(z.imag()) || std::isnan(z.real()) ||
+      std::isnan(z.imag())) {
+    return static_cast<c10::complex<T>>(
+        std::acos(static_cast<std::complex<T>>(z)));
   }
   auto a = compute_csqrt(c10::complex<T>(one - z.real(), -z.imag()));
-  auto b = compute_csqrt(c10::complex<T>(one + z.real(),  z.imag()));
+  auto b = compute_csqrt(c10::complex<T>(one + z.real(), z.imag()));
   auto c = compute_csqrt(c10::complex<T>(one + z.real(), -z.imag()));
   auto r = T(2) * std::atan2(a.real(), b.real());
   // Explicitly unroll (a*c).imag()
@@ -68,8 +71,8 @@ c10::complex<T> compute_cacos(const c10::complex<T>& z) {
 }
 } // anonymous namespace
 
-
-namespace c10_complex_math { namespace _detail {
+namespace c10_complex_math {
+namespace _detail {
 c10::complex<float> sqrt(const c10::complex<float>& in) {
   return compute_csqrt(in);
 }
@@ -86,5 +89,6 @@ c10::complex<double> acos(const c10::complex<double>& in) {
   return compute_cacos(in);
 }
 
-}} // namespace c10_complex_math::_detail
+} // namespace _detail
+} // namespace c10_complex_math
 #endif
diff --git a/c10/util/complex_math.h b/c10/util/complex_math.h
index 25dbdf9fbfe..ecfd0442b75 100644
--- a/c10/util/complex_math.h
+++ b/c10/util/complex_math.h
@@ -1,277 +1,336 @@
 #if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H)
-#error "c10/util/complex_math.h is not meant to be individually included. Include c10/util/complex.h instead."
+#error \
+    "c10/util/complex_math.h is not meant to be individually included. Include c10/util/complex.h instead."
 #endif
 
-
 namespace c10_complex_math {
 
 // Exponential functions
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> exp(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> exp(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::exp(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::exp(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::exp(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::exp(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> log(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> log(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::log(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::log(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::log(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::log(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> log10(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> log10(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::log10(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::log10(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::log10(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::log10(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> log2(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> log2(const c10::complex<T>& x) {
   const c10::complex<T> log2 = c10::complex<T>(::log(2.0), 0.0);
   return c10_complex_math::log(x) / log2;
 }
 
 // Power functions
 //
-#if defined(_LIBCPP_VERSION) || (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
+#if defined(_LIBCPP_VERSION) || \
+    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX))
 namespace _detail {
 TORCH_API c10::complex<float> sqrt(const c10::complex<float>& in);
 TORCH_API c10::complex<double> sqrt(const c10::complex<double>& in);
 TORCH_API c10::complex<float> acos(const c10::complex<float>& in);
 TORCH_API c10::complex<double> acos(const c10::complex<double>& in);
-};
+}; // namespace _detail
 #endif
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> sqrt(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> sqrt(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::sqrt(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
-#elif !(defined(_LIBCPP_VERSION) || (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX)))
-  return static_cast<c10::complex<T>>(std::sqrt(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(thrust::sqrt(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+#elif !(                        \
+    defined(_LIBCPP_VERSION) || \
+    (defined(__GLIBCXX__) && !defined(_GLIBCXX11_USE_C99_COMPLEX)))
+  return static_cast<c10::complex<T>>(
+      std::sqrt(static_cast<std::complex<T>>(x)));
 #else
   return _detail::sqrt(x);
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const c10::complex<T> &x, const c10::complex<T> &y) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> pow(
+    const c10::complex<T>& x,
+    const c10::complex<T>& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
-                                                  c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
 #else
-  return static_cast<c10::complex<T>>(std::pow(static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
+  return static_cast<c10::complex<T>>(std::pow(
+      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const c10::complex<T> &x, const T &y) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> pow(
+    const c10::complex<T>& x,
+    const T& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
 #else
-  return static_cast<c10::complex<T>>(std::pow(static_cast<std::complex<T>>(x), y));
+  return static_cast<c10::complex<T>>(
+      std::pow(static_cast<std::complex<T>>(x), y));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> pow(const T &x, const c10::complex<T> &y) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> pow(
+    const T& x,
+    const c10::complex<T>& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
 #else
-  return static_cast<c10::complex<T>>(std::pow(x, static_cast<std::complex<T>>(y)));
+  return static_cast<c10::complex<T>>(
+      std::pow(x, static_cast<std::complex<T>>(y)));
 #endif
 }
 
-template<typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(const c10::complex<T> &x, const c10::complex<U> &y) {
+template <typename T, typename U>
+C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
+    const c10::complex<T>& x,
+    const c10::complex<U>& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
-                                                  c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x),
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
 #else
-  return static_cast<c10::complex<T>>(std::pow(static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
+  return static_cast<c10::complex<T>>(std::pow(
+      static_cast<std::complex<T>>(x), static_cast<std::complex<T>>(y)));
 #endif
 }
 
-template<typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(const c10::complex<T> &x, const U &y) {
+template <typename T, typename U>
+C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
+    const c10::complex<T>& x,
+    const U& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x), y));
 #else
-  return static_cast<c10::complex<T>>(std::pow(static_cast<std::complex<T>>(x), y));
+  return static_cast<c10::complex<T>>(
+      std::pow(static_cast<std::complex<T>>(x), y));
 #endif
 }
 
-template<typename T, typename U>
-C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(const T &x, const c10::complex<U> &y) {
+template <typename T, typename U>
+C10_HOST_DEVICE inline c10::complex<decltype(T() * U())> pow(
+    const T& x,
+    const c10::complex<U>& y) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::pow(x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
+  return static_cast<c10::complex<T>>(thrust::pow(
+      x, c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(y)));
 #else
-  return static_cast<c10::complex<T>>(std::pow(x, static_cast<std::complex<T>>(y)));
+  return static_cast<c10::complex<T>>(
+      std::pow(x, static_cast<std::complex<T>>(y)));
 #endif
 }
 
 // Trigonometric functions
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> sin(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> sin(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::sin(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::sin(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::sin(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::sin(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> cos(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> cos(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::cos(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::cos(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::cos(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::cos(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> tan(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> tan(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::tan(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::tan(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::tan(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::tan(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> asin(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> asin(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::asin(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::asin(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::asin(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::asin(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> acos(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> acos(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::acos(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::acos(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #elif !defined(_LIBCPP_VERSION)
-  return static_cast<c10::complex<T>>(std::acos(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::acos(static_cast<std::complex<T>>(x)));
 #else
   return _detail::acos(x);
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> atan(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> atan(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::atan(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::atan(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::atan(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::atan(static_cast<std::complex<T>>(x)));
 #endif
 }
 
 // Hyperbolic functions
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> sinh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> sinh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::sinh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::sinh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::sinh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::sinh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> cosh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> cosh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::cosh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::cosh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::cosh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::cosh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> tanh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> tanh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::tanh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::tanh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::tanh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::tanh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> asinh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> asinh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::asinh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::asinh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::asinh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::asinh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> acosh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> acosh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::acosh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::acosh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::acosh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::acosh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-template<typename T>
-C10_HOST_DEVICE inline c10::complex<T> atanh(const c10::complex<T> &x) {
+template <typename T>
+C10_HOST_DEVICE inline c10::complex<T> atanh(const c10::complex<T>& x) {
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  return static_cast<c10::complex<T>>(thrust::atanh(c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
+  return static_cast<c10::complex<T>>(thrust::atanh(
+      c10_internal::cuda101bug_cast_c10_complex_to_thrust_complex(x)));
 #else
-  return static_cast<c10::complex<T>>(std::atanh(static_cast<std::complex<T>>(x)));
+  return static_cast<c10::complex<T>>(
+      std::atanh(static_cast<std::complex<T>>(x)));
 #endif
 }
 
-}  // namespace c10_complex_math
+} // namespace c10_complex_math
 
+using c10_complex_math::acos;
+using c10_complex_math::acosh;
+using c10_complex_math::asin;
+using c10_complex_math::asinh;
+using c10_complex_math::atan;
+using c10_complex_math::atanh;
+using c10_complex_math::cos;
+using c10_complex_math::cosh;
 using c10_complex_math::exp;
 using c10_complex_math::log;
 using c10_complex_math::log10;
 using c10_complex_math::log2;
-using c10_complex_math::sqrt;
 using c10_complex_math::pow;
 using c10_complex_math::sin;
-using c10_complex_math::cos;
-using c10_complex_math::tan;
-using c10_complex_math::asin;
-using c10_complex_math::acos;
-using c10_complex_math::atan;
 using c10_complex_math::sinh;
-using c10_complex_math::cosh;
+using c10_complex_math::sqrt;
+using c10_complex_math::tan;
 using c10_complex_math::tanh;
-using c10_complex_math::asinh;
-using c10_complex_math::acosh;
-using c10_complex_math::atanh;
 
 namespace std {
 
+using c10_complex_math::acos;
+using c10_complex_math::acosh;
+using c10_complex_math::asin;
+using c10_complex_math::asinh;
+using c10_complex_math::atan;
+using c10_complex_math::atanh;
+using c10_complex_math::cos;
+using c10_complex_math::cosh;
 using c10_complex_math::exp;
 using c10_complex_math::log;
 using c10_complex_math::log10;
 using c10_complex_math::log2;
-using c10_complex_math::sqrt;
 using c10_complex_math::pow;
 using c10_complex_math::sin;
-using c10_complex_math::cos;
-using c10_complex_math::tan;
-using c10_complex_math::asin;
-using c10_complex_math::acos;
-using c10_complex_math::atan;
 using c10_complex_math::sinh;
-using c10_complex_math::cosh;
+using c10_complex_math::sqrt;
+using c10_complex_math::tan;
 using c10_complex_math::tanh;
-using c10_complex_math::asinh;
-using c10_complex_math::acosh;
-using c10_complex_math::atanh;
 
-}
+} // namespace std
diff --git a/c10/util/complex_utils.h b/c10/util/complex_utils.h
index 81ae7568dde..a28f0bd487f 100644
--- a/c10/util/complex_utils.h
+++ b/c10/util/complex_utils.h
@@ -1,10 +1,10 @@
 #if !defined(C10_INTERNAL_INCLUDE_COMPLEX_REMAINING_H)
-#error "c10/util/complex_utils.h is not meant to be individually included. Include c10/util/complex.h instead."
+#error \
+    "c10/util/complex_utils.h is not meant to be individually included. Include c10/util/complex.h instead."
 #endif
 
 #include <limits>
 
-
 namespace c10 {
 
 template <typename T>
@@ -16,7 +16,6 @@ struct is_complex<std::complex<T>> : public std::true_type {};
 template <typename T>
 struct is_complex<c10::complex<T>> : public std::true_type {};
 
-
 // Extract double from std::complex<double>; is identity otherwise
 // TODO: Write in more idiomatic C++17
 template <typename T>
@@ -32,11 +31,11 @@ struct scalar_value_type<c10::complex<T>> {
   using type = T;
 };
 
-}
+} // namespace c10
 
 namespace std {
 
 template <typename T>
-class numeric_limits<c10::complex<T>> : public numeric_limits<T>  {};
+class numeric_limits<c10::complex<T>> : public numeric_limits<T> {};
 
-}
+} // namespace std
diff --git a/c10/util/copysign.h b/c10/util/copysign.h
index 0a47ecaffb7..1707fc47d3f 100644
--- a/c10/util/copysign.h
+++ b/c10/util/copysign.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <c10/util/Half.h>
 #include <c10/util/BFloat16.h>
+#include <c10/util/Half.h>
 #include <c10/util/math_compat.h>
 
 namespace c10 {
@@ -17,11 +17,12 @@ inline auto copysign(const T& a, const U& b) {
 // Implement copysign for half precision floats using bit ops
 // Sign is the most significant bit for both half and bfloat16 types
 inline c10::Half copysign(c10::Half a, c10::Half b) {
-  return c10::Half((a.x&0x7fff) | (b.x&0x8000), c10::Half::from_bits());
+  return c10::Half((a.x & 0x7fff) | (b.x & 0x8000), c10::Half::from_bits());
 }
 
 inline c10::BFloat16 copysign(c10::BFloat16 a, c10::BFloat16 b) {
-  return c10::BFloat16((a.x&0x7fff) | (b.x&0x8000), c10::BFloat16::from_bits());
+  return c10::BFloat16(
+      (a.x & 0x7fff) | (b.x & 0x8000), c10::BFloat16::from_bits());
 }
 
 } // namespace c10
diff --git a/c10/util/either.h b/c10/util/either.h
index 92747ac040d..da765b9a9bb 100644
--- a/c10/util/either.h
+++ b/c10/util/either.h
@@ -130,8 +130,9 @@ class either final {
     return std::move(right());
   }
 
-  template<class Result, class LeftFoldFunc, class RightFoldFunc>
-  Result fold(LeftFoldFunc&& leftFoldFunc, RightFoldFunc&& rightFoldFunc) const {
+  template <class Result, class LeftFoldFunc, class RightFoldFunc>
+  Result fold(LeftFoldFunc&& leftFoldFunc, RightFoldFunc&& rightFoldFunc)
+      const {
     if (Side::left == _side) {
       return std::forward<LeftFoldFunc>(leftFoldFunc)(_left);
     } else {
diff --git a/c10/util/flags_use_no_gflags.cpp b/c10/util/flags_use_no_gflags.cpp
index a11882bf876..fd8f3dafc0e 100644
--- a/c10/util/flags_use_no_gflags.cpp
+++ b/c10/util/flags_use_no_gflags.cpp
@@ -1,5 +1,5 @@
-#include <c10/util/Flags.h>
 #include <c10/macros/Macros.h>
+#include <c10/util/Flags.h>
 
 #include <cstdlib>
 #include <iostream>
diff --git a/c10/util/flat_hash_map.h b/c10/util/flat_hash_map.h
index c513a61ab48..ddef6b51662 100644
--- a/c10/util/flat_hash_map.h
+++ b/c10/util/flat_hash_map.h
@@ -1,10 +1,12 @@
-// Taken from https://github.com/skarupke/flat_hash_map/blob/2c4687431f978f02a3780e24b8b701d22aa32d9c/flat_hash_map.hpp
+// Taken from
+// https://github.com/skarupke/flat_hash_map/blob/2c4687431f978f02a3780e24b8b701d22aa32d9c/flat_hash_map.hpp
 // with fixes applied:
 // - https://github.com/skarupke/flat_hash_map/pull/25
 // - https://github.com/skarupke/flat_hash_map/pull/26
 // - replace size_t with uint64_t to fix it for 32bit
 // - add "GCC diagnostic" pragma to ignore -Wshadow
-// - make sherwood_v3_table::convertible_to_iterator public because GCC5 seems to have issues with it otherwise
+// - make sherwood_v3_table::convertible_to_iterator public because GCC5 seems
+// to have issues with it otherwise
 // - fix compiler warnings in operator templated_iterator<const value_type>
 
 //          Copyright Malte Skarupke 2017.
@@ -13,15 +15,15 @@
 
 #pragma once
 
-#include <cstdint>
-#include <cstddef>
-#include <functional>
-#include <cmath>
 #include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
 #include <iterator>
-#include <utility>
-#include <type_traits>
 #include <stdexcept>
+#include <type_traits>
+#include <utility>
 
 #ifndef _MSC_VER
 #pragma GCC diagnostic push
@@ -34,1487 +36,2066 @@
 #define SKA_NOINLINE(...) __VA_ARGS__ __attribute__((noinline))
 #endif
 
-namespace ska
-{
+namespace ska {
 struct prime_number_hash_policy;
 struct power_of_two_hash_policy;
 struct fibonacci_hash_policy;
 
-namespace detailv3
-{
-template<typename Result, typename Functor>
-struct functor_storage : Functor
-{
-    functor_storage() = default;
-    functor_storage(const Functor & functor)
-        : Functor(functor)
-    {
-    }
-    template<typename... Args>
-    Result operator()(Args &&... args)
-    {
-        return static_cast<Functor &>(*this)(std::forward<Args>(args)...);
-    }
-    template<typename... Args>
-    Result operator()(Args &&... args) const
-    {
-        return static_cast<const Functor &>(*this)(std::forward<Args>(args)...);
-    }
+namespace detailv3 {
+template <typename Result, typename Functor>
+struct functor_storage : Functor {
+  functor_storage() = default;
+  functor_storage(const Functor& functor) : Functor(functor) {}
+  template <typename... Args>
+  Result operator()(Args&&... args) {
+    return static_cast<Functor&>(*this)(std::forward<Args>(args)...);
+  }
+  template <typename... Args>
+  Result operator()(Args&&... args) const {
+    return static_cast<const Functor&>(*this)(std::forward<Args>(args)...);
+  }
 };
-template<typename Result, typename... Args>
-struct functor_storage<Result, Result (*)(Args...)>
-{
-    typedef Result (*function_ptr)(Args...);
-    function_ptr function;
-    functor_storage(function_ptr function)
-        : function(function)
-    {
-    }
-    Result operator()(Args... args) const
-    {
-        return function(std::forward<Args>(args)...);
-    }
-    operator function_ptr &()
-    {
-        return function;
-    }
-    operator const function_ptr &()
-    {
-        return function;
-    }
+template <typename Result, typename... Args>
+struct functor_storage<Result, Result (*)(Args...)> {
+  typedef Result (*function_ptr)(Args...);
+  function_ptr function;
+  functor_storage(function_ptr function) : function(function) {}
+  Result operator()(Args... args) const {
+    return function(std::forward<Args>(args)...);
+  }
+  operator function_ptr&() {
+    return function;
+  }
+  operator const function_ptr&() {
+    return function;
+  }
 };
-template<typename key_type, typename value_type, typename hasher>
-struct KeyOrValueHasher : functor_storage<uint64_t, hasher>
-{
-    typedef functor_storage<uint64_t, hasher> hasher_storage;
-    KeyOrValueHasher() = default;
-    KeyOrValueHasher(const hasher & hash)
-        : hasher_storage(hash)
-    {
-    }
-    uint64_t operator()(const key_type & key)
-    {
-        return static_cast<hasher_storage &>(*this)(key);
-    }
-    uint64_t operator()(const key_type & key) const
-    {
-        return static_cast<const hasher_storage &>(*this)(key);
-    }
-    uint64_t operator()(const value_type & value)
-    {
-        return static_cast<hasher_storage &>(*this)(value.first);
-    }
-    uint64_t operator()(const value_type & value) const
-    {
-        return static_cast<const hasher_storage &>(*this)(value.first);
-    }
-    template<typename F, typename S>
-    uint64_t operator()(const std::pair<F, S> & value)
-    {
-        return static_cast<hasher_storage &>(*this)(value.first);
-    }
-    template<typename F, typename S>
-    uint64_t operator()(const std::pair<F, S> & value) const
-    {
-        return static_cast<const hasher_storage &>(*this)(value.first);
-    }
+template <typename key_type, typename value_type, typename hasher>
+struct KeyOrValueHasher : functor_storage<uint64_t, hasher> {
+  typedef functor_storage<uint64_t, hasher> hasher_storage;
+  KeyOrValueHasher() = default;
+  KeyOrValueHasher(const hasher& hash) : hasher_storage(hash) {}
+  uint64_t operator()(const key_type& key) {
+    return static_cast<hasher_storage&>(*this)(key);
+  }
+  uint64_t operator()(const key_type& key) const {
+    return static_cast<const hasher_storage&>(*this)(key);
+  }
+  uint64_t operator()(const value_type& value) {
+    return static_cast<hasher_storage&>(*this)(value.first);
+  }
+  uint64_t operator()(const value_type& value) const {
+    return static_cast<const hasher_storage&>(*this)(value.first);
+  }
+  template <typename F, typename S>
+  uint64_t operator()(const std::pair<F, S>& value) {
+    return static_cast<hasher_storage&>(*this)(value.first);
+  }
+  template <typename F, typename S>
+  uint64_t operator()(const std::pair<F, S>& value) const {
+    return static_cast<const hasher_storage&>(*this)(value.first);
+  }
 };
-template<typename key_type, typename value_type, typename key_equal>
-struct KeyOrValueEquality : functor_storage<bool, key_equal>
-{
-    typedef functor_storage<bool, key_equal> equality_storage;
-    KeyOrValueEquality() = default;
-    KeyOrValueEquality(const key_equal & equality)
-        : equality_storage(equality)
-    {
-    }
-    bool operator()(const key_type & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs);
-    }
-    bool operator()(const key_type & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs.first);
-    }
-    bool operator()(const value_type & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs);
-    }
-    bool operator()(const value_type & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const key_type & lhs, const std::pair<F, S> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const std::pair<F, S> & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs);
-    }
-    template<typename F, typename S>
-    bool operator()(const value_type & lhs, const std::pair<F, S> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const std::pair<F, S> & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename FL, typename SL, typename FR, typename SR>
-    bool operator()(const std::pair<FL, SL> & lhs, const std::pair<FR, SR> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
+template <typename key_type, typename value_type, typename key_equal>
+struct KeyOrValueEquality : functor_storage<bool, key_equal> {
+  typedef functor_storage<bool, key_equal> equality_storage;
+  KeyOrValueEquality() = default;
+  KeyOrValueEquality(const key_equal& equality) : equality_storage(equality) {}
+  bool operator()(const key_type& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs);
+  }
+  bool operator()(const key_type& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs.first);
+  }
+  bool operator()(const value_type& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs);
+  }
+  bool operator()(const value_type& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const key_type& lhs, const std::pair<F, S>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const std::pair<F, S>& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs);
+  }
+  template <typename F, typename S>
+  bool operator()(const value_type& lhs, const std::pair<F, S>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const std::pair<F, S>& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename FL, typename SL, typename FR, typename SR>
+  bool operator()(const std::pair<FL, SL>& lhs, const std::pair<FR, SR>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
 };
 static constexpr int8_t min_lookups = 4;
-template<typename T>
-struct sherwood_v3_entry
-{
-    sherwood_v3_entry()
-    {
-    }
-    sherwood_v3_entry(int8_t distance_from_desired)
-        : distance_from_desired(distance_from_desired)
-    {
-    }
-    ~sherwood_v3_entry()
-    {
-    }
+template <typename T>
+struct sherwood_v3_entry {
+  sherwood_v3_entry() {}
+  sherwood_v3_entry(int8_t distance_from_desired)
+      : distance_from_desired(distance_from_desired) {}
+  ~sherwood_v3_entry() {}
 
-    bool has_value() const
-    {
-        return distance_from_desired >= 0;
-    }
-    bool is_empty() const
-    {
-        return distance_from_desired < 0;
-    }
-    bool is_at_desired_position() const
-    {
-        return distance_from_desired <= 0;
-    }
-    template<typename... Args>
-    void emplace(int8_t distance, Args &&... args)
-    {
-        new (std::addressof(value)) T(std::forward<Args>(args)...);
-        distance_from_desired = distance;
-    }
+  bool has_value() const {
+    return distance_from_desired >= 0;
+  }
+  bool is_empty() const {
+    return distance_from_desired < 0;
+  }
+  bool is_at_desired_position() const {
+    return distance_from_desired <= 0;
+  }
+  template <typename... Args>
+  void emplace(int8_t distance, Args&&... args) {
+    new (std::addressof(value)) T(std::forward<Args>(args)...);
+    distance_from_desired = distance;
+  }
 
-    void destroy_value()
-    {
-        value.~T();
-        distance_from_desired = -1;
-    }
+  void destroy_value() {
+    value.~T();
+    distance_from_desired = -1;
+  }
 
-    int8_t distance_from_desired = -1;
-    static constexpr int8_t special_end_value = 0;
-    union { T value; };
+  int8_t distance_from_desired = -1;
+  static constexpr int8_t special_end_value = 0;
+  union {
+    T value;
+  };
 };
 
-inline int8_t log2(uint64_t value)
-{
-    static constexpr int8_t table[64] =
-    {
-        63,  0, 58,  1, 59, 47, 53,  2,
-        60, 39, 48, 27, 54, 33, 42,  3,
-        61, 51, 37, 40, 49, 18, 28, 20,
-        55, 30, 34, 11, 43, 14, 22,  4,
-        62, 57, 46, 52, 38, 26, 32, 41,
-        50, 36, 17, 19, 29, 10, 13, 21,
-        56, 45, 25, 31, 35, 16,  9, 12,
-        44, 24, 15,  8, 23,  7,  6,  5
-    };
-    value |= value >> 1;
-    value |= value >> 2;
-    value |= value >> 4;
-    value |= value >> 8;
-    value |= value >> 16;
-    value |= value >> 32;
-    return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
+inline int8_t log2(uint64_t value) {
+  static constexpr int8_t table[64] = {
+      63, 0,  58, 1,  59, 47, 53, 2,  60, 39, 48, 27, 54, 33, 42, 3,
+      61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4,
+      62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
+      56, 45, 25, 31, 35, 16, 9,  12, 44, 24, 15, 8,  23, 7,  6,  5};
+  value |= value >> 1;
+  value |= value >> 2;
+  value |= value >> 4;
+  value |= value >> 8;
+  value |= value >> 16;
+  value |= value >> 32;
+  return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
 }
 
-template<typename T, bool>
-struct AssignIfTrue
-{
-    void operator()(T & lhs, const T & rhs)
-    {
-        lhs = rhs;
-    }
-    void operator()(T & lhs, T && rhs)
-    {
-        lhs = std::move(rhs);
-    }
+template <typename T, bool>
+struct AssignIfTrue {
+  void operator()(T& lhs, const T& rhs) {
+    lhs = rhs;
+  }
+  void operator()(T& lhs, T&& rhs) {
+    lhs = std::move(rhs);
+  }
 };
-template<typename T>
-struct AssignIfTrue<T, false>
-{
-    void operator()(T &, const T &)
-    {
-    }
-    void operator()(T &, T &&)
-    {
-    }
+template <typename T>
+struct AssignIfTrue<T, false> {
+  void operator()(T&, const T&) {}
+  void operator()(T&, T&&) {}
 };
 
-inline uint64_t next_power_of_two(uint64_t i)
-{
-    --i;
-    i |= i >> 1;
-    i |= i >> 2;
-    i |= i >> 4;
-    i |= i >> 8;
-    i |= i >> 16;
-    i |= i >> 32;
-    ++i;
-    return i;
+inline uint64_t next_power_of_two(uint64_t i) {
+  --i;
+  i |= i >> 1;
+  i |= i >> 2;
+  i |= i >> 4;
+  i |= i >> 8;
+  i |= i >> 16;
+  i |= i >> 32;
+  ++i;
+  return i;
 }
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/void_t
 // (it takes CWG1558 into account and also works for older compilers)
-template<typename... Ts> struct make_void { typedef void type;};
-template<typename... Ts> using void_t = typename make_void<Ts...>::type;
-
-template<typename T, typename = void>
-struct HashPolicySelector
-{
-    typedef fibonacci_hash_policy type;
+template <typename... Ts>
+struct make_void {
+  typedef void type;
 };
-template<typename T>
-struct HashPolicySelector<T, void_t<typename T::hash_policy>>
-{
-    typedef typename T::hash_policy type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
+template <typename T, typename = void>
+struct HashPolicySelector {
+  typedef fibonacci_hash_policy type;
+};
+template <typename T>
+struct HashPolicySelector<T, void_t<typename T::hash_policy>> {
+  typedef typename T::hash_policy type;
 };
 
-template<typename T, typename FindKey, typename ArgumentHash, typename Hasher, typename ArgumentEqual, typename Equal, typename ArgumentAlloc, typename EntryAlloc>
-class sherwood_v3_table : private EntryAlloc, private Hasher, private Equal
-{
-    using Entry = detailv3::sherwood_v3_entry<T>;
-    using AllocatorTraits = std::allocator_traits<EntryAlloc>;
-    using EntryPointer = typename AllocatorTraits::pointer;
+template <
+    typename T,
+    typename FindKey,
+    typename ArgumentHash,
+    typename Hasher,
+    typename ArgumentEqual,
+    typename Equal,
+    typename ArgumentAlloc,
+    typename EntryAlloc>
+class sherwood_v3_table : private EntryAlloc, private Hasher, private Equal {
+  using Entry = detailv3::sherwood_v3_entry<T>;
+  using AllocatorTraits = std::allocator_traits<EntryAlloc>;
+  using EntryPointer = typename AllocatorTraits::pointer;
 
-public:
-    struct convertible_to_iterator;
+ public:
+  struct convertible_to_iterator;
 
-    using value_type = T;
-    using size_type = uint64_t;
-    using difference_type = std::ptrdiff_t;
-    using hasher = ArgumentHash;
-    using key_equal = ArgumentEqual;
-    using allocator_type = EntryAlloc;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using pointer = value_type *;
-    using const_pointer = const value_type *;
+  using value_type = T;
+  using size_type = uint64_t;
+  using difference_type = std::ptrdiff_t;
+  using hasher = ArgumentHash;
+  using key_equal = ArgumentEqual;
+  using allocator_type = EntryAlloc;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
 
-    sherwood_v3_table()
-    {
+  sherwood_v3_table() {}
+  explicit sherwood_v3_table(
+      size_type bucket_count,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : EntryAlloc(alloc), Hasher(hash), Equal(equal) {
+    rehash(bucket_count);
+  }
+  sherwood_v3_table(size_type bucket_count, const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc) {}
+  explicit sherwood_v3_table(const ArgumentAlloc& alloc) : EntryAlloc(alloc) {}
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count = 0,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : sherwood_v3_table(bucket_count, hash, equal, alloc) {
+    insert(first, last);
+  }
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            first,
+            last,
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            first,
+            last,
+            bucket_count,
+            hash,
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count = 0,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : sherwood_v3_table(bucket_count, hash, equal, alloc) {
+    if (bucket_count == 0)
+      rehash(il.size());
+    insert(il.begin(), il.end());
+  }
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            il,
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc) {}
+  sherwood_v3_table(const sherwood_v3_table& other)
+      : sherwood_v3_table(
+            other,
+            AllocatorTraits::select_on_container_copy_construction(
+                other.get_allocator())) {}
+  sherwood_v3_table(const sherwood_v3_table& other, const ArgumentAlloc& alloc)
+      : EntryAlloc(alloc),
+        Hasher(other),
+        Equal(other),
+        _max_load_factor(other._max_load_factor) {
+    rehash_for_other_container(other);
+    try {
+      insert(other.begin(), other.end());
+    } catch (...) {
+      clear();
+      deallocate_data(entries, num_slots_minus_one, max_lookups);
+      throw;
     }
-    explicit sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : EntryAlloc(alloc), Hasher(hash), Equal(equal)
-    {
-        rehash(bucket_count);
-    }
-    sherwood_v3_table(size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    explicit sherwood_v3_table(const ArgumentAlloc & alloc)
-        : EntryAlloc(alloc)
-    {
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : sherwood_v3_table(bucket_count, hash, equal, alloc)
-    {
-        insert(first, last);
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(first, last, bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(first, last, bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : sherwood_v3_table(bucket_count, hash, equal, alloc)
-    {
-        if (bucket_count == 0)
-            rehash(il.size());
-        insert(il.begin(), il.end());
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(il, bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(const sherwood_v3_table & other)
-        : sherwood_v3_table(other, AllocatorTraits::select_on_container_copy_construction(other.get_allocator()))
-    {
-    }
-    sherwood_v3_table(const sherwood_v3_table & other, const ArgumentAlloc & alloc)
-        : EntryAlloc(alloc), Hasher(other), Equal(other), _max_load_factor(other._max_load_factor)
-    {
-        rehash_for_other_container(other);
-        try
-        {
-            insert(other.begin(), other.end());
-        }
-        catch(...)
-        {
-            clear();
-            deallocate_data(entries, num_slots_minus_one, max_lookups);
-            throw;
-        }
-    }
-    sherwood_v3_table(sherwood_v3_table && other) noexcept
-        : EntryAlloc(std::move(other)), Hasher(std::move(other)), Equal(std::move(other))
-    {
-        swap_pointers(other);
-    }
-    sherwood_v3_table(sherwood_v3_table && other, const ArgumentAlloc & alloc) noexcept
-        : EntryAlloc(alloc), Hasher(std::move(other)), Equal(std::move(other))
-    {
-        swap_pointers(other);
-    }
-    sherwood_v3_table & operator=(const sherwood_v3_table & other)
-    {
-        if (this == std::addressof(other))
-            return *this;
+  }
+  sherwood_v3_table(sherwood_v3_table&& other) noexcept
+      : EntryAlloc(std::move(other)),
+        Hasher(std::move(other)),
+        Equal(std::move(other)) {
+    swap_pointers(other);
+  }
+  sherwood_v3_table(
+      sherwood_v3_table&& other,
+      const ArgumentAlloc& alloc) noexcept
+      : EntryAlloc(alloc), Hasher(std::move(other)), Equal(std::move(other)) {
+    swap_pointers(other);
+  }
+  sherwood_v3_table& operator=(const sherwood_v3_table& other) {
+    if (this == std::addressof(other))
+      return *this;
 
-        clear();
-        if (AllocatorTraits::propagate_on_container_copy_assignment::value)
-        {
-            if (static_cast<EntryAlloc &>(*this) != static_cast<const EntryAlloc &>(other))
-            {
-                reset_to_empty_state();
-            }
-            AssignIfTrue<EntryAlloc, AllocatorTraits::propagate_on_container_copy_assignment::value>()(*this, other);
-        }
-        _max_load_factor = other._max_load_factor;
-        static_cast<Hasher &>(*this) = other;
-        static_cast<Equal &>(*this) = other;
-        rehash_for_other_container(other);
-        insert(other.begin(), other.end());
-        return *this;
+    clear();
+    if (AllocatorTraits::propagate_on_container_copy_assignment::value) {
+      if (static_cast<EntryAlloc&>(*this) !=
+          static_cast<const EntryAlloc&>(other)) {
+        reset_to_empty_state();
+      }
+      AssignIfTrue<
+          EntryAlloc,
+          AllocatorTraits::propagate_on_container_copy_assignment::value>()(
+          *this, other);
     }
-    sherwood_v3_table & operator=(sherwood_v3_table && other) noexcept
-    {
-        if (this == std::addressof(other))
-            return *this;
-        else if (AllocatorTraits::propagate_on_container_move_assignment::value)
-        {
-            clear();
-            reset_to_empty_state();
-            AssignIfTrue<EntryAlloc, AllocatorTraits::propagate_on_container_move_assignment::value>()(*this, std::move(other));
-            swap_pointers(other);
-        }
-        else if (static_cast<EntryAlloc &>(*this) == static_cast<EntryAlloc &>(other))
-        {
-            swap_pointers(other);
-        }
-        else
-        {
-            clear();
-            _max_load_factor = other._max_load_factor;
-            rehash_for_other_container(other);
-            for (T & elem : other)
-                emplace(std::move(elem));
-            other.clear();
-        }
-        static_cast<Hasher &>(*this) = std::move(other);
-        static_cast<Equal &>(*this) = std::move(other);
-        return *this;
+    _max_load_factor = other._max_load_factor;
+    static_cast<Hasher&>(*this) = other;
+    static_cast<Equal&>(*this) = other;
+    rehash_for_other_container(other);
+    insert(other.begin(), other.end());
+    return *this;
+  }
+  sherwood_v3_table& operator=(sherwood_v3_table&& other) noexcept {
+    if (this == std::addressof(other))
+      return *this;
+    else if (AllocatorTraits::propagate_on_container_move_assignment::value) {
+      clear();
+      reset_to_empty_state();
+      AssignIfTrue<
+          EntryAlloc,
+          AllocatorTraits::propagate_on_container_move_assignment::value>()(
+          *this, std::move(other));
+      swap_pointers(other);
+    } else if (
+        static_cast<EntryAlloc&>(*this) == static_cast<EntryAlloc&>(other)) {
+      swap_pointers(other);
+    } else {
+      clear();
+      _max_load_factor = other._max_load_factor;
+      rehash_for_other_container(other);
+      for (T& elem : other)
+        emplace(std::move(elem));
+      other.clear();
     }
-    ~sherwood_v3_table()
-    {
-        clear();
-        deallocate_data(entries, num_slots_minus_one, max_lookups);
+    static_cast<Hasher&>(*this) = std::move(other);
+    static_cast<Equal&>(*this) = std::move(other);
+    return *this;
+  }
+  ~sherwood_v3_table() {
+    clear();
+    deallocate_data(entries, num_slots_minus_one, max_lookups);
+  }
+
+  const allocator_type& get_allocator() const {
+    return static_cast<const allocator_type&>(*this);
+  }
+  const ArgumentEqual& key_eq() const {
+    return static_cast<const ArgumentEqual&>(*this);
+  }
+  const ArgumentHash& hash_function() const {
+    return static_cast<const ArgumentHash&>(*this);
+  }
+
+  template <typename ValueType>
+  struct templated_iterator {
+    templated_iterator() = default;
+    templated_iterator(EntryPointer current) : current(current) {}
+    EntryPointer current = EntryPointer();
+
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = ValueType;
+    using difference_type = ptrdiff_t;
+    using pointer = ValueType*;
+    using reference = ValueType&;
+
+    friend bool operator==(
+        const templated_iterator& lhs,
+        const templated_iterator& rhs) {
+      return lhs.current == rhs.current;
+    }
+    friend bool operator!=(
+        const templated_iterator& lhs,
+        const templated_iterator& rhs) {
+      return !(lhs == rhs);
     }
 
-    const allocator_type & get_allocator() const
-    {
-        return static_cast<const allocator_type &>(*this);
+    templated_iterator& operator++() {
+      do {
+        ++current;
+      } while (current->is_empty());
+      return *this;
     }
-    const ArgumentEqual & key_eq() const
-    {
-        return static_cast<const ArgumentEqual &>(*this);
-    }
-    const ArgumentHash & hash_function() const
-    {
-        return static_cast<const ArgumentHash &>(*this);
+    templated_iterator operator++(int) {
+      templated_iterator copy(*this);
+      ++*this;
+      return copy;
     }
 
-    template<typename ValueType>
-    struct templated_iterator
-    {
-        templated_iterator() = default;
-        templated_iterator(EntryPointer current)
-            : current(current)
-        {
-        }
-        EntryPointer current = EntryPointer();
-
-        using iterator_category = std::forward_iterator_tag;
-        using value_type = ValueType;
-        using difference_type = ptrdiff_t;
-        using pointer = ValueType *;
-        using reference = ValueType &;
-
-        friend bool operator==(const templated_iterator & lhs, const templated_iterator & rhs)
-        {
-            return lhs.current == rhs.current;
-        }
-        friend bool operator!=(const templated_iterator & lhs, const templated_iterator & rhs)
-        {
-            return !(lhs == rhs);
-        }
-
-        templated_iterator & operator++()
-        {
-            do
-            {
-                ++current;
-            }
-            while(current->is_empty());
-            return *this;
-        }
-        templated_iterator operator++(int)
-        {
-            templated_iterator copy(*this);
-            ++*this;
-            return copy;
-        }
-
-        ValueType & operator*() const
-        {
-            return current->value;
-        }
-        ValueType * operator->() const
-        {
-            return std::addressof(current->value);
-        }
-
-        // the template automatically disables the operator when value_type is already
-        // const, because that would cause a lot of compiler warnings otherwise.
-        template<class target_type = const value_type, class = typename std::enable_if<std::is_same<target_type, const value_type>::value && !std::is_same<target_type, value_type>::value>::type>
-        operator templated_iterator<target_type>() const
-        {
-            return { current };
-        }
-    };
-    using iterator = templated_iterator<value_type>;
-    using const_iterator = templated_iterator<const value_type>;
-
-    iterator begin()
-    {
-        for (EntryPointer it = entries;; ++it)
-        {
-            if (it->has_value())
-                return { it };
-        }
+    ValueType& operator*() const {
+      return current->value;
     }
-    const_iterator begin() const
-    {
-        for (EntryPointer it = entries;; ++it)
-        {
-            if (it->has_value())
-                return { it };
-        }
-    }
-    const_iterator cbegin() const
-    {
-        return begin();
-    }
-    iterator end()
-    {
-        return { entries + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups) };
-    }
-    const_iterator end() const
-    {
-        return { entries + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups) };
-    }
-    const_iterator cend() const
-    {
-        return end();
+    ValueType* operator->() const {
+      return std::addressof(current->value);
     }
 
-    iterator find(const FindKey & key)
-    {
-        uint64_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-        EntryPointer it = entries + ptrdiff_t(index);
-        for (int8_t distance = 0; it->distance_from_desired >= distance; ++distance, ++it)
-        {
-            if (compares_equal(key, it->value))
-                return { it };
-        }
-        return end();
-    }
-    const_iterator find(const FindKey & key) const
-    {
-        return const_cast<sherwood_v3_table *>(this)->find(key);
-    }
-    uint64_t count(const FindKey & key) const
-    {
-        return find(key) == end() ? 0 : 1;
-    }
-    std::pair<iterator, iterator> equal_range(const FindKey & key)
-    {
-        iterator found = find(key);
-        if (found == end())
-            return { found, found };
-        else
-            return { found, std::next(found) };
-    }
-    std::pair<const_iterator, const_iterator> equal_range(const FindKey & key) const
-    {
-        const_iterator found = find(key);
-        if (found == end())
-            return { found, found };
-        else
-            return { found, std::next(found) };
+    // the template automatically disables the operator when value_type is
+    // already const, because that would cause a lot of compiler warnings
+    // otherwise.
+    template <
+        class target_type = const value_type,
+        class = typename std::enable_if<
+            std::is_same<target_type, const value_type>::value &&
+            !std::is_same<target_type, value_type>::value>::type>
+    operator templated_iterator<target_type>() const {
+      return {current};
     }
+  };
+  using iterator = templated_iterator<value_type>;
+  using const_iterator = templated_iterator<const value_type>;
 
-    template<typename Key, typename... Args>
-    std::pair<iterator, bool> emplace(Key && key, Args &&... args)
-    {
-        uint64_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-        EntryPointer current_entry = entries + ptrdiff_t(index);
-        int8_t distance_from_desired = 0;
-        for (; current_entry->distance_from_desired >= distance_from_desired; ++current_entry, ++distance_from_desired)
-        {
-            if (compares_equal(key, current_entry->value))
-                return { { current_entry }, false };
-        }
-        return emplace_new_key(distance_from_desired, current_entry, std::forward<Key>(key), std::forward<Args>(args)...);
+  iterator begin() {
+    for (EntryPointer it = entries;; ++it) {
+      if (it->has_value())
+        return {it};
     }
+  }
+  const_iterator begin() const {
+    for (EntryPointer it = entries;; ++it) {
+      if (it->has_value())
+        return {it};
+    }
+  }
+  const_iterator cbegin() const {
+    return begin();
+  }
+  iterator end() {
+    return {
+        entries + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups)};
+  }
+  const_iterator end() const {
+    return {
+        entries + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups)};
+  }
+  const_iterator cend() const {
+    return end();
+  }
 
-    std::pair<iterator, bool> insert(const value_type & value)
-    {
-        return emplace(value);
-    }
-    std::pair<iterator, bool> insert(value_type && value)
-    {
-        return emplace(std::move(value));
-    }
-    template<typename... Args>
-    iterator emplace_hint(const_iterator, Args &&... args)
-    {
-        return emplace(std::forward<Args>(args)...).first;
-    }
-    iterator insert(const_iterator, const value_type & value)
-    {
-        return emplace(value).first;
-    }
-    iterator insert(const_iterator, value_type && value)
-    {
-        return emplace(std::move(value)).first;
+  iterator find(const FindKey& key) {
+    uint64_t index =
+        hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+    EntryPointer it = entries + ptrdiff_t(index);
+    for (int8_t distance = 0; it->distance_from_desired >= distance;
+         ++distance, ++it) {
+      if (compares_equal(key, it->value))
+        return {it};
     }
+    return end();
+  }
+  const_iterator find(const FindKey& key) const {
+    return const_cast<sherwood_v3_table*>(this)->find(key);
+  }
+  uint64_t count(const FindKey& key) const {
+    return find(key) == end() ? 0 : 1;
+  }
+  std::pair<iterator, iterator> equal_range(const FindKey& key) {
+    iterator found = find(key);
+    if (found == end())
+      return {found, found};
+    else
+      return {found, std::next(found)};
+  }
+  std::pair<const_iterator, const_iterator> equal_range(
+      const FindKey& key) const {
+    const_iterator found = find(key);
+    if (found == end())
+      return {found, found};
+    else
+      return {found, std::next(found)};
+  }
 
-    template<typename It>
-    void insert(It begin, It end)
-    {
-        for (; begin != end; ++begin)
-        {
-            emplace(*begin);
-        }
-    }
-    void insert(std::initializer_list<value_type> il)
-    {
-        insert(il.begin(), il.end());
+  template <typename Key, typename... Args>
+  std::pair<iterator, bool> emplace(Key&& key, Args&&... args) {
+    uint64_t index =
+        hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+    EntryPointer current_entry = entries + ptrdiff_t(index);
+    int8_t distance_from_desired = 0;
+    for (; current_entry->distance_from_desired >= distance_from_desired;
+         ++current_entry, ++distance_from_desired) {
+      if (compares_equal(key, current_entry->value))
+        return {{current_entry}, false};
     }
+    return emplace_new_key(
+        distance_from_desired,
+        current_entry,
+        std::forward<Key>(key),
+        std::forward<Args>(args)...);
+  }
 
-    void rehash(uint64_t num_buckets)
-    {
-        num_buckets = std::max(num_buckets, static_cast<uint64_t>(std::ceil(num_elements / static_cast<double>(_max_load_factor))));
-        if (num_buckets == 0)
-        {
-            reset_to_empty_state();
-            return;
-        }
-        auto new_prime_index = hash_policy.next_size_over(num_buckets);
-        if (num_buckets == bucket_count())
-            return;
-        int8_t new_max_lookups = compute_max_lookups(num_buckets);
-        EntryPointer new_buckets(AllocatorTraits::allocate(*this, num_buckets + new_max_lookups));
-        EntryPointer special_end_item = new_buckets + static_cast<ptrdiff_t>(num_buckets + new_max_lookups - 1);
-        for (EntryPointer it = new_buckets; it != special_end_item; ++it)
-            it->distance_from_desired = -1;
-        special_end_item->distance_from_desired = Entry::special_end_value;
-        std::swap(entries, new_buckets);
-        std::swap(num_slots_minus_one, num_buckets);
-        --num_slots_minus_one;
-        hash_policy.commit(new_prime_index);
-        int8_t old_max_lookups = max_lookups;
-        max_lookups = new_max_lookups;
-        num_elements = 0;
-        for (EntryPointer it = new_buckets, end = it + static_cast<ptrdiff_t>(num_buckets + old_max_lookups); it != end; ++it)
-        {
-            if (it->has_value())
-            {
-                emplace(std::move(it->value));
-                it->destroy_value();
-            }
-        }
-        deallocate_data(new_buckets, num_buckets, old_max_lookups);
-    }
+  std::pair<iterator, bool> insert(const value_type& value) {
+    return emplace(value);
+  }
+  std::pair<iterator, bool> insert(value_type&& value) {
+    return emplace(std::move(value));
+  }
+  template <typename... Args>
+  iterator emplace_hint(const_iterator, Args&&... args) {
+    return emplace(std::forward<Args>(args)...).first;
+  }
+  iterator insert(const_iterator, const value_type& value) {
+    return emplace(value).first;
+  }
+  iterator insert(const_iterator, value_type&& value) {
+    return emplace(std::move(value)).first;
+  }
 
-    void reserve(uint64_t num_elements)
-    {
-        uint64_t required_buckets = num_buckets_for_reserve(num_elements);
-        if (required_buckets > bucket_count())
-            rehash(required_buckets);
+  template <typename It>
+  void insert(It begin, It end) {
+    for (; begin != end; ++begin) {
+      emplace(*begin);
     }
+  }
+  void insert(std::initializer_list<value_type> il) {
+    insert(il.begin(), il.end());
+  }
 
-    // the return value is a type that can be converted to an iterator
-    // the reason for doing this is that it's not free to find the
-    // iterator pointing at the next element. if you care about the
-    // next iterator, turn the return value into an iterator
-    convertible_to_iterator erase(const_iterator to_erase)
-    {
-        EntryPointer current = to_erase.current;
-        current->destroy_value();
+  void rehash(uint64_t num_buckets) {
+    num_buckets = std::max(
+        num_buckets,
+        static_cast<uint64_t>(
+            std::ceil(num_elements / static_cast<double>(_max_load_factor))));
+    if (num_buckets == 0) {
+      reset_to_empty_state();
+      return;
+    }
+    auto new_prime_index = hash_policy.next_size_over(num_buckets);
+    if (num_buckets == bucket_count())
+      return;
+    int8_t new_max_lookups = compute_max_lookups(num_buckets);
+    EntryPointer new_buckets(
+        AllocatorTraits::allocate(*this, num_buckets + new_max_lookups));
+    EntryPointer special_end_item =
+        new_buckets + static_cast<ptrdiff_t>(num_buckets + new_max_lookups - 1);
+    for (EntryPointer it = new_buckets; it != special_end_item; ++it)
+      it->distance_from_desired = -1;
+    special_end_item->distance_from_desired = Entry::special_end_value;
+    std::swap(entries, new_buckets);
+    std::swap(num_slots_minus_one, num_buckets);
+    --num_slots_minus_one;
+    hash_policy.commit(new_prime_index);
+    int8_t old_max_lookups = max_lookups;
+    max_lookups = new_max_lookups;
+    num_elements = 0;
+    for (EntryPointer
+             it = new_buckets,
+             end = it + static_cast<ptrdiff_t>(num_buckets + old_max_lookups);
+         it != end;
+         ++it) {
+      if (it->has_value()) {
+        emplace(std::move(it->value));
+        it->destroy_value();
+      }
+    }
+    deallocate_data(new_buckets, num_buckets, old_max_lookups);
+  }
+
+  void reserve(uint64_t num_elements) {
+    uint64_t required_buckets = num_buckets_for_reserve(num_elements);
+    if (required_buckets > bucket_count())
+      rehash(required_buckets);
+  }
+
+  // the return value is a type that can be converted to an iterator
+  // the reason for doing this is that it's not free to find the
+  // iterator pointing at the next element. if you care about the
+  // next iterator, turn the return value into an iterator
+  convertible_to_iterator erase(const_iterator to_erase) {
+    EntryPointer current = to_erase.current;
+    current->destroy_value();
+    --num_elements;
+    for (EntryPointer next = current + ptrdiff_t(1);
+         !next->is_at_desired_position();
+         ++current, ++next) {
+      current->emplace(next->distance_from_desired - 1, std::move(next->value));
+      next->destroy_value();
+    }
+    return {to_erase.current};
+  }
+
+  iterator erase(const_iterator begin_it, const_iterator end_it) {
+    if (begin_it == end_it)
+      return {begin_it.current};
+    for (EntryPointer it = begin_it.current, end = end_it.current; it != end;
+         ++it) {
+      if (it->has_value()) {
+        it->destroy_value();
         --num_elements;
-        for (EntryPointer next = current + ptrdiff_t(1); !next->is_at_desired_position(); ++current, ++next)
-        {
-            current->emplace(next->distance_from_desired - 1, std::move(next->value));
-            next->destroy_value();
-        }
-        return { to_erase.current };
+      }
     }
+    if (end_it == this->end())
+      return this->end();
+    ptrdiff_t num_to_move = std::min(
+        static_cast<ptrdiff_t>(end_it.current->distance_from_desired),
+        end_it.current - begin_it.current);
+    EntryPointer to_return = end_it.current - num_to_move;
+    for (EntryPointer it = end_it.current; !it->is_at_desired_position();) {
+      EntryPointer target = it - num_to_move;
+      target->emplace(
+          it->distance_from_desired - num_to_move, std::move(it->value));
+      it->destroy_value();
+      ++it;
+      num_to_move = std::min(
+          static_cast<ptrdiff_t>(it->distance_from_desired), num_to_move);
+    }
+    return {to_return};
+  }
 
-    iterator erase(const_iterator begin_it, const_iterator end_it)
-    {
-        if (begin_it == end_it)
-            return { begin_it.current };
-        for (EntryPointer it = begin_it.current, end = end_it.current; it != end; ++it)
-        {
-            if (it->has_value())
-            {
-                it->destroy_value();
-                --num_elements;
-            }
-        }
-        if (end_it == this->end())
-            return this->end();
-        ptrdiff_t num_to_move = std::min(static_cast<ptrdiff_t>(end_it.current->distance_from_desired), end_it.current - begin_it.current);
-        EntryPointer to_return = end_it.current - num_to_move;
-        for (EntryPointer it = end_it.current; !it->is_at_desired_position();)
-        {
-            EntryPointer target = it - num_to_move;
-            target->emplace(it->distance_from_desired - num_to_move, std::move(it->value));
-            it->destroy_value();
-            ++it;
-            num_to_move = std::min(static_cast<ptrdiff_t>(it->distance_from_desired), num_to_move);
-        }
-        return { to_return };
+  uint64_t erase(const FindKey& key) {
+    auto found = find(key);
+    if (found == end())
+      return 0;
+    else {
+      erase(found);
+      return 1;
     }
+  }
 
-    uint64_t erase(const FindKey & key)
-    {
-        auto found = find(key);
-        if (found == end())
-            return 0;
-        else
-        {
-            erase(found);
-            return 1;
-        }
+  void clear() {
+    for (EntryPointer it = entries,
+                      end = it +
+             static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups);
+         it != end;
+         ++it) {
+      if (it->has_value())
+        it->destroy_value();
     }
+    num_elements = 0;
+  }
 
-    void clear()
-    {
-        for (EntryPointer it = entries, end = it + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups); it != end; ++it)
-        {
-            if (it->has_value())
-                it->destroy_value();
-        }
-        num_elements = 0;
-    }
+  void shrink_to_fit() {
+    rehash_for_other_container(*this);
+  }
 
-    void shrink_to_fit()
-    {
-        rehash_for_other_container(*this);
-    }
+  void swap(sherwood_v3_table& other) {
+    using std::swap;
+    swap_pointers(other);
+    swap(static_cast<ArgumentHash&>(*this), static_cast<ArgumentHash&>(other));
+    swap(
+        static_cast<ArgumentEqual&>(*this), static_cast<ArgumentEqual&>(other));
+    if (AllocatorTraits::propagate_on_container_swap::value)
+      swap(static_cast<EntryAlloc&>(*this), static_cast<EntryAlloc&>(other));
+  }
 
-    void swap(sherwood_v3_table & other)
-    {
-        using std::swap;
-        swap_pointers(other);
-        swap(static_cast<ArgumentHash &>(*this), static_cast<ArgumentHash &>(other));
-        swap(static_cast<ArgumentEqual &>(*this), static_cast<ArgumentEqual &>(other));
-        if (AllocatorTraits::propagate_on_container_swap::value)
-            swap(static_cast<EntryAlloc &>(*this), static_cast<EntryAlloc &>(other));
-    }
+  uint64_t size() const {
+    return num_elements;
+  }
+  uint64_t max_size() const {
+    return (AllocatorTraits::max_size(*this)) / sizeof(Entry);
+  }
+  uint64_t bucket_count() const {
+    return num_slots_minus_one ? num_slots_minus_one + 1 : 0;
+  }
+  size_type max_bucket_count() const {
+    return (AllocatorTraits::max_size(*this) - min_lookups) / sizeof(Entry);
+  }
+  uint64_t bucket(const FindKey& key) const {
+    return hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+  }
+  float load_factor() const {
+    uint64_t buckets = bucket_count();
+    if (buckets)
+      return static_cast<float>(num_elements) / bucket_count();
+    else
+      return 0;
+  }
+  void max_load_factor(float value) {
+    _max_load_factor = value;
+  }
+  float max_load_factor() const {
+    return _max_load_factor;
+  }
 
-    uint64_t size() const
-    {
-        return num_elements;
-    }
-    uint64_t max_size() const
-    {
-        return (AllocatorTraits::max_size(*this)) / sizeof(Entry);
-    }
-    uint64_t bucket_count() const
-    {
-        return num_slots_minus_one ? num_slots_minus_one + 1 : 0;
-    }
-    size_type max_bucket_count() const
-    {
-        return (AllocatorTraits::max_size(*this) - min_lookups) / sizeof(Entry);
-    }
-    uint64_t bucket(const FindKey & key) const
-    {
-        return hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-    }
-    float load_factor() const
-    {
-        uint64_t buckets = bucket_count();
-        if (buckets)
-            return static_cast<float>(num_elements) / bucket_count();
-        else
-            return 0;
-    }
-    void max_load_factor(float value)
-    {
-        _max_load_factor = value;
-    }
-    float max_load_factor() const
-    {
-        return _max_load_factor;
-    }
+  bool empty() const {
+    return num_elements == 0;
+  }
 
-    bool empty() const
-    {
-        return num_elements == 0;
-    }
+ private:
+  EntryPointer entries = empty_default_table();
+  uint64_t num_slots_minus_one = 0;
+  typename HashPolicySelector<ArgumentHash>::type hash_policy;
+  int8_t max_lookups = detailv3::min_lookups - 1;
+  float _max_load_factor = 0.5f;
+  uint64_t num_elements = 0;
 
-private:
-    EntryPointer entries = empty_default_table();
-    uint64_t num_slots_minus_one = 0;
-    typename HashPolicySelector<ArgumentHash>::type hash_policy;
-    int8_t max_lookups = detailv3::min_lookups - 1;
-    float _max_load_factor = 0.5f;
-    uint64_t num_elements = 0;
+  EntryPointer empty_default_table() {
+    EntryPointer result =
+        AllocatorTraits::allocate(*this, detailv3::min_lookups);
+    EntryPointer special_end_item =
+        result + static_cast<ptrdiff_t>(detailv3::min_lookups - 1);
+    for (EntryPointer it = result; it != special_end_item; ++it)
+      it->distance_from_desired = -1;
+    special_end_item->distance_from_desired = Entry::special_end_value;
+    return result;
+  }
 
-    EntryPointer empty_default_table()
-    {
-        EntryPointer result = AllocatorTraits::allocate(*this, detailv3::min_lookups);
-        EntryPointer special_end_item = result + static_cast<ptrdiff_t>(detailv3::min_lookups - 1);
-        for (EntryPointer it = result; it != special_end_item; ++it)
-            it->distance_from_desired = -1;
-        special_end_item->distance_from_desired = Entry::special_end_value;
-        return result;
-    }
+  static int8_t compute_max_lookups(uint64_t num_buckets) {
+    int8_t desired = detailv3::log2(num_buckets);
+    return std::max(detailv3::min_lookups, desired);
+  }
 
-    static int8_t compute_max_lookups(uint64_t num_buckets)
-    {
-        int8_t desired = detailv3::log2(num_buckets);
-        return std::max(detailv3::min_lookups, desired);
-    }
+  uint64_t num_buckets_for_reserve(uint64_t num_elements) const {
+    return static_cast<uint64_t>(std::ceil(
+        num_elements / std::min(0.5, static_cast<double>(_max_load_factor))));
+  }
+  void rehash_for_other_container(const sherwood_v3_table& other) {
+    rehash(
+        std::min(num_buckets_for_reserve(other.size()), other.bucket_count()));
+  }
 
-    uint64_t num_buckets_for_reserve(uint64_t num_elements) const
-    {
-        return static_cast<uint64_t>(std::ceil(num_elements / std::min(0.5, static_cast<double>(_max_load_factor))));
-    }
-    void rehash_for_other_container(const sherwood_v3_table & other)
-    {
-        rehash(std::min(num_buckets_for_reserve(other.size()), other.bucket_count()));
-    }
+  void swap_pointers(sherwood_v3_table& other) {
+    using std::swap;
+    swap(hash_policy, other.hash_policy);
+    swap(entries, other.entries);
+    swap(num_slots_minus_one, other.num_slots_minus_one);
+    swap(num_elements, other.num_elements);
+    swap(max_lookups, other.max_lookups);
+    swap(_max_load_factor, other._max_load_factor);
+  }
 
-    void swap_pointers(sherwood_v3_table & other)
-    {
-        using std::swap;
-        swap(hash_policy, other.hash_policy);
-        swap(entries, other.entries);
-        swap(num_slots_minus_one, other.num_slots_minus_one);
-        swap(num_elements, other.num_elements);
-        swap(max_lookups, other.max_lookups);
-        swap(_max_load_factor, other._max_load_factor);
+  template <typename Key, typename... Args>
+  SKA_NOINLINE(std::pair<iterator, bool>)
+  emplace_new_key(
+      int8_t distance_from_desired,
+      EntryPointer current_entry,
+      Key&& key,
+      Args&&... args) {
+    using std::swap;
+    if (num_slots_minus_one == 0 || distance_from_desired == max_lookups ||
+        num_elements + 1 >
+            (num_slots_minus_one + 1) * static_cast<double>(_max_load_factor)) {
+      grow();
+      return emplace(std::forward<Key>(key), std::forward<Args>(args)...);
+    } else if (current_entry->is_empty()) {
+      current_entry->emplace(
+          distance_from_desired,
+          std::forward<Key>(key),
+          std::forward<Args>(args)...);
+      ++num_elements;
+      return {{current_entry}, true};
     }
-
-    template<typename Key, typename... Args>
-    SKA_NOINLINE(std::pair<iterator, bool>) emplace_new_key(int8_t distance_from_desired, EntryPointer current_entry, Key && key, Args &&... args)
-    {
-        using std::swap;
-        if (num_slots_minus_one == 0 || distance_from_desired == max_lookups || num_elements + 1 > (num_slots_minus_one + 1) * static_cast<double>(_max_load_factor))
-        {
-            grow();
-            return emplace(std::forward<Key>(key), std::forward<Args>(args)...);
-        }
-        else if (current_entry->is_empty())
-        {
-            current_entry->emplace(distance_from_desired, std::forward<Key>(key), std::forward<Args>(args)...);
-            ++num_elements;
-            return { { current_entry }, true };
-        }
-        value_type to_insert(std::forward<Key>(key), std::forward<Args>(args)...);
+    value_type to_insert(std::forward<Key>(key), std::forward<Args>(args)...);
+    swap(distance_from_desired, current_entry->distance_from_desired);
+    swap(to_insert, current_entry->value);
+    iterator result = {current_entry};
+    for (++distance_from_desired, ++current_entry;; ++current_entry) {
+      if (current_entry->is_empty()) {
+        current_entry->emplace(distance_from_desired, std::move(to_insert));
+        ++num_elements;
+        return {result, true};
+      } else if (current_entry->distance_from_desired < distance_from_desired) {
         swap(distance_from_desired, current_entry->distance_from_desired);
         swap(to_insert, current_entry->value);
-        iterator result = { current_entry };
-        for (++distance_from_desired, ++current_entry;; ++current_entry)
-        {
-            if (current_entry->is_empty())
-            {
-                current_entry->emplace(distance_from_desired, std::move(to_insert));
-                ++num_elements;
-                return { result, true };
-            }
-            else if (current_entry->distance_from_desired < distance_from_desired)
-            {
-                swap(distance_from_desired, current_entry->distance_from_desired);
-                swap(to_insert, current_entry->value);
-                ++distance_from_desired;
-            }
-            else
-            {
-                ++distance_from_desired;
-                if (distance_from_desired == max_lookups)
-                {
-                    swap(to_insert, result.current->value);
-                    grow();
-                    return emplace(std::move(to_insert));
-                }
-            }
+        ++distance_from_desired;
+      } else {
+        ++distance_from_desired;
+        if (distance_from_desired == max_lookups) {
+          swap(to_insert, result.current->value);
+          grow();
+          return emplace(std::move(to_insert));
         }
+      }
     }
+  }
 
-    void grow()
-    {
-        rehash(std::max(uint64_t(4), 2 * bucket_count()));
+  void grow() {
+    rehash(std::max(uint64_t(4), 2 * bucket_count()));
+  }
+
+  void deallocate_data(
+      EntryPointer begin,
+      uint64_t num_slots_minus_one,
+      int8_t max_lookups) {
+    AllocatorTraits::deallocate(
+        *this, begin, num_slots_minus_one + max_lookups + 1);
+  }
+
+  void reset_to_empty_state() {
+    deallocate_data(entries, num_slots_minus_one, max_lookups);
+    entries = empty_default_table();
+    num_slots_minus_one = 0;
+    hash_policy.reset();
+    max_lookups = detailv3::min_lookups - 1;
+  }
+
+  template <typename U>
+  uint64_t hash_object(const U& key) {
+    return static_cast<Hasher&>(*this)(key);
+  }
+  template <typename U>
+  uint64_t hash_object(const U& key) const {
+    return static_cast<const Hasher&>(*this)(key);
+  }
+  template <typename L, typename R>
+  bool compares_equal(const L& lhs, const R& rhs) {
+    return static_cast<Equal&>(*this)(lhs, rhs);
+  }
+
+ public:
+  struct convertible_to_iterator {
+    EntryPointer it;
+
+    operator iterator() {
+      if (it->has_value())
+        return {it};
+      else
+        return ++iterator{it};
     }
-
-    void deallocate_data(EntryPointer begin, uint64_t num_slots_minus_one, int8_t max_lookups)
-    {
-        AllocatorTraits::deallocate(*this, begin, num_slots_minus_one + max_lookups + 1);
+    operator const_iterator() {
+      if (it->has_value())
+        return {it};
+      else
+        return ++const_iterator{it};
     }
-
-    void reset_to_empty_state()
-    {
-        deallocate_data(entries, num_slots_minus_one, max_lookups);
-        entries = empty_default_table();
-        num_slots_minus_one = 0;
-        hash_policy.reset();
-        max_lookups = detailv3::min_lookups - 1;
-    }
-
-    template<typename U>
-    uint64_t hash_object(const U & key)
-    {
-        return static_cast<Hasher &>(*this)(key);
-    }
-    template<typename U>
-    uint64_t hash_object(const U & key) const
-    {
-        return static_cast<const Hasher &>(*this)(key);
-    }
-    template<typename L, typename R>
-    bool compares_equal(const L & lhs, const R & rhs)
-    {
-        return static_cast<Equal &>(*this)(lhs, rhs);
-    }
-
-public:
-    struct convertible_to_iterator
-    {
-        EntryPointer it;
-
-        operator iterator()
-        {
-            if (it->has_value())
-                return { it };
-            else
-                return ++iterator{it};
-        }
-        operator const_iterator()
-        {
-            if (it->has_value())
-                return { it };
-            else
-                return ++const_iterator{it};
-        }
-    };
-
+  };
 };
-}
+} // namespace detailv3
 
-struct prime_number_hash_policy
-{
-    static uint64_t mod0(uint64_t) { return 0llu; }
-    static uint64_t mod2(uint64_t hash) { return hash % 2llu; }
-    static uint64_t mod3(uint64_t hash) { return hash % 3llu; }
-    static uint64_t mod5(uint64_t hash) { return hash % 5llu; }
-    static uint64_t mod7(uint64_t hash) { return hash % 7llu; }
-    static uint64_t mod11(uint64_t hash) { return hash % 11llu; }
-    static uint64_t mod13(uint64_t hash) { return hash % 13llu; }
-    static uint64_t mod17(uint64_t hash) { return hash % 17llu; }
-    static uint64_t mod23(uint64_t hash) { return hash % 23llu; }
-    static uint64_t mod29(uint64_t hash) { return hash % 29llu; }
-    static uint64_t mod37(uint64_t hash) { return hash % 37llu; }
-    static uint64_t mod47(uint64_t hash) { return hash % 47llu; }
-    static uint64_t mod59(uint64_t hash) { return hash % 59llu; }
-    static uint64_t mod73(uint64_t hash) { return hash % 73llu; }
-    static uint64_t mod97(uint64_t hash) { return hash % 97llu; }
-    static uint64_t mod127(uint64_t hash) { return hash % 127llu; }
-    static uint64_t mod151(uint64_t hash) { return hash % 151llu; }
-    static uint64_t mod197(uint64_t hash) { return hash % 197llu; }
-    static uint64_t mod251(uint64_t hash) { return hash % 251llu; }
-    static uint64_t mod313(uint64_t hash) { return hash % 313llu; }
-    static uint64_t mod397(uint64_t hash) { return hash % 397llu; }
-    static uint64_t mod499(uint64_t hash) { return hash % 499llu; }
-    static uint64_t mod631(uint64_t hash) { return hash % 631llu; }
-    static uint64_t mod797(uint64_t hash) { return hash % 797llu; }
-    static uint64_t mod1009(uint64_t hash) { return hash % 1009llu; }
-    static uint64_t mod1259(uint64_t hash) { return hash % 1259llu; }
-    static uint64_t mod1597(uint64_t hash) { return hash % 1597llu; }
-    static uint64_t mod2011(uint64_t hash) { return hash % 2011llu; }
-    static uint64_t mod2539(uint64_t hash) { return hash % 2539llu; }
-    static uint64_t mod3203(uint64_t hash) { return hash % 3203llu; }
-    static uint64_t mod4027(uint64_t hash) { return hash % 4027llu; }
-    static uint64_t mod5087(uint64_t hash) { return hash % 5087llu; }
-    static uint64_t mod6421(uint64_t hash) { return hash % 6421llu; }
-    static uint64_t mod8089(uint64_t hash) { return hash % 8089llu; }
-    static uint64_t mod10193(uint64_t hash) { return hash % 10193llu; }
-    static uint64_t mod12853(uint64_t hash) { return hash % 12853llu; }
-    static uint64_t mod16193(uint64_t hash) { return hash % 16193llu; }
-    static uint64_t mod20399(uint64_t hash) { return hash % 20399llu; }
-    static uint64_t mod25717(uint64_t hash) { return hash % 25717llu; }
-    static uint64_t mod32401(uint64_t hash) { return hash % 32401llu; }
-    static uint64_t mod40823(uint64_t hash) { return hash % 40823llu; }
-    static uint64_t mod51437(uint64_t hash) { return hash % 51437llu; }
-    static uint64_t mod64811(uint64_t hash) { return hash % 64811llu; }
-    static uint64_t mod81649(uint64_t hash) { return hash % 81649llu; }
-    static uint64_t mod102877(uint64_t hash) { return hash % 102877llu; }
-    static uint64_t mod129607(uint64_t hash) { return hash % 129607llu; }
-    static uint64_t mod163307(uint64_t hash) { return hash % 163307llu; }
-    static uint64_t mod205759(uint64_t hash) { return hash % 205759llu; }
-    static uint64_t mod259229(uint64_t hash) { return hash % 259229llu; }
-    static uint64_t mod326617(uint64_t hash) { return hash % 326617llu; }
-    static uint64_t mod411527(uint64_t hash) { return hash % 411527llu; }
-    static uint64_t mod518509(uint64_t hash) { return hash % 518509llu; }
-    static uint64_t mod653267(uint64_t hash) { return hash % 653267llu; }
-    static uint64_t mod823117(uint64_t hash) { return hash % 823117llu; }
-    static uint64_t mod1037059(uint64_t hash) { return hash % 1037059llu; }
-    static uint64_t mod1306601(uint64_t hash) { return hash % 1306601llu; }
-    static uint64_t mod1646237(uint64_t hash) { return hash % 1646237llu; }
-    static uint64_t mod2074129(uint64_t hash) { return hash % 2074129llu; }
-    static uint64_t mod2613229(uint64_t hash) { return hash % 2613229llu; }
-    static uint64_t mod3292489(uint64_t hash) { return hash % 3292489llu; }
-    static uint64_t mod4148279(uint64_t hash) { return hash % 4148279llu; }
-    static uint64_t mod5226491(uint64_t hash) { return hash % 5226491llu; }
-    static uint64_t mod6584983(uint64_t hash) { return hash % 6584983llu; }
-    static uint64_t mod8296553(uint64_t hash) { return hash % 8296553llu; }
-    static uint64_t mod10453007(uint64_t hash) { return hash % 10453007llu; }
-    static uint64_t mod13169977(uint64_t hash) { return hash % 13169977llu; }
-    static uint64_t mod16593127(uint64_t hash) { return hash % 16593127llu; }
-    static uint64_t mod20906033(uint64_t hash) { return hash % 20906033llu; }
-    static uint64_t mod26339969(uint64_t hash) { return hash % 26339969llu; }
-    static uint64_t mod33186281(uint64_t hash) { return hash % 33186281llu; }
-    static uint64_t mod41812097(uint64_t hash) { return hash % 41812097llu; }
-    static uint64_t mod52679969(uint64_t hash) { return hash % 52679969llu; }
-    static uint64_t mod66372617(uint64_t hash) { return hash % 66372617llu; }
-    static uint64_t mod83624237(uint64_t hash) { return hash % 83624237llu; }
-    static uint64_t mod105359939(uint64_t hash) { return hash % 105359939llu; }
-    static uint64_t mod132745199(uint64_t hash) { return hash % 132745199llu; }
-    static uint64_t mod167248483(uint64_t hash) { return hash % 167248483llu; }
-    static uint64_t mod210719881(uint64_t hash) { return hash % 210719881llu; }
-    static uint64_t mod265490441(uint64_t hash) { return hash % 265490441llu; }
-    static uint64_t mod334496971(uint64_t hash) { return hash % 334496971llu; }
-    static uint64_t mod421439783(uint64_t hash) { return hash % 421439783llu; }
-    static uint64_t mod530980861(uint64_t hash) { return hash % 530980861llu; }
-    static uint64_t mod668993977(uint64_t hash) { return hash % 668993977llu; }
-    static uint64_t mod842879579(uint64_t hash) { return hash % 842879579llu; }
-    static uint64_t mod1061961721(uint64_t hash) { return hash % 1061961721llu; }
-    static uint64_t mod1337987929(uint64_t hash) { return hash % 1337987929llu; }
-    static uint64_t mod1685759167(uint64_t hash) { return hash % 1685759167llu; }
-    static uint64_t mod2123923447(uint64_t hash) { return hash % 2123923447llu; }
-    static uint64_t mod2675975881(uint64_t hash) { return hash % 2675975881llu; }
-    static uint64_t mod3371518343(uint64_t hash) { return hash % 3371518343llu; }
-    static uint64_t mod4247846927(uint64_t hash) { return hash % 4247846927llu; }
-    static uint64_t mod5351951779(uint64_t hash) { return hash % 5351951779llu; }
-    static uint64_t mod6743036717(uint64_t hash) { return hash % 6743036717llu; }
-    static uint64_t mod8495693897(uint64_t hash) { return hash % 8495693897llu; }
-    static uint64_t mod10703903591(uint64_t hash) { return hash % 10703903591llu; }
-    static uint64_t mod13486073473(uint64_t hash) { return hash % 13486073473llu; }
-    static uint64_t mod16991387857(uint64_t hash) { return hash % 16991387857llu; }
-    static uint64_t mod21407807219(uint64_t hash) { return hash % 21407807219llu; }
-    static uint64_t mod26972146961(uint64_t hash) { return hash % 26972146961llu; }
-    static uint64_t mod33982775741(uint64_t hash) { return hash % 33982775741llu; }
-    static uint64_t mod42815614441(uint64_t hash) { return hash % 42815614441llu; }
-    static uint64_t mod53944293929(uint64_t hash) { return hash % 53944293929llu; }
-    static uint64_t mod67965551447(uint64_t hash) { return hash % 67965551447llu; }
-    static uint64_t mod85631228929(uint64_t hash) { return hash % 85631228929llu; }
-    static uint64_t mod107888587883(uint64_t hash) { return hash % 107888587883llu; }
-    static uint64_t mod135931102921(uint64_t hash) { return hash % 135931102921llu; }
-    static uint64_t mod171262457903(uint64_t hash) { return hash % 171262457903llu; }
-    static uint64_t mod215777175787(uint64_t hash) { return hash % 215777175787llu; }
-    static uint64_t mod271862205833(uint64_t hash) { return hash % 271862205833llu; }
-    static uint64_t mod342524915839(uint64_t hash) { return hash % 342524915839llu; }
-    static uint64_t mod431554351609(uint64_t hash) { return hash % 431554351609llu; }
-    static uint64_t mod543724411781(uint64_t hash) { return hash % 543724411781llu; }
-    static uint64_t mod685049831731(uint64_t hash) { return hash % 685049831731llu; }
-    static uint64_t mod863108703229(uint64_t hash) { return hash % 863108703229llu; }
-    static uint64_t mod1087448823553(uint64_t hash) { return hash % 1087448823553llu; }
-    static uint64_t mod1370099663459(uint64_t hash) { return hash % 1370099663459llu; }
-    static uint64_t mod1726217406467(uint64_t hash) { return hash % 1726217406467llu; }
-    static uint64_t mod2174897647073(uint64_t hash) { return hash % 2174897647073llu; }
-    static uint64_t mod2740199326961(uint64_t hash) { return hash % 2740199326961llu; }
-    static uint64_t mod3452434812973(uint64_t hash) { return hash % 3452434812973llu; }
-    static uint64_t mod4349795294267(uint64_t hash) { return hash % 4349795294267llu; }
-    static uint64_t mod5480398654009(uint64_t hash) { return hash % 5480398654009llu; }
-    static uint64_t mod6904869625999(uint64_t hash) { return hash % 6904869625999llu; }
-    static uint64_t mod8699590588571(uint64_t hash) { return hash % 8699590588571llu; }
-    static uint64_t mod10960797308051(uint64_t hash) { return hash % 10960797308051llu; }
-    static uint64_t mod13809739252051(uint64_t hash) { return hash % 13809739252051llu; }
-    static uint64_t mod17399181177241(uint64_t hash) { return hash % 17399181177241llu; }
-    static uint64_t mod21921594616111(uint64_t hash) { return hash % 21921594616111llu; }
-    static uint64_t mod27619478504183(uint64_t hash) { return hash % 27619478504183llu; }
-    static uint64_t mod34798362354533(uint64_t hash) { return hash % 34798362354533llu; }
-    static uint64_t mod43843189232363(uint64_t hash) { return hash % 43843189232363llu; }
-    static uint64_t mod55238957008387(uint64_t hash) { return hash % 55238957008387llu; }
-    static uint64_t mod69596724709081(uint64_t hash) { return hash % 69596724709081llu; }
-    static uint64_t mod87686378464759(uint64_t hash) { return hash % 87686378464759llu; }
-    static uint64_t mod110477914016779(uint64_t hash) { return hash % 110477914016779llu; }
-    static uint64_t mod139193449418173(uint64_t hash) { return hash % 139193449418173llu; }
-    static uint64_t mod175372756929481(uint64_t hash) { return hash % 175372756929481llu; }
-    static uint64_t mod220955828033581(uint64_t hash) { return hash % 220955828033581llu; }
-    static uint64_t mod278386898836457(uint64_t hash) { return hash % 278386898836457llu; }
-    static uint64_t mod350745513859007(uint64_t hash) { return hash % 350745513859007llu; }
-    static uint64_t mod441911656067171(uint64_t hash) { return hash % 441911656067171llu; }
-    static uint64_t mod556773797672909(uint64_t hash) { return hash % 556773797672909llu; }
-    static uint64_t mod701491027718027(uint64_t hash) { return hash % 701491027718027llu; }
-    static uint64_t mod883823312134381(uint64_t hash) { return hash % 883823312134381llu; }
-    static uint64_t mod1113547595345903(uint64_t hash) { return hash % 1113547595345903llu; }
-    static uint64_t mod1402982055436147(uint64_t hash) { return hash % 1402982055436147llu; }
-    static uint64_t mod1767646624268779(uint64_t hash) { return hash % 1767646624268779llu; }
-    static uint64_t mod2227095190691797(uint64_t hash) { return hash % 2227095190691797llu; }
-    static uint64_t mod2805964110872297(uint64_t hash) { return hash % 2805964110872297llu; }
-    static uint64_t mod3535293248537579(uint64_t hash) { return hash % 3535293248537579llu; }
-    static uint64_t mod4454190381383713(uint64_t hash) { return hash % 4454190381383713llu; }
-    static uint64_t mod5611928221744609(uint64_t hash) { return hash % 5611928221744609llu; }
-    static uint64_t mod7070586497075177(uint64_t hash) { return hash % 7070586497075177llu; }
-    static uint64_t mod8908380762767489(uint64_t hash) { return hash % 8908380762767489llu; }
-    static uint64_t mod11223856443489329(uint64_t hash) { return hash % 11223856443489329llu; }
-    static uint64_t mod14141172994150357(uint64_t hash) { return hash % 14141172994150357llu; }
-    static uint64_t mod17816761525534927(uint64_t hash) { return hash % 17816761525534927llu; }
-    static uint64_t mod22447712886978529(uint64_t hash) { return hash % 22447712886978529llu; }
-    static uint64_t mod28282345988300791(uint64_t hash) { return hash % 28282345988300791llu; }
-    static uint64_t mod35633523051069991(uint64_t hash) { return hash % 35633523051069991llu; }
-    static uint64_t mod44895425773957261(uint64_t hash) { return hash % 44895425773957261llu; }
-    static uint64_t mod56564691976601587(uint64_t hash) { return hash % 56564691976601587llu; }
-    static uint64_t mod71267046102139967(uint64_t hash) { return hash % 71267046102139967llu; }
-    static uint64_t mod89790851547914507(uint64_t hash) { return hash % 89790851547914507llu; }
-    static uint64_t mod113129383953203213(uint64_t hash) { return hash % 113129383953203213llu; }
-    static uint64_t mod142534092204280003(uint64_t hash) { return hash % 142534092204280003llu; }
-    static uint64_t mod179581703095829107(uint64_t hash) { return hash % 179581703095829107llu; }
-    static uint64_t mod226258767906406483(uint64_t hash) { return hash % 226258767906406483llu; }
-    static uint64_t mod285068184408560057(uint64_t hash) { return hash % 285068184408560057llu; }
-    static uint64_t mod359163406191658253(uint64_t hash) { return hash % 359163406191658253llu; }
-    static uint64_t mod452517535812813007(uint64_t hash) { return hash % 452517535812813007llu; }
-    static uint64_t mod570136368817120201(uint64_t hash) { return hash % 570136368817120201llu; }
-    static uint64_t mod718326812383316683(uint64_t hash) { return hash % 718326812383316683llu; }
-    static uint64_t mod905035071625626043(uint64_t hash) { return hash % 905035071625626043llu; }
-    static uint64_t mod1140272737634240411(uint64_t hash) { return hash % 1140272737634240411llu; }
-    static uint64_t mod1436653624766633509(uint64_t hash) { return hash % 1436653624766633509llu; }
-    static uint64_t mod1810070143251252131(uint64_t hash) { return hash % 1810070143251252131llu; }
-    static uint64_t mod2280545475268481167(uint64_t hash) { return hash % 2280545475268481167llu; }
-    static uint64_t mod2873307249533267101(uint64_t hash) { return hash % 2873307249533267101llu; }
-    static uint64_t mod3620140286502504283(uint64_t hash) { return hash % 3620140286502504283llu; }
-    static uint64_t mod4561090950536962147(uint64_t hash) { return hash % 4561090950536962147llu; }
-    static uint64_t mod5746614499066534157(uint64_t hash) { return hash % 5746614499066534157llu; }
-    static uint64_t mod7240280573005008577(uint64_t hash) { return hash % 7240280573005008577llu; }
-    static uint64_t mod9122181901073924329(uint64_t hash) { return hash % 9122181901073924329llu; }
-    static uint64_t mod11493228998133068689(uint64_t hash) { return hash % 11493228998133068689llu; }
-    static uint64_t mod14480561146010017169(uint64_t hash) { return hash % 14480561146010017169llu; }
-    static uint64_t mod18446744073709551557(uint64_t hash) { return hash % 18446744073709551557llu; }
+struct prime_number_hash_policy {
+  static uint64_t mod0(uint64_t) {
+    return 0llu;
+  }
+  static uint64_t mod2(uint64_t hash) {
+    return hash % 2llu;
+  }
+  static uint64_t mod3(uint64_t hash) {
+    return hash % 3llu;
+  }
+  static uint64_t mod5(uint64_t hash) {
+    return hash % 5llu;
+  }
+  static uint64_t mod7(uint64_t hash) {
+    return hash % 7llu;
+  }
+  static uint64_t mod11(uint64_t hash) {
+    return hash % 11llu;
+  }
+  static uint64_t mod13(uint64_t hash) {
+    return hash % 13llu;
+  }
+  static uint64_t mod17(uint64_t hash) {
+    return hash % 17llu;
+  }
+  static uint64_t mod23(uint64_t hash) {
+    return hash % 23llu;
+  }
+  static uint64_t mod29(uint64_t hash) {
+    return hash % 29llu;
+  }
+  static uint64_t mod37(uint64_t hash) {
+    return hash % 37llu;
+  }
+  static uint64_t mod47(uint64_t hash) {
+    return hash % 47llu;
+  }
+  static uint64_t mod59(uint64_t hash) {
+    return hash % 59llu;
+  }
+  static uint64_t mod73(uint64_t hash) {
+    return hash % 73llu;
+  }
+  static uint64_t mod97(uint64_t hash) {
+    return hash % 97llu;
+  }
+  static uint64_t mod127(uint64_t hash) {
+    return hash % 127llu;
+  }
+  static uint64_t mod151(uint64_t hash) {
+    return hash % 151llu;
+  }
+  static uint64_t mod197(uint64_t hash) {
+    return hash % 197llu;
+  }
+  static uint64_t mod251(uint64_t hash) {
+    return hash % 251llu;
+  }
+  static uint64_t mod313(uint64_t hash) {
+    return hash % 313llu;
+  }
+  static uint64_t mod397(uint64_t hash) {
+    return hash % 397llu;
+  }
+  static uint64_t mod499(uint64_t hash) {
+    return hash % 499llu;
+  }
+  static uint64_t mod631(uint64_t hash) {
+    return hash % 631llu;
+  }
+  static uint64_t mod797(uint64_t hash) {
+    return hash % 797llu;
+  }
+  static uint64_t mod1009(uint64_t hash) {
+    return hash % 1009llu;
+  }
+  static uint64_t mod1259(uint64_t hash) {
+    return hash % 1259llu;
+  }
+  static uint64_t mod1597(uint64_t hash) {
+    return hash % 1597llu;
+  }
+  static uint64_t mod2011(uint64_t hash) {
+    return hash % 2011llu;
+  }
+  static uint64_t mod2539(uint64_t hash) {
+    return hash % 2539llu;
+  }
+  static uint64_t mod3203(uint64_t hash) {
+    return hash % 3203llu;
+  }
+  static uint64_t mod4027(uint64_t hash) {
+    return hash % 4027llu;
+  }
+  static uint64_t mod5087(uint64_t hash) {
+    return hash % 5087llu;
+  }
+  static uint64_t mod6421(uint64_t hash) {
+    return hash % 6421llu;
+  }
+  static uint64_t mod8089(uint64_t hash) {
+    return hash % 8089llu;
+  }
+  static uint64_t mod10193(uint64_t hash) {
+    return hash % 10193llu;
+  }
+  static uint64_t mod12853(uint64_t hash) {
+    return hash % 12853llu;
+  }
+  static uint64_t mod16193(uint64_t hash) {
+    return hash % 16193llu;
+  }
+  static uint64_t mod20399(uint64_t hash) {
+    return hash % 20399llu;
+  }
+  static uint64_t mod25717(uint64_t hash) {
+    return hash % 25717llu;
+  }
+  static uint64_t mod32401(uint64_t hash) {
+    return hash % 32401llu;
+  }
+  static uint64_t mod40823(uint64_t hash) {
+    return hash % 40823llu;
+  }
+  static uint64_t mod51437(uint64_t hash) {
+    return hash % 51437llu;
+  }
+  static uint64_t mod64811(uint64_t hash) {
+    return hash % 64811llu;
+  }
+  static uint64_t mod81649(uint64_t hash) {
+    return hash % 81649llu;
+  }
+  static uint64_t mod102877(uint64_t hash) {
+    return hash % 102877llu;
+  }
+  static uint64_t mod129607(uint64_t hash) {
+    return hash % 129607llu;
+  }
+  static uint64_t mod163307(uint64_t hash) {
+    return hash % 163307llu;
+  }
+  static uint64_t mod205759(uint64_t hash) {
+    return hash % 205759llu;
+  }
+  static uint64_t mod259229(uint64_t hash) {
+    return hash % 259229llu;
+  }
+  static uint64_t mod326617(uint64_t hash) {
+    return hash % 326617llu;
+  }
+  static uint64_t mod411527(uint64_t hash) {
+    return hash % 411527llu;
+  }
+  static uint64_t mod518509(uint64_t hash) {
+    return hash % 518509llu;
+  }
+  static uint64_t mod653267(uint64_t hash) {
+    return hash % 653267llu;
+  }
+  static uint64_t mod823117(uint64_t hash) {
+    return hash % 823117llu;
+  }
+  static uint64_t mod1037059(uint64_t hash) {
+    return hash % 1037059llu;
+  }
+  static uint64_t mod1306601(uint64_t hash) {
+    return hash % 1306601llu;
+  }
+  static uint64_t mod1646237(uint64_t hash) {
+    return hash % 1646237llu;
+  }
+  static uint64_t mod2074129(uint64_t hash) {
+    return hash % 2074129llu;
+  }
+  static uint64_t mod2613229(uint64_t hash) {
+    return hash % 2613229llu;
+  }
+  static uint64_t mod3292489(uint64_t hash) {
+    return hash % 3292489llu;
+  }
+  static uint64_t mod4148279(uint64_t hash) {
+    return hash % 4148279llu;
+  }
+  static uint64_t mod5226491(uint64_t hash) {
+    return hash % 5226491llu;
+  }
+  static uint64_t mod6584983(uint64_t hash) {
+    return hash % 6584983llu;
+  }
+  static uint64_t mod8296553(uint64_t hash) {
+    return hash % 8296553llu;
+  }
+  static uint64_t mod10453007(uint64_t hash) {
+    return hash % 10453007llu;
+  }
+  static uint64_t mod13169977(uint64_t hash) {
+    return hash % 13169977llu;
+  }
+  static uint64_t mod16593127(uint64_t hash) {
+    return hash % 16593127llu;
+  }
+  static uint64_t mod20906033(uint64_t hash) {
+    return hash % 20906033llu;
+  }
+  static uint64_t mod26339969(uint64_t hash) {
+    return hash % 26339969llu;
+  }
+  static uint64_t mod33186281(uint64_t hash) {
+    return hash % 33186281llu;
+  }
+  static uint64_t mod41812097(uint64_t hash) {
+    return hash % 41812097llu;
+  }
+  static uint64_t mod52679969(uint64_t hash) {
+    return hash % 52679969llu;
+  }
+  static uint64_t mod66372617(uint64_t hash) {
+    return hash % 66372617llu;
+  }
+  static uint64_t mod83624237(uint64_t hash) {
+    return hash % 83624237llu;
+  }
+  static uint64_t mod105359939(uint64_t hash) {
+    return hash % 105359939llu;
+  }
+  static uint64_t mod132745199(uint64_t hash) {
+    return hash % 132745199llu;
+  }
+  static uint64_t mod167248483(uint64_t hash) {
+    return hash % 167248483llu;
+  }
+  static uint64_t mod210719881(uint64_t hash) {
+    return hash % 210719881llu;
+  }
+  static uint64_t mod265490441(uint64_t hash) {
+    return hash % 265490441llu;
+  }
+  static uint64_t mod334496971(uint64_t hash) {
+    return hash % 334496971llu;
+  }
+  static uint64_t mod421439783(uint64_t hash) {
+    return hash % 421439783llu;
+  }
+  static uint64_t mod530980861(uint64_t hash) {
+    return hash % 530980861llu;
+  }
+  static uint64_t mod668993977(uint64_t hash) {
+    return hash % 668993977llu;
+  }
+  static uint64_t mod842879579(uint64_t hash) {
+    return hash % 842879579llu;
+  }
+  static uint64_t mod1061961721(uint64_t hash) {
+    return hash % 1061961721llu;
+  }
+  static uint64_t mod1337987929(uint64_t hash) {
+    return hash % 1337987929llu;
+  }
+  static uint64_t mod1685759167(uint64_t hash) {
+    return hash % 1685759167llu;
+  }
+  static uint64_t mod2123923447(uint64_t hash) {
+    return hash % 2123923447llu;
+  }
+  static uint64_t mod2675975881(uint64_t hash) {
+    return hash % 2675975881llu;
+  }
+  static uint64_t mod3371518343(uint64_t hash) {
+    return hash % 3371518343llu;
+  }
+  static uint64_t mod4247846927(uint64_t hash) {
+    return hash % 4247846927llu;
+  }
+  static uint64_t mod5351951779(uint64_t hash) {
+    return hash % 5351951779llu;
+  }
+  static uint64_t mod6743036717(uint64_t hash) {
+    return hash % 6743036717llu;
+  }
+  static uint64_t mod8495693897(uint64_t hash) {
+    return hash % 8495693897llu;
+  }
+  static uint64_t mod10703903591(uint64_t hash) {
+    return hash % 10703903591llu;
+  }
+  static uint64_t mod13486073473(uint64_t hash) {
+    return hash % 13486073473llu;
+  }
+  static uint64_t mod16991387857(uint64_t hash) {
+    return hash % 16991387857llu;
+  }
+  static uint64_t mod21407807219(uint64_t hash) {
+    return hash % 21407807219llu;
+  }
+  static uint64_t mod26972146961(uint64_t hash) {
+    return hash % 26972146961llu;
+  }
+  static uint64_t mod33982775741(uint64_t hash) {
+    return hash % 33982775741llu;
+  }
+  static uint64_t mod42815614441(uint64_t hash) {
+    return hash % 42815614441llu;
+  }
+  static uint64_t mod53944293929(uint64_t hash) {
+    return hash % 53944293929llu;
+  }
+  static uint64_t mod67965551447(uint64_t hash) {
+    return hash % 67965551447llu;
+  }
+  static uint64_t mod85631228929(uint64_t hash) {
+    return hash % 85631228929llu;
+  }
+  static uint64_t mod107888587883(uint64_t hash) {
+    return hash % 107888587883llu;
+  }
+  static uint64_t mod135931102921(uint64_t hash) {
+    return hash % 135931102921llu;
+  }
+  static uint64_t mod171262457903(uint64_t hash) {
+    return hash % 171262457903llu;
+  }
+  static uint64_t mod215777175787(uint64_t hash) {
+    return hash % 215777175787llu;
+  }
+  static uint64_t mod271862205833(uint64_t hash) {
+    return hash % 271862205833llu;
+  }
+  static uint64_t mod342524915839(uint64_t hash) {
+    return hash % 342524915839llu;
+  }
+  static uint64_t mod431554351609(uint64_t hash) {
+    return hash % 431554351609llu;
+  }
+  static uint64_t mod543724411781(uint64_t hash) {
+    return hash % 543724411781llu;
+  }
+  static uint64_t mod685049831731(uint64_t hash) {
+    return hash % 685049831731llu;
+  }
+  static uint64_t mod863108703229(uint64_t hash) {
+    return hash % 863108703229llu;
+  }
+  static uint64_t mod1087448823553(uint64_t hash) {
+    return hash % 1087448823553llu;
+  }
+  static uint64_t mod1370099663459(uint64_t hash) {
+    return hash % 1370099663459llu;
+  }
+  static uint64_t mod1726217406467(uint64_t hash) {
+    return hash % 1726217406467llu;
+  }
+  static uint64_t mod2174897647073(uint64_t hash) {
+    return hash % 2174897647073llu;
+  }
+  static uint64_t mod2740199326961(uint64_t hash) {
+    return hash % 2740199326961llu;
+  }
+  static uint64_t mod3452434812973(uint64_t hash) {
+    return hash % 3452434812973llu;
+  }
+  static uint64_t mod4349795294267(uint64_t hash) {
+    return hash % 4349795294267llu;
+  }
+  static uint64_t mod5480398654009(uint64_t hash) {
+    return hash % 5480398654009llu;
+  }
+  static uint64_t mod6904869625999(uint64_t hash) {
+    return hash % 6904869625999llu;
+  }
+  static uint64_t mod8699590588571(uint64_t hash) {
+    return hash % 8699590588571llu;
+  }
+  static uint64_t mod10960797308051(uint64_t hash) {
+    return hash % 10960797308051llu;
+  }
+  static uint64_t mod13809739252051(uint64_t hash) {
+    return hash % 13809739252051llu;
+  }
+  static uint64_t mod17399181177241(uint64_t hash) {
+    return hash % 17399181177241llu;
+  }
+  static uint64_t mod21921594616111(uint64_t hash) {
+    return hash % 21921594616111llu;
+  }
+  static uint64_t mod27619478504183(uint64_t hash) {
+    return hash % 27619478504183llu;
+  }
+  static uint64_t mod34798362354533(uint64_t hash) {
+    return hash % 34798362354533llu;
+  }
+  static uint64_t mod43843189232363(uint64_t hash) {
+    return hash % 43843189232363llu;
+  }
+  static uint64_t mod55238957008387(uint64_t hash) {
+    return hash % 55238957008387llu;
+  }
+  static uint64_t mod69596724709081(uint64_t hash) {
+    return hash % 69596724709081llu;
+  }
+  static uint64_t mod87686378464759(uint64_t hash) {
+    return hash % 87686378464759llu;
+  }
+  static uint64_t mod110477914016779(uint64_t hash) {
+    return hash % 110477914016779llu;
+  }
+  static uint64_t mod139193449418173(uint64_t hash) {
+    return hash % 139193449418173llu;
+  }
+  static uint64_t mod175372756929481(uint64_t hash) {
+    return hash % 175372756929481llu;
+  }
+  static uint64_t mod220955828033581(uint64_t hash) {
+    return hash % 220955828033581llu;
+  }
+  static uint64_t mod278386898836457(uint64_t hash) {
+    return hash % 278386898836457llu;
+  }
+  static uint64_t mod350745513859007(uint64_t hash) {
+    return hash % 350745513859007llu;
+  }
+  static uint64_t mod441911656067171(uint64_t hash) {
+    return hash % 441911656067171llu;
+  }
+  static uint64_t mod556773797672909(uint64_t hash) {
+    return hash % 556773797672909llu;
+  }
+  static uint64_t mod701491027718027(uint64_t hash) {
+    return hash % 701491027718027llu;
+  }
+  static uint64_t mod883823312134381(uint64_t hash) {
+    return hash % 883823312134381llu;
+  }
+  static uint64_t mod1113547595345903(uint64_t hash) {
+    return hash % 1113547595345903llu;
+  }
+  static uint64_t mod1402982055436147(uint64_t hash) {
+    return hash % 1402982055436147llu;
+  }
+  static uint64_t mod1767646624268779(uint64_t hash) {
+    return hash % 1767646624268779llu;
+  }
+  static uint64_t mod2227095190691797(uint64_t hash) {
+    return hash % 2227095190691797llu;
+  }
+  static uint64_t mod2805964110872297(uint64_t hash) {
+    return hash % 2805964110872297llu;
+  }
+  static uint64_t mod3535293248537579(uint64_t hash) {
+    return hash % 3535293248537579llu;
+  }
+  static uint64_t mod4454190381383713(uint64_t hash) {
+    return hash % 4454190381383713llu;
+  }
+  static uint64_t mod5611928221744609(uint64_t hash) {
+    return hash % 5611928221744609llu;
+  }
+  static uint64_t mod7070586497075177(uint64_t hash) {
+    return hash % 7070586497075177llu;
+  }
+  static uint64_t mod8908380762767489(uint64_t hash) {
+    return hash % 8908380762767489llu;
+  }
+  static uint64_t mod11223856443489329(uint64_t hash) {
+    return hash % 11223856443489329llu;
+  }
+  static uint64_t mod14141172994150357(uint64_t hash) {
+    return hash % 14141172994150357llu;
+  }
+  static uint64_t mod17816761525534927(uint64_t hash) {
+    return hash % 17816761525534927llu;
+  }
+  static uint64_t mod22447712886978529(uint64_t hash) {
+    return hash % 22447712886978529llu;
+  }
+  static uint64_t mod28282345988300791(uint64_t hash) {
+    return hash % 28282345988300791llu;
+  }
+  static uint64_t mod35633523051069991(uint64_t hash) {
+    return hash % 35633523051069991llu;
+  }
+  static uint64_t mod44895425773957261(uint64_t hash) {
+    return hash % 44895425773957261llu;
+  }
+  static uint64_t mod56564691976601587(uint64_t hash) {
+    return hash % 56564691976601587llu;
+  }
+  static uint64_t mod71267046102139967(uint64_t hash) {
+    return hash % 71267046102139967llu;
+  }
+  static uint64_t mod89790851547914507(uint64_t hash) {
+    return hash % 89790851547914507llu;
+  }
+  static uint64_t mod113129383953203213(uint64_t hash) {
+    return hash % 113129383953203213llu;
+  }
+  static uint64_t mod142534092204280003(uint64_t hash) {
+    return hash % 142534092204280003llu;
+  }
+  static uint64_t mod179581703095829107(uint64_t hash) {
+    return hash % 179581703095829107llu;
+  }
+  static uint64_t mod226258767906406483(uint64_t hash) {
+    return hash % 226258767906406483llu;
+  }
+  static uint64_t mod285068184408560057(uint64_t hash) {
+    return hash % 285068184408560057llu;
+  }
+  static uint64_t mod359163406191658253(uint64_t hash) {
+    return hash % 359163406191658253llu;
+  }
+  static uint64_t mod452517535812813007(uint64_t hash) {
+    return hash % 452517535812813007llu;
+  }
+  static uint64_t mod570136368817120201(uint64_t hash) {
+    return hash % 570136368817120201llu;
+  }
+  static uint64_t mod718326812383316683(uint64_t hash) {
+    return hash % 718326812383316683llu;
+  }
+  static uint64_t mod905035071625626043(uint64_t hash) {
+    return hash % 905035071625626043llu;
+  }
+  static uint64_t mod1140272737634240411(uint64_t hash) {
+    return hash % 1140272737634240411llu;
+  }
+  static uint64_t mod1436653624766633509(uint64_t hash) {
+    return hash % 1436653624766633509llu;
+  }
+  static uint64_t mod1810070143251252131(uint64_t hash) {
+    return hash % 1810070143251252131llu;
+  }
+  static uint64_t mod2280545475268481167(uint64_t hash) {
+    return hash % 2280545475268481167llu;
+  }
+  static uint64_t mod2873307249533267101(uint64_t hash) {
+    return hash % 2873307249533267101llu;
+  }
+  static uint64_t mod3620140286502504283(uint64_t hash) {
+    return hash % 3620140286502504283llu;
+  }
+  static uint64_t mod4561090950536962147(uint64_t hash) {
+    return hash % 4561090950536962147llu;
+  }
+  static uint64_t mod5746614499066534157(uint64_t hash) {
+    return hash % 5746614499066534157llu;
+  }
+  static uint64_t mod7240280573005008577(uint64_t hash) {
+    return hash % 7240280573005008577llu;
+  }
+  static uint64_t mod9122181901073924329(uint64_t hash) {
+    return hash % 9122181901073924329llu;
+  }
+  static uint64_t mod11493228998133068689(uint64_t hash) {
+    return hash % 11493228998133068689llu;
+  }
+  static uint64_t mod14480561146010017169(uint64_t hash) {
+    return hash % 14480561146010017169llu;
+  }
+  static uint64_t mod18446744073709551557(uint64_t hash) {
+    return hash % 18446744073709551557llu;
+  }
 
-    using mod_function = uint64_t (*)(uint64_t);
+  using mod_function = uint64_t (*)(uint64_t);
 
-    mod_function next_size_over(uint64_t & size) const
-    {
-        // prime numbers generated by the following method:
-        // 1. start with a prime p = 2
-        // 2. go to wolfram alpha and get p = NextPrime(2 * p)
-        // 3. repeat 2. until you overflow 64 bits
-        // you now have large gaps which you would hit if somebody called reserve() with an unlucky number.
-        // 4. to fill the gaps for every prime p go to wolfram alpha and get ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in the gaps
-        // 5. get PrevPrime(2^64) and put it at the end
-        static constexpr const uint64_t prime_list[] =
-        {
-            2llu, 3llu, 5llu, 7llu, 11llu, 13llu, 17llu, 23llu, 29llu, 37llu, 47llu,
-            59llu, 73llu, 97llu, 127llu, 151llu, 197llu, 251llu, 313llu, 397llu,
-            499llu, 631llu, 797llu, 1009llu, 1259llu, 1597llu, 2011llu, 2539llu,
-            3203llu, 4027llu, 5087llu, 6421llu, 8089llu, 10193llu, 12853llu, 16193llu,
-            20399llu, 25717llu, 32401llu, 40823llu, 51437llu, 64811llu, 81649llu,
-            102877llu, 129607llu, 163307llu, 205759llu, 259229llu, 326617llu,
-            411527llu, 518509llu, 653267llu, 823117llu, 1037059llu, 1306601llu,
-            1646237llu, 2074129llu, 2613229llu, 3292489llu, 4148279llu, 5226491llu,
-            6584983llu, 8296553llu, 10453007llu, 13169977llu, 16593127llu, 20906033llu,
-            26339969llu, 33186281llu, 41812097llu, 52679969llu, 66372617llu,
-            83624237llu, 105359939llu, 132745199llu, 167248483llu, 210719881llu,
-            265490441llu, 334496971llu, 421439783llu, 530980861llu, 668993977llu,
-            842879579llu, 1061961721llu, 1337987929llu, 1685759167llu, 2123923447llu,
-            2675975881llu, 3371518343llu, 4247846927llu, 5351951779llu, 6743036717llu,
-            8495693897llu, 10703903591llu, 13486073473llu, 16991387857llu,
-            21407807219llu, 26972146961llu, 33982775741llu, 42815614441llu,
-            53944293929llu, 67965551447llu, 85631228929llu, 107888587883llu,
-            135931102921llu, 171262457903llu, 215777175787llu, 271862205833llu,
-            342524915839llu, 431554351609llu, 543724411781llu, 685049831731llu,
-            863108703229llu, 1087448823553llu, 1370099663459llu, 1726217406467llu,
-            2174897647073llu, 2740199326961llu, 3452434812973llu, 4349795294267llu,
-            5480398654009llu, 6904869625999llu, 8699590588571llu, 10960797308051llu,
-            13809739252051llu, 17399181177241llu, 21921594616111llu, 27619478504183llu,
-            34798362354533llu, 43843189232363llu, 55238957008387llu, 69596724709081llu,
-            87686378464759llu, 110477914016779llu, 139193449418173llu,
-            175372756929481llu, 220955828033581llu, 278386898836457llu,
-            350745513859007llu, 441911656067171llu, 556773797672909llu,
-            701491027718027llu, 883823312134381llu, 1113547595345903llu,
-            1402982055436147llu, 1767646624268779llu, 2227095190691797llu,
-            2805964110872297llu, 3535293248537579llu, 4454190381383713llu,
-            5611928221744609llu, 7070586497075177llu, 8908380762767489llu,
-            11223856443489329llu, 14141172994150357llu, 17816761525534927llu,
-            22447712886978529llu, 28282345988300791llu, 35633523051069991llu,
-            44895425773957261llu, 56564691976601587llu, 71267046102139967llu,
-            89790851547914507llu, 113129383953203213llu, 142534092204280003llu,
-            179581703095829107llu, 226258767906406483llu, 285068184408560057llu,
-            359163406191658253llu, 452517535812813007llu, 570136368817120201llu,
-            718326812383316683llu, 905035071625626043llu, 1140272737634240411llu,
-            1436653624766633509llu, 1810070143251252131llu, 2280545475268481167llu,
-            2873307249533267101llu, 3620140286502504283llu, 4561090950536962147llu,
-            5746614499066534157llu, 7240280573005008577llu, 9122181901073924329llu,
-            11493228998133068689llu, 14480561146010017169llu, 18446744073709551557llu
-        };
-        static constexpr uint64_t (* const mod_functions[])(uint64_t) =
-        {
-            &mod0, &mod2, &mod3, &mod5, &mod7, &mod11, &mod13, &mod17, &mod23, &mod29, &mod37,
-            &mod47, &mod59, &mod73, &mod97, &mod127, &mod151, &mod197, &mod251, &mod313, &mod397,
-            &mod499, &mod631, &mod797, &mod1009, &mod1259, &mod1597, &mod2011, &mod2539, &mod3203,
-            &mod4027, &mod5087, &mod6421, &mod8089, &mod10193, &mod12853, &mod16193, &mod20399,
-            &mod25717, &mod32401, &mod40823, &mod51437, &mod64811, &mod81649, &mod102877,
-            &mod129607, &mod163307, &mod205759, &mod259229, &mod326617, &mod411527, &mod518509,
-            &mod653267, &mod823117, &mod1037059, &mod1306601, &mod1646237, &mod2074129,
-            &mod2613229, &mod3292489, &mod4148279, &mod5226491, &mod6584983, &mod8296553,
-            &mod10453007, &mod13169977, &mod16593127, &mod20906033, &mod26339969, &mod33186281,
-            &mod41812097, &mod52679969, &mod66372617, &mod83624237, &mod105359939, &mod132745199,
-            &mod167248483, &mod210719881, &mod265490441, &mod334496971, &mod421439783,
-            &mod530980861, &mod668993977, &mod842879579, &mod1061961721, &mod1337987929,
-            &mod1685759167, &mod2123923447, &mod2675975881, &mod3371518343, &mod4247846927,
-            &mod5351951779, &mod6743036717, &mod8495693897, &mod10703903591, &mod13486073473,
-            &mod16991387857, &mod21407807219, &mod26972146961, &mod33982775741, &mod42815614441,
-            &mod53944293929, &mod67965551447, &mod85631228929, &mod107888587883, &mod135931102921,
-            &mod171262457903, &mod215777175787, &mod271862205833, &mod342524915839,
-            &mod431554351609, &mod543724411781, &mod685049831731, &mod863108703229,
-            &mod1087448823553, &mod1370099663459, &mod1726217406467, &mod2174897647073,
-            &mod2740199326961, &mod3452434812973, &mod4349795294267, &mod5480398654009,
-            &mod6904869625999, &mod8699590588571, &mod10960797308051, &mod13809739252051,
-            &mod17399181177241, &mod21921594616111, &mod27619478504183, &mod34798362354533,
-            &mod43843189232363, &mod55238957008387, &mod69596724709081, &mod87686378464759,
-            &mod110477914016779, &mod139193449418173, &mod175372756929481, &mod220955828033581,
-            &mod278386898836457, &mod350745513859007, &mod441911656067171, &mod556773797672909,
-            &mod701491027718027, &mod883823312134381, &mod1113547595345903, &mod1402982055436147,
-            &mod1767646624268779, &mod2227095190691797, &mod2805964110872297, &mod3535293248537579,
-            &mod4454190381383713, &mod5611928221744609, &mod7070586497075177, &mod8908380762767489,
-            &mod11223856443489329, &mod14141172994150357, &mod17816761525534927,
-            &mod22447712886978529, &mod28282345988300791, &mod35633523051069991,
-            &mod44895425773957261, &mod56564691976601587, &mod71267046102139967,
-            &mod89790851547914507, &mod113129383953203213, &mod142534092204280003,
-            &mod179581703095829107, &mod226258767906406483, &mod285068184408560057,
-            &mod359163406191658253, &mod452517535812813007, &mod570136368817120201,
-            &mod718326812383316683, &mod905035071625626043, &mod1140272737634240411,
-            &mod1436653624766633509, &mod1810070143251252131, &mod2280545475268481167,
-            &mod2873307249533267101, &mod3620140286502504283, &mod4561090950536962147,
-            &mod5746614499066534157, &mod7240280573005008577, &mod9122181901073924329,
-            &mod11493228998133068689, &mod14480561146010017169, &mod18446744073709551557
-        };
-        const uint64_t * found = std::lower_bound(std::begin(prime_list), std::end(prime_list) - 1, size);
-        size = *found;
-        return mod_functions[1 + found - prime_list];
-    }
-    void commit(mod_function new_mod_function)
-    {
-        current_mod_function = new_mod_function;
-    }
-    void reset()
-    {
-        current_mod_function = &mod0;
-    }
+  mod_function next_size_over(uint64_t& size) const {
+    // prime numbers generated by the following method:
+    // 1. start with a prime p = 2
+    // 2. go to wolfram alpha and get p = NextPrime(2 * p)
+    // 3. repeat 2. until you overflow 64 bits
+    // you now have large gaps which you would hit if somebody called reserve()
+    // with an unlucky number.
+    // 4. to fill the gaps for every prime p go to wolfram alpha and get
+    // ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in
+    // the gaps
+    // 5. get PrevPrime(2^64) and put it at the end
+    static constexpr const uint64_t prime_list[] = {
+        2llu,
+        3llu,
+        5llu,
+        7llu,
+        11llu,
+        13llu,
+        17llu,
+        23llu,
+        29llu,
+        37llu,
+        47llu,
+        59llu,
+        73llu,
+        97llu,
+        127llu,
+        151llu,
+        197llu,
+        251llu,
+        313llu,
+        397llu,
+        499llu,
+        631llu,
+        797llu,
+        1009llu,
+        1259llu,
+        1597llu,
+        2011llu,
+        2539llu,
+        3203llu,
+        4027llu,
+        5087llu,
+        6421llu,
+        8089llu,
+        10193llu,
+        12853llu,
+        16193llu,
+        20399llu,
+        25717llu,
+        32401llu,
+        40823llu,
+        51437llu,
+        64811llu,
+        81649llu,
+        102877llu,
+        129607llu,
+        163307llu,
+        205759llu,
+        259229llu,
+        326617llu,
+        411527llu,
+        518509llu,
+        653267llu,
+        823117llu,
+        1037059llu,
+        1306601llu,
+        1646237llu,
+        2074129llu,
+        2613229llu,
+        3292489llu,
+        4148279llu,
+        5226491llu,
+        6584983llu,
+        8296553llu,
+        10453007llu,
+        13169977llu,
+        16593127llu,
+        20906033llu,
+        26339969llu,
+        33186281llu,
+        41812097llu,
+        52679969llu,
+        66372617llu,
+        83624237llu,
+        105359939llu,
+        132745199llu,
+        167248483llu,
+        210719881llu,
+        265490441llu,
+        334496971llu,
+        421439783llu,
+        530980861llu,
+        668993977llu,
+        842879579llu,
+        1061961721llu,
+        1337987929llu,
+        1685759167llu,
+        2123923447llu,
+        2675975881llu,
+        3371518343llu,
+        4247846927llu,
+        5351951779llu,
+        6743036717llu,
+        8495693897llu,
+        10703903591llu,
+        13486073473llu,
+        16991387857llu,
+        21407807219llu,
+        26972146961llu,
+        33982775741llu,
+        42815614441llu,
+        53944293929llu,
+        67965551447llu,
+        85631228929llu,
+        107888587883llu,
+        135931102921llu,
+        171262457903llu,
+        215777175787llu,
+        271862205833llu,
+        342524915839llu,
+        431554351609llu,
+        543724411781llu,
+        685049831731llu,
+        863108703229llu,
+        1087448823553llu,
+        1370099663459llu,
+        1726217406467llu,
+        2174897647073llu,
+        2740199326961llu,
+        3452434812973llu,
+        4349795294267llu,
+        5480398654009llu,
+        6904869625999llu,
+        8699590588571llu,
+        10960797308051llu,
+        13809739252051llu,
+        17399181177241llu,
+        21921594616111llu,
+        27619478504183llu,
+        34798362354533llu,
+        43843189232363llu,
+        55238957008387llu,
+        69596724709081llu,
+        87686378464759llu,
+        110477914016779llu,
+        139193449418173llu,
+        175372756929481llu,
+        220955828033581llu,
+        278386898836457llu,
+        350745513859007llu,
+        441911656067171llu,
+        556773797672909llu,
+        701491027718027llu,
+        883823312134381llu,
+        1113547595345903llu,
+        1402982055436147llu,
+        1767646624268779llu,
+        2227095190691797llu,
+        2805964110872297llu,
+        3535293248537579llu,
+        4454190381383713llu,
+        5611928221744609llu,
+        7070586497075177llu,
+        8908380762767489llu,
+        11223856443489329llu,
+        14141172994150357llu,
+        17816761525534927llu,
+        22447712886978529llu,
+        28282345988300791llu,
+        35633523051069991llu,
+        44895425773957261llu,
+        56564691976601587llu,
+        71267046102139967llu,
+        89790851547914507llu,
+        113129383953203213llu,
+        142534092204280003llu,
+        179581703095829107llu,
+        226258767906406483llu,
+        285068184408560057llu,
+        359163406191658253llu,
+        452517535812813007llu,
+        570136368817120201llu,
+        718326812383316683llu,
+        905035071625626043llu,
+        1140272737634240411llu,
+        1436653624766633509llu,
+        1810070143251252131llu,
+        2280545475268481167llu,
+        2873307249533267101llu,
+        3620140286502504283llu,
+        4561090950536962147llu,
+        5746614499066534157llu,
+        7240280573005008577llu,
+        9122181901073924329llu,
+        11493228998133068689llu,
+        14480561146010017169llu,
+        18446744073709551557llu};
+    static constexpr uint64_t (*const mod_functions[])(uint64_t) = {
+        &mod0,
+        &mod2,
+        &mod3,
+        &mod5,
+        &mod7,
+        &mod11,
+        &mod13,
+        &mod17,
+        &mod23,
+        &mod29,
+        &mod37,
+        &mod47,
+        &mod59,
+        &mod73,
+        &mod97,
+        &mod127,
+        &mod151,
+        &mod197,
+        &mod251,
+        &mod313,
+        &mod397,
+        &mod499,
+        &mod631,
+        &mod797,
+        &mod1009,
+        &mod1259,
+        &mod1597,
+        &mod2011,
+        &mod2539,
+        &mod3203,
+        &mod4027,
+        &mod5087,
+        &mod6421,
+        &mod8089,
+        &mod10193,
+        &mod12853,
+        &mod16193,
+        &mod20399,
+        &mod25717,
+        &mod32401,
+        &mod40823,
+        &mod51437,
+        &mod64811,
+        &mod81649,
+        &mod102877,
+        &mod129607,
+        &mod163307,
+        &mod205759,
+        &mod259229,
+        &mod326617,
+        &mod411527,
+        &mod518509,
+        &mod653267,
+        &mod823117,
+        &mod1037059,
+        &mod1306601,
+        &mod1646237,
+        &mod2074129,
+        &mod2613229,
+        &mod3292489,
+        &mod4148279,
+        &mod5226491,
+        &mod6584983,
+        &mod8296553,
+        &mod10453007,
+        &mod13169977,
+        &mod16593127,
+        &mod20906033,
+        &mod26339969,
+        &mod33186281,
+        &mod41812097,
+        &mod52679969,
+        &mod66372617,
+        &mod83624237,
+        &mod105359939,
+        &mod132745199,
+        &mod167248483,
+        &mod210719881,
+        &mod265490441,
+        &mod334496971,
+        &mod421439783,
+        &mod530980861,
+        &mod668993977,
+        &mod842879579,
+        &mod1061961721,
+        &mod1337987929,
+        &mod1685759167,
+        &mod2123923447,
+        &mod2675975881,
+        &mod3371518343,
+        &mod4247846927,
+        &mod5351951779,
+        &mod6743036717,
+        &mod8495693897,
+        &mod10703903591,
+        &mod13486073473,
+        &mod16991387857,
+        &mod21407807219,
+        &mod26972146961,
+        &mod33982775741,
+        &mod42815614441,
+        &mod53944293929,
+        &mod67965551447,
+        &mod85631228929,
+        &mod107888587883,
+        &mod135931102921,
+        &mod171262457903,
+        &mod215777175787,
+        &mod271862205833,
+        &mod342524915839,
+        &mod431554351609,
+        &mod543724411781,
+        &mod685049831731,
+        &mod863108703229,
+        &mod1087448823553,
+        &mod1370099663459,
+        &mod1726217406467,
+        &mod2174897647073,
+        &mod2740199326961,
+        &mod3452434812973,
+        &mod4349795294267,
+        &mod5480398654009,
+        &mod6904869625999,
+        &mod8699590588571,
+        &mod10960797308051,
+        &mod13809739252051,
+        &mod17399181177241,
+        &mod21921594616111,
+        &mod27619478504183,
+        &mod34798362354533,
+        &mod43843189232363,
+        &mod55238957008387,
+        &mod69596724709081,
+        &mod87686378464759,
+        &mod110477914016779,
+        &mod139193449418173,
+        &mod175372756929481,
+        &mod220955828033581,
+        &mod278386898836457,
+        &mod350745513859007,
+        &mod441911656067171,
+        &mod556773797672909,
+        &mod701491027718027,
+        &mod883823312134381,
+        &mod1113547595345903,
+        &mod1402982055436147,
+        &mod1767646624268779,
+        &mod2227095190691797,
+        &mod2805964110872297,
+        &mod3535293248537579,
+        &mod4454190381383713,
+        &mod5611928221744609,
+        &mod7070586497075177,
+        &mod8908380762767489,
+        &mod11223856443489329,
+        &mod14141172994150357,
+        &mod17816761525534927,
+        &mod22447712886978529,
+        &mod28282345988300791,
+        &mod35633523051069991,
+        &mod44895425773957261,
+        &mod56564691976601587,
+        &mod71267046102139967,
+        &mod89790851547914507,
+        &mod113129383953203213,
+        &mod142534092204280003,
+        &mod179581703095829107,
+        &mod226258767906406483,
+        &mod285068184408560057,
+        &mod359163406191658253,
+        &mod452517535812813007,
+        &mod570136368817120201,
+        &mod718326812383316683,
+        &mod905035071625626043,
+        &mod1140272737634240411,
+        &mod1436653624766633509,
+        &mod1810070143251252131,
+        &mod2280545475268481167,
+        &mod2873307249533267101,
+        &mod3620140286502504283,
+        &mod4561090950536962147,
+        &mod5746614499066534157,
+        &mod7240280573005008577,
+        &mod9122181901073924329,
+        &mod11493228998133068689,
+        &mod14480561146010017169,
+        &mod18446744073709551557};
+    const uint64_t* found = std::lower_bound(
+        std::begin(prime_list), std::end(prime_list) - 1, size);
+    size = *found;
+    return mod_functions[1 + found - prime_list];
+  }
+  void commit(mod_function new_mod_function) {
+    current_mod_function = new_mod_function;
+  }
+  void reset() {
+    current_mod_function = &mod0;
+  }
 
-    uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const
-    {
-        return current_mod_function(hash);
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index > num_slots_minus_one ? current_mod_function(index) : index;
-    }
+  uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/)
+      const {
+    return current_mod_function(hash);
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index > num_slots_minus_one ? current_mod_function(index) : index;
+  }
 
-private:
-    mod_function current_mod_function = &mod0;
+ private:
+  mod_function current_mod_function = &mod0;
 };
 
-struct power_of_two_hash_policy
-{
-    uint64_t index_for_hash(uint64_t hash, uint64_t num_slots_minus_one) const
-    {
-        return hash & num_slots_minus_one;
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index_for_hash(index, num_slots_minus_one);
-    }
-    int8_t next_size_over(uint64_t & size) const
-    {
-        size = detailv3::next_power_of_two(size);
-        return 0;
-    }
-    void commit(int8_t)
-    {
-    }
-    void reset()
-    {
-    }
-
+struct power_of_two_hash_policy {
+  uint64_t index_for_hash(uint64_t hash, uint64_t num_slots_minus_one) const {
+    return hash & num_slots_minus_one;
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index_for_hash(index, num_slots_minus_one);
+  }
+  int8_t next_size_over(uint64_t& size) const {
+    size = detailv3::next_power_of_two(size);
+    return 0;
+  }
+  void commit(int8_t) {}
+  void reset() {}
 };
 
-struct fibonacci_hash_policy
-{
-    uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const
-    {
-        return (11400714819323198485ull * hash) >> shift;
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index & num_slots_minus_one;
-    }
+struct fibonacci_hash_policy {
+  uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/)
+      const {
+    return (11400714819323198485ull * hash) >> shift;
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index & num_slots_minus_one;
+  }
 
-    int8_t next_size_over(uint64_t & size) const
-    {
-        size = std::max(uint64_t(2), detailv3::next_power_of_two(size));
-        return 64 - detailv3::log2(size);
-    }
-    void commit(int8_t shift)
-    {
-        this->shift = shift;
-    }
-    void reset()
-    {
-        shift = 63;
-    }
+  int8_t next_size_over(uint64_t& size) const {
+    size = std::max(uint64_t(2), detailv3::next_power_of_two(size));
+    return 64 - detailv3::log2(size);
+  }
+  void commit(int8_t shift) {
+    this->shift = shift;
+  }
+  void reset() {
+    shift = 63;
+  }
 
-private:
-    int8_t shift = 63;
+ private:
+  int8_t shift = 63;
 };
 
-template<typename K, typename V, typename H = std::hash<K>, typename E = std::equal_to<K>, typename A = std::allocator<std::pair<K, V> > >
+template <
+    typename K,
+    typename V,
+    typename H = std::hash<K>,
+    typename E = std::equal_to<K>,
+    typename A = std::allocator<std::pair<K, V>>>
 class flat_hash_map
-        : public detailv3::sherwood_v3_table
-        <
-            std::pair<K, V>,
-            K,
-            H,
-            detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
-            E,
-            detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
-            A,
-            typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<std::pair<K, V>>>
-        >
-{
-    using Table = detailv3::sherwood_v3_table
-    <
-        std::pair<K, V>,
-        K,
-        H,
-        detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
-        E,
-        detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
-        A,
-        typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<std::pair<K, V>>>
-    >;
-public:
+    : public detailv3::sherwood_v3_table<
+          std::pair<K, V>,
+          K,
+          H,
+          detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
+          E,
+          detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
+          A,
+          typename std::allocator_traits<A>::template rebind_alloc<
+              detailv3::sherwood_v3_entry<std::pair<K, V>>>> {
+  using Table = detailv3::sherwood_v3_table<
+      std::pair<K, V>,
+      K,
+      H,
+      detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
+      E,
+      detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
+      A,
+      typename std::allocator_traits<A>::template rebind_alloc<
+          detailv3::sherwood_v3_entry<std::pair<K, V>>>>;
 
-    using key_type = K;
-    using mapped_type = V;
+ public:
+  using key_type = K;
+  using mapped_type = V;
 
-    using Table::Table;
-    flat_hash_map()
-    {
-    }
+  using Table::Table;
+  flat_hash_map() {}
 
-    inline V & operator[](const K & key)
-    {
-        return emplace(key, convertible_to_value()).first->second;
-    }
-    inline V & operator[](K && key)
-    {
-        return emplace(std::move(key), convertible_to_value()).first->second;
-    }
-    V & at(const K & key)
-    {
-        auto found = this->find(key);
-        if (found == this->end())
-            throw std::out_of_range("Argument passed to at() was not in the map.");
-        return found->second;
-    }
-    const V & at(const K & key) const
-    {
-        auto found = this->find(key);
-        if (found == this->end())
-            throw std::out_of_range("Argument passed to at() was not in the map.");
-        return found->second;
-    }
+  inline V& operator[](const K& key) {
+    return emplace(key, convertible_to_value()).first->second;
+  }
+  inline V& operator[](K&& key) {
+    return emplace(std::move(key), convertible_to_value()).first->second;
+  }
+  V& at(const K& key) {
+    auto found = this->find(key);
+    if (found == this->end())
+      throw std::out_of_range("Argument passed to at() was not in the map.");
+    return found->second;
+  }
+  const V& at(const K& key) const {
+    auto found = this->find(key);
+    if (found == this->end())
+      throw std::out_of_range("Argument passed to at() was not in the map.");
+    return found->second;
+  }
 
-    using Table::emplace;
-    std::pair<typename Table::iterator, bool> emplace()
-    {
-        return emplace(key_type(), convertible_to_value());
-    }
-    template<typename M>
-    std::pair<typename Table::iterator, bool> insert_or_assign(const key_type & key, M && m)
-    {
-        auto emplace_result = emplace(key, std::forward<M>(m));
-        if (!emplace_result.second)
-            emplace_result.first->second = std::forward<M>(m);
-        return emplace_result;
-    }
-    template<typename M>
-    std::pair<typename Table::iterator, bool> insert_or_assign(key_type && key, M && m)
-    {
-        auto emplace_result = emplace(std::move(key), std::forward<M>(m));
-        if (!emplace_result.second)
-            emplace_result.first->second = std::forward<M>(m);
-        return emplace_result;
-    }
-    template<typename M>
-    typename Table::iterator insert_or_assign(typename Table::const_iterator, const key_type & key, M && m)
-    {
-        return insert_or_assign(key, std::forward<M>(m)).first;
-    }
-    template<typename M>
-    typename Table::iterator insert_or_assign(typename Table::const_iterator, key_type && key, M && m)
-    {
-        return insert_or_assign(std::move(key), std::forward<M>(m)).first;
-    }
+  using Table::emplace;
+  std::pair<typename Table::iterator, bool> emplace() {
+    return emplace(key_type(), convertible_to_value());
+  }
+  template <typename M>
+  std::pair<typename Table::iterator, bool> insert_or_assign(
+      const key_type& key,
+      M&& m) {
+    auto emplace_result = emplace(key, std::forward<M>(m));
+    if (!emplace_result.second)
+      emplace_result.first->second = std::forward<M>(m);
+    return emplace_result;
+  }
+  template <typename M>
+  std::pair<typename Table::iterator, bool> insert_or_assign(
+      key_type&& key,
+      M&& m) {
+    auto emplace_result = emplace(std::move(key), std::forward<M>(m));
+    if (!emplace_result.second)
+      emplace_result.first->second = std::forward<M>(m);
+    return emplace_result;
+  }
+  template <typename M>
+  typename Table::iterator insert_or_assign(
+      typename Table::const_iterator,
+      const key_type& key,
+      M&& m) {
+    return insert_or_assign(key, std::forward<M>(m)).first;
+  }
+  template <typename M>
+  typename Table::iterator insert_or_assign(
+      typename Table::const_iterator,
+      key_type&& key,
+      M&& m) {
+    return insert_or_assign(std::move(key), std::forward<M>(m)).first;
+  }
 
-    friend bool operator==(const flat_hash_map & lhs, const flat_hash_map & rhs)
-    {
-        if (lhs.size() != rhs.size())
-            return false;
-        for (const typename Table::value_type & value : lhs)
-        {
-            auto found = rhs.find(value.first);
-            if (found == rhs.end())
-                return false;
-            else if (value.second != found->second)
-                return false;
-        }
-        return true;
-    }
-    friend bool operator!=(const flat_hash_map & lhs, const flat_hash_map & rhs)
-    {
-        return !(lhs == rhs);
+  friend bool operator==(const flat_hash_map& lhs, const flat_hash_map& rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    for (const typename Table::value_type& value : lhs) {
+      auto found = rhs.find(value.first);
+      if (found == rhs.end())
+        return false;
+      else if (value.second != found->second)
+        return false;
     }
+    return true;
+  }
+  friend bool operator!=(const flat_hash_map& lhs, const flat_hash_map& rhs) {
+    return !(lhs == rhs);
+  }
 
-private:
-    struct convertible_to_value
-    {
-        operator V() const
-        {
-            return V();
-        }
-    };
+ private:
+  struct convertible_to_value {
+    operator V() const {
+      return V();
+    }
+  };
 };
 
-template<typename T, typename H = std::hash<T>, typename E = std::equal_to<T>, typename A = std::allocator<T> >
+template <
+    typename T,
+    typename H = std::hash<T>,
+    typename E = std::equal_to<T>,
+    typename A = std::allocator<T>>
 class flat_hash_set
-        : public detailv3::sherwood_v3_table
-        <
-            T,
-            T,
-            H,
-            detailv3::functor_storage<uint64_t, H>,
-            E,
-            detailv3::functor_storage<bool, E>,
-            A,
-            typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<T>>
-        >
-{
-    using Table = detailv3::sherwood_v3_table
-    <
-        T,
-        T,
-        H,
-        detailv3::functor_storage<uint64_t, H>,
-        E,
-        detailv3::functor_storage<bool, E>,
-        A,
-        typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<T>>
-    >;
-public:
+    : public detailv3::sherwood_v3_table<
+          T,
+          T,
+          H,
+          detailv3::functor_storage<uint64_t, H>,
+          E,
+          detailv3::functor_storage<bool, E>,
+          A,
+          typename std::allocator_traits<A>::template rebind_alloc<
+              detailv3::sherwood_v3_entry<T>>> {
+  using Table = detailv3::sherwood_v3_table<
+      T,
+      T,
+      H,
+      detailv3::functor_storage<uint64_t, H>,
+      E,
+      detailv3::functor_storage<bool, E>,
+      A,
+      typename std::allocator_traits<A>::template rebind_alloc<
+          detailv3::sherwood_v3_entry<T>>>;
 
-    using key_type = T;
+ public:
+  using key_type = T;
 
-    using Table::Table;
-    flat_hash_set()
-    {
-    }
+  using Table::Table;
+  flat_hash_set() {}
 
-    template<typename... Args>
-    std::pair<typename Table::iterator, bool> emplace(Args &&... args)
-    {
-        return Table::emplace(T(std::forward<Args>(args)...));
-    }
-    std::pair<typename Table::iterator, bool> emplace(const key_type & arg)
-    {
-        return Table::emplace(arg);
-    }
-    std::pair<typename Table::iterator, bool> emplace(key_type & arg)
-    {
-        return Table::emplace(arg);
-    }
-    std::pair<typename Table::iterator, bool> emplace(const key_type && arg)
-    {
-        return Table::emplace(std::move(arg));
-    }
-    std::pair<typename Table::iterator, bool> emplace(key_type && arg)
-    {
-        return Table::emplace(std::move(arg));
-    }
+  template <typename... Args>
+  std::pair<typename Table::iterator, bool> emplace(Args&&... args) {
+    return Table::emplace(T(std::forward<Args>(args)...));
+  }
+  std::pair<typename Table::iterator, bool> emplace(const key_type& arg) {
+    return Table::emplace(arg);
+  }
+  std::pair<typename Table::iterator, bool> emplace(key_type& arg) {
+    return Table::emplace(arg);
+  }
+  std::pair<typename Table::iterator, bool> emplace(const key_type&& arg) {
+    return Table::emplace(std::move(arg));
+  }
+  std::pair<typename Table::iterator, bool> emplace(key_type&& arg) {
+    return Table::emplace(std::move(arg));
+  }
 
-    friend bool operator==(const flat_hash_set & lhs, const flat_hash_set & rhs)
-    {
-        if (lhs.size() != rhs.size())
-            return false;
-        for (const T & value : lhs)
-        {
-            if (rhs.find(value) == rhs.end())
-                return false;
-        }
-        return true;
-    }
-    friend bool operator!=(const flat_hash_set & lhs, const flat_hash_set & rhs)
-    {
-        return !(lhs == rhs);
+  friend bool operator==(const flat_hash_set& lhs, const flat_hash_set& rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    for (const T& value : lhs) {
+      if (rhs.find(value) == rhs.end())
+        return false;
     }
+    return true;
+  }
+  friend bool operator!=(const flat_hash_set& lhs, const flat_hash_set& rhs) {
+    return !(lhs == rhs);
+  }
 };
 
-
-template<typename T>
-struct power_of_two_std_hash : std::hash<T>
-{
-    typedef ska::power_of_two_hash_policy hash_policy;
+template <typename T>
+struct power_of_two_std_hash : std::hash<T> {
+  typedef ska::power_of_two_hash_policy hash_policy;
 };
 
 } // end namespace ska
diff --git a/c10/util/hash.h b/c10/util/hash.h
index 3c493a58213..58866de9938 100644
--- a/c10/util/hash.h
+++ b/c10/util/hash.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <c10/util/complex.h>
 #include <functional>
 #include <vector>
-#include <c10/util/complex.h>
 namespace c10 {
 
 // NOTE: hash_combine is based on implementation from Boost
@@ -147,5 +147,4 @@ struct hash<c10::complex<T>> {
   }
 };
 
-
 } // namespace c10
diff --git a/c10/util/in_place.h b/c10/util/in_place.h
index 9689fe10e4d..62ddf5e6a8c 100644
--- a/c10/util/in_place.h
+++ b/c10/util/in_place.h
@@ -4,13 +4,19 @@
 
 namespace c10 {
 
-struct in_place_t { explicit in_place_t() = default; };
+struct in_place_t {
+  explicit in_place_t() = default;
+};
 
 template <std::size_t I>
-struct in_place_index_t { explicit in_place_index_t() = default; };
+struct in_place_index_t {
+  explicit in_place_index_t() = default;
+};
 
 template <typename T>
-struct in_place_type_t { explicit in_place_type_t() = default; };
+struct in_place_type_t {
+  explicit in_place_type_t() = default;
+};
 
 constexpr in_place_t in_place{};
 
diff --git a/c10/util/intrusive_ptr.h b/c10/util/intrusive_ptr.h
index 693ff33146d..1be22075983 100644
--- a/c10/util/intrusive_ptr.h
+++ b/c10/util/intrusive_ptr.h
@@ -14,16 +14,16 @@ class class_;
 namespace c10 {
 class intrusive_ptr_target;
 namespace raw {
-  namespace weak_intrusive_ptr {
-    inline void incref(intrusive_ptr_target* self);
-  }
-  namespace intrusive_ptr {
-    inline void incref(intrusive_ptr_target * self);
-  }
-
-  // constructor tag used by intrusive_ptr constructors
-  struct DontIncreaseRefcount {};
+namespace weak_intrusive_ptr {
+inline void incref(intrusive_ptr_target* self);
 }
+namespace intrusive_ptr {
+inline void incref(intrusive_ptr_target* self);
+}
+
+// constructor tag used by intrusive_ptr constructors
+struct DontIncreaseRefcount {};
+} // namespace raw
 /**
  * intrusive_ptr<T> is an alternative to shared_ptr<T> that has better
  * performance because it does the refcounting intrusively
@@ -82,7 +82,8 @@ class C10_API intrusive_ptr_target {
 
   template <typename T, typename NullType>
   friend class weak_intrusive_ptr;
-  friend inline void raw::weak_intrusive_ptr::incref(intrusive_ptr_target* self);
+  friend inline void raw::weak_intrusive_ptr::incref(
+      intrusive_ptr_target* self);
 
  protected:
   // protected destructor. We never want to destruct intrusive_ptr_target*
@@ -94,37 +95,46 @@ class C10_API intrusive_ptr_target {
 // some other compilers don't know about -Wterminate or -Wexceptions and
 // will show a warning about unknown warning options otherwise.
 #if defined(_MSC_VER) && !defined(__clang__)
-#  pragma warning(push)
-#  pragma warning(disable: 4297) // function assumed not to throw an exception but does
+#pragma warning(push)
+#pragma warning( \
+    disable : 4297) // function assumed not to throw an exception but does
 #else
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wpragmas"
-#  pragma GCC diagnostic ignored "-Wunknown-warning-option"
-#  pragma GCC diagnostic ignored "-Wterminate"
-#  pragma GCC diagnostic ignored "-Wexceptions"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wunknown-warning-option"
+#pragma GCC diagnostic ignored "-Wterminate"
+#pragma GCC diagnostic ignored "-Wexceptions"
 #endif
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
         refcount_.load() == 0,
         "Tried to destruct an intrusive_ptr_target that still has intrusive_ptr to it");
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
-        // See ~intrusive_ptr for optimization that will frequently result in 1 at destruction time.
+        // See ~intrusive_ptr for optimization that will frequently result in 1
+        // at destruction time.
         weakcount_.load() == 1 || weakcount_.load() == 0,
         "Tried to destruct an intrusive_ptr_target that still has weak_intrusive_ptr to it");
 #if defined(_MSC_VER) && !defined(__clang__)
-#  pragma warning(pop)
+#pragma warning(pop)
 #else
-#  pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif
   }
 
   constexpr intrusive_ptr_target() noexcept : refcount_(0), weakcount_(0) {}
 
-  // intrusive_ptr_target supports copy and move: but refcount and weakcount don't
-  // participate (since they are intrinsic properties of the memory location)
-  intrusive_ptr_target(intrusive_ptr_target&& other) noexcept : intrusive_ptr_target() {}
-  intrusive_ptr_target& operator=(intrusive_ptr_target&& other) noexcept { return *this; }
-  intrusive_ptr_target(const intrusive_ptr_target& other) noexcept : intrusive_ptr_target() {}
-  intrusive_ptr_target& operator=(const intrusive_ptr_target& other) noexcept { return *this; }
+  // intrusive_ptr_target supports copy and move: but refcount and weakcount
+  // don't participate (since they are intrinsic properties of the memory
+  // location)
+  intrusive_ptr_target(intrusive_ptr_target&& other) noexcept
+      : intrusive_ptr_target() {}
+  intrusive_ptr_target& operator=(intrusive_ptr_target&& other) noexcept {
+    return *this;
+  }
+  intrusive_ptr_target(const intrusive_ptr_target& other) noexcept
+      : intrusive_ptr_target() {}
+  intrusive_ptr_target& operator=(const intrusive_ptr_target& other) noexcept {
+    return *this;
+  }
 
  private:
   /**
@@ -152,7 +162,7 @@ struct intrusive_target_default_null_type final {
   }
 };
 
-template<class TTarget, class ToNullType, class FromNullType>
+template <class TTarget, class ToNullType, class FromNullType>
 TTarget* assign_ptr_(TTarget* rhs) {
   if (FromNullType::singleton() == rhs) {
     return ToNullType::singleton();
@@ -198,7 +208,8 @@ class intrusive_ptr final {
 //  this is a problem for classes that contain pointers to themselves
 //  static_assert(
 //      std::is_base_of<intrusive_ptr_target, TTarget>::value,
-//      "intrusive_ptr can only be used for classes that inherit from intrusive_ptr_target.");
+//      "intrusive_ptr can only be used for classes that inherit from
+//      intrusive_ptr_target.");
 #ifndef _WIN32
   // This static_assert triggers on MSVC
   //  error C2131: expression did not evaluate to a constant
@@ -207,7 +218,10 @@ class intrusive_ptr final {
       "NullType must have a constexpr singleton() method");
 #endif
   static_assert(
-      std::is_base_of<TTarget, typename std::remove_pointer<decltype(NullType::singleton())>::type>::value,
+      std::is_base_of<
+          TTarget,
+          typename std::remove_pointer<decltype(NullType::singleton())>::type>::
+          value,
       "NullType::singleton() must return a element_type* pointer");
 
   TTarget* target_;
@@ -228,7 +242,8 @@ class intrusive_ptr final {
 
   void retain_() {
     if (target_ != NullType::singleton()) {
-      size_t new_refcount = detail::atomic_refcount_increment(target_->refcount_);
+      size_t new_refcount =
+          detail::atomic_refcount_increment(target_->refcount_);
       TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
           new_refcount != 1,
           "intrusive_ptr: Cannot increase refcount after it reached zero.");
@@ -236,10 +251,11 @@ class intrusive_ptr final {
   }
 
   void reset_() noexcept {
-    if (target_ != NullType::singleton() && detail::atomic_refcount_decrement(target_->refcount_) == 0) {
-      // justification for const_cast: release_resources is basically a destructor
-      // and a destructor always mutates the object, even for const objects.
-      // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
+    if (target_ != NullType::singleton() &&
+        detail::atomic_refcount_decrement(target_->refcount_) == 0) {
+      // justification for const_cast: release_resources is basically a
+      // destructor and a destructor always mutates the object, even for const
+      // objects. NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
       const_cast<std::remove_const_t<TTarget>*>(target_)->release_resources();
 
       // See comment above about weakcount. As long as refcount>0,
@@ -298,7 +314,8 @@ class intrusive_ptr final {
 
   template <class From, class FromNullType>
   /* implicit */ intrusive_ptr(intrusive_ptr<From, FromNullType>&& rhs) noexcept
-      : target_(detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
+      : target_(
+            detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. intrusive_ptr move constructor got pointer of wrong type.");
@@ -310,9 +327,9 @@ class intrusive_ptr final {
   }
 
   template <class From, class FromNullType>
-  /* implicit */ intrusive_ptr(
-      const intrusive_ptr<From, FromNullType>& rhs)
-      : target_(detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
+  /* implicit */ intrusive_ptr(const intrusive_ptr<From, FromNullType>& rhs)
+      : target_(
+            detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. intrusive_ptr copy constructor got pointer of wrong type.");
@@ -328,8 +345,7 @@ class intrusive_ptr final {
   }
 
   template <class From, class FromNullType>
-      intrusive_ptr& operator=(intrusive_ptr<From, FromNullType>&& rhs) &
-      noexcept {
+  intrusive_ptr& operator=(intrusive_ptr<From, FromNullType>&& rhs) & noexcept {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. intrusive_ptr move assignment got pointer of wrong type.");
@@ -343,7 +359,7 @@ class intrusive_ptr final {
   }
 
   template <class From, class FromNullType>
-      intrusive_ptr& operator=(const intrusive_ptr<From, NullType>& rhs) & {
+  intrusive_ptr& operator=(const intrusive_ptr<From, NullType>& rhs) & {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. intrusive_ptr copy assignment got pointer of wrong type.");
@@ -555,7 +571,10 @@ class weak_intrusive_ptr final {
       "NullType must have a constexpr singleton() method");
 #endif
   static_assert(
-      std::is_base_of<TTarget, typename std::remove_pointer<decltype(NullType::singleton())>::type>::value,
+      std::is_base_of<
+          TTarget,
+          typename std::remove_pointer<decltype(NullType::singleton())>::type>::
+          value,
       "NullType::singleton() must return a element_type* pointer");
 
   TTarget* target_;
@@ -565,7 +584,8 @@ class weak_intrusive_ptr final {
 
   void retain_() {
     if (target_ != NullType::singleton()) {
-      size_t new_weakcount = detail::atomic_weakcount_increment(target_->weakcount_);
+      size_t new_weakcount =
+          detail::atomic_weakcount_increment(target_->weakcount_);
       TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
           new_weakcount != 1,
           "weak_intrusive_ptr: Cannot increase weakcount after it reached zero.");
@@ -573,7 +593,8 @@ class weak_intrusive_ptr final {
   }
 
   void reset_() noexcept {
-    if (target_ != NullType::singleton() && detail::atomic_weakcount_decrement(target_->weakcount_) == 0) {
+    if (target_ != NullType::singleton() &&
+        detail::atomic_weakcount_decrement(target_->weakcount_) == 0) {
       // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
       delete target_;
     }
@@ -597,22 +618,23 @@ class weak_intrusive_ptr final {
   template <class From, class FromNullType>
   /* implicit */ weak_intrusive_ptr(
       weak_intrusive_ptr<From, FromNullType>&& rhs) noexcept
-      : target_(detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
+      : target_(
+            detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. weak_intrusive_ptr move constructor got pointer of wrong type.");
     rhs.target_ = FromNullType::singleton();
   }
 
-  weak_intrusive_ptr(const weak_intrusive_ptr& rhs)
-      : target_(rhs.target_) {
+  weak_intrusive_ptr(const weak_intrusive_ptr& rhs) : target_(rhs.target_) {
     retain_();
   }
 
   template <class From, class FromNullType>
   /* implicit */ weak_intrusive_ptr(
       const weak_intrusive_ptr<From, FromNullType>& rhs)
-      : target_(detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
+      : target_(
+            detail::assign_ptr_<TTarget, NullType, FromNullType>(rhs.target_)) {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. weak_intrusive_ptr copy constructor got pointer of wrong type.");
@@ -628,9 +650,8 @@ class weak_intrusive_ptr final {
   }
 
   template <class From, class FromNullType>
-      weak_intrusive_ptr& operator=(
-          weak_intrusive_ptr<From, FromNullType>&& rhs) &
-      noexcept {
+  weak_intrusive_ptr& operator=(
+      weak_intrusive_ptr<From, FromNullType>&& rhs) & noexcept {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. weak_intrusive_ptr move assignment got pointer of wrong type.");
@@ -643,15 +664,16 @@ class weak_intrusive_ptr final {
     return operator=<TTarget, NullType>(rhs);
   }
 
-  weak_intrusive_ptr& operator=(const intrusive_ptr<TTarget, NullType>& rhs) & noexcept {
+  weak_intrusive_ptr& operator=(
+      const intrusive_ptr<TTarget, NullType>& rhs) & noexcept {
     weak_intrusive_ptr tmp(rhs);
     swap(tmp);
     return *this;
   }
 
   template <class From, class FromNullType>
-      weak_intrusive_ptr& operator=(
-          const weak_intrusive_ptr<From, NullType>& rhs) & {
+  weak_intrusive_ptr& operator=(
+      const weak_intrusive_ptr<From, NullType>& rhs) & {
     static_assert(
         std::is_convertible<From*, TTarget*>::value,
         "Type mismatch. weak_intrusive_ptr copy assignment got pointer of wrong type.");
@@ -699,7 +721,8 @@ class weak_intrusive_ptr final {
     if (target_ == NullType::singleton()) {
       return 0;
     }
-    return target_->refcount_.load(std::memory_order_acquire); // refcount, not weakcount!
+    return target_->refcount_.load(
+        std::memory_order_acquire); // refcount, not weakcount!
   }
 
   size_t weak_use_count() const noexcept {
@@ -724,7 +747,8 @@ class weak_intrusive_ptr final {
           // Return nullptr.
           return intrusive_ptr<TTarget, NullType>();
         }
-      } while (!target_->refcount_.compare_exchange_weak(refcount, refcount + 1));
+      } while (
+          !target_->refcount_.compare_exchange_weak(refcount, refcount + 1));
       return intrusive_ptr<TTarget, NullType>(
           target_, raw::DontIncreaseRefcount{});
     }
@@ -758,7 +782,7 @@ class weak_intrusive_ptr final {
     // if refcount == 0, weakcount only must be >0.
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
         owning_weak_ptr == NullType::singleton() ||
-        owning_weak_ptr->weakcount_.load() > 1 ||
+            owning_weak_ptr->weakcount_.load() > 1 ||
             (owning_weak_ptr->refcount_.load() == 0 &&
              owning_weak_ptr->weakcount_.load() > 0),
         "weak_intrusive_ptr: Can only weak_intrusive_ptr::reclaim() owning pointers that were created using weak_intrusive_ptr::release().");
@@ -824,71 +848,71 @@ namespace raw {
 
 namespace intrusive_ptr {
 
-  // WARNING: Unlike the reclaim() API, it is NOT valid to pass
-  // NullType::singleton to this function
-  inline void incref(intrusive_ptr_target* self) {
-    if (self) {
-      detail::atomic_refcount_increment(self->refcount_);
-    }
+// WARNING: Unlike the reclaim() API, it is NOT valid to pass
+// NullType::singleton to this function
+inline void incref(intrusive_ptr_target* self) {
+  if (self) {
+    detail::atomic_refcount_increment(self->refcount_);
   }
+}
 
-  // WARNING: Unlike the reclaim() API, it is NOT valid to pass
-  // NullType::singleton to this function
-  inline void decref(intrusive_ptr_target* self) {
-    // Let it die
-    c10::intrusive_ptr<intrusive_ptr_target>::reclaim(self);
-    // NB: Caller still has 'self' pointer, but it's now invalid.
-    // If you want more safety, used the actual c10::intrusive_ptr class
-  }
+// WARNING: Unlike the reclaim() API, it is NOT valid to pass
+// NullType::singleton to this function
+inline void decref(intrusive_ptr_target* self) {
+  // Let it die
+  c10::intrusive_ptr<intrusive_ptr_target>::reclaim(self);
+  // NB: Caller still has 'self' pointer, but it's now invalid.
+  // If you want more safety, used the actual c10::intrusive_ptr class
+}
 
-  template <typename T>
-  inline T* make_weak(T* self) {
-    // NB: 'this' is a strong pointer, but we return a weak pointer
-    auto ptr = c10::intrusive_ptr<T>::reclaim(self);
-    c10::weak_intrusive_ptr<T> wptr(ptr);
-    ptr.release();
-    return wptr.release();
-  }
+template <typename T>
+inline T* make_weak(T* self) {
+  // NB: 'this' is a strong pointer, but we return a weak pointer
+  auto ptr = c10::intrusive_ptr<T>::reclaim(self);
+  c10::weak_intrusive_ptr<T> wptr(ptr);
+  ptr.release();
+  return wptr.release();
+}
 
-  inline size_t use_count(intrusive_ptr_target* self) {
-    auto ptr = c10::intrusive_ptr<intrusive_ptr_target>::reclaim(self);
-    auto r = ptr.use_count();
-    ptr.release();
-    return r;
-  }
+inline size_t use_count(intrusive_ptr_target* self) {
+  auto ptr = c10::intrusive_ptr<intrusive_ptr_target>::reclaim(self);
+  auto r = ptr.use_count();
+  ptr.release();
+  return r;
+}
 
-} // namespace intrusive_ptr_target
+} // namespace intrusive_ptr
 
 namespace weak_intrusive_ptr {
 
-  inline void incref(weak_intrusive_ptr_target* self) {
-    detail::atomic_weakcount_increment(self->weakcount_);
-  }
+inline void incref(weak_intrusive_ptr_target* self) {
+  detail::atomic_weakcount_increment(self->weakcount_);
+}
 
-  inline void decref(weak_intrusive_ptr_target* self) {
-    // Let it die
-    c10::weak_intrusive_ptr<intrusive_ptr_target>::reclaim(self);
-    // NB: You still "have" the 'self' pointer, but it's now invalid.
-    // If you want more safety, used the actual c10::weak_intrusive_ptr class
-  }
+inline void decref(weak_intrusive_ptr_target* self) {
+  // Let it die
+  c10::weak_intrusive_ptr<intrusive_ptr_target>::reclaim(self);
+  // NB: You still "have" the 'self' pointer, but it's now invalid.
+  // If you want more safety, used the actual c10::weak_intrusive_ptr class
+}
 
-  template <typename T>
-  inline T* lock(T* self) {
-    auto wptr = c10::weak_intrusive_ptr<T>::reclaim(self);
-    auto ptr = wptr.lock();
-    wptr.release();
-    return ptr.release();
-  }
+template <typename T>
+inline T* lock(T* self) {
+  auto wptr = c10::weak_intrusive_ptr<T>::reclaim(self);
+  auto ptr = wptr.lock();
+  wptr.release();
+  return ptr.release();
+}
 
-  // This gives the STRONG refcount of a WEAK pointer
-  inline size_t use_count(weak_intrusive_ptr_target* self) {
-    auto wptr = c10::weak_intrusive_ptr<intrusive_ptr_target>::reclaim(self);
-    auto r = wptr.use_count();
-    wptr.release();
-    return r;
-  }
+// This gives the STRONG refcount of a WEAK pointer
+inline size_t use_count(weak_intrusive_ptr_target* self) {
+  auto wptr = c10::weak_intrusive_ptr<intrusive_ptr_target>::reclaim(self);
+  auto r = wptr.use_count();
+  wptr.release();
+  return r;
+}
 
-} // namespace weak_intrusive_ptr_target
+} // namespace weak_intrusive_ptr
 
 } // namespace raw
 
diff --git a/c10/util/irange.h b/c10/util/irange.h
index 9bd68e1bce2..e734688c81d 100644
--- a/c10/util/irange.h
+++ b/c10/util/irange.h
@@ -13,49 +13,61 @@ namespace c10 {
 
 namespace detail {
 
-template <typename I, typename std::enable_if<std::is_integral<I>::value, int>::type = 0>
+template <
+    typename I,
+    typename std::enable_if<std::is_integral<I>::value, int>::type = 0>
 struct integer_iterator : std::iterator<std::input_iterator_tag, I> {
-    explicit integer_iterator(I value) : value(value) {}
+  explicit integer_iterator(I value) : value(value) {}
 
-    I operator*() const { return value; }
+  I operator*() const {
+    return value;
+  }
 
-    I const* operator->() const { return &value; }
+  I const* operator->() const {
+    return &value;
+  }
 
-    integer_iterator& operator++() {
-        ++value;
-        return *this;
-    }
+  integer_iterator& operator++() {
+    ++value;
+    return *this;
+  }
 
-    integer_iterator operator++(int) {
-        const auto copy = *this;
-        ++*this;
-        return copy;
-    }
+  integer_iterator operator++(int) {
+    const auto copy = *this;
+    ++*this;
+    return copy;
+  }
 
-    bool operator==(const integer_iterator& other) const {
-        return value == other.value;
-    }
+  bool operator==(const integer_iterator& other) const {
+    return value == other.value;
+  }
 
-    bool operator!=(const integer_iterator& other) const {
-        return value != other.value;
-    }
+  bool operator!=(const integer_iterator& other) const {
+    return value != other.value;
+  }
 
  protected:
-    I value;
+  I value;
 };
 
 } // namespace detail
 
-template <typename I, typename std::enable_if<std::is_integral<I>::value, bool>::type = true>
+template <
+    typename I,
+    typename std::enable_if<std::is_integral<I>::value, bool>::type = true>
 struct integer_range {
  public:
-    integer_range(I begin, I end) : begin_(begin), end_(end) {}
-    detail::integer_iterator<I> begin() const { return begin_; }
-    detail::integer_iterator<I> end() const { return end_; }
+  integer_range(I begin, I end) : begin_(begin), end_(end) {}
+  detail::integer_iterator<I> begin() const {
+    return begin_;
+  }
+  detail::integer_iterator<I> end() const {
+    return end_;
+  }
 
  private:
-    detail::integer_iterator<I> begin_;
-    detail::integer_iterator<I> end_;
+  detail::integer_iterator<I> begin_;
+  detail::integer_iterator<I> end_;
 };
 
 /// Creates an integer range for the half-open interval [begin, end)
@@ -65,23 +77,29 @@ struct integer_range {
 template <
     typename Integer1,
     typename Integer2,
-    typename std::enable_if<std::is_integral<Integer1>::value, bool>::type = true,
-    typename std::enable_if<std::is_integral<Integer2>::value, bool>::type = true
->
+    typename std::enable_if<std::is_integral<Integer1>::value, bool>::type =
+        true,
+    typename std::enable_if<std::is_integral<Integer2>::value, bool>::type =
+        true>
 integer_range<Integer2> irange(Integer1 begin, Integer2 end) {
-    //If end<=begin then the range is empty; we can achieve this effect by
-    //choosing the larger of {begin, end} as the loop terminator
-    return {static_cast<Integer2>(begin), std::max(static_cast<Integer2>(begin), end)};
+  // If end<=begin then the range is empty; we can achieve this effect by
+  // choosing the larger of {begin, end} as the loop terminator
+  return {
+      static_cast<Integer2>(begin),
+      std::max(static_cast<Integer2>(begin), end)};
 }
 
 /// Creates an integer range for the half-open interval [0, end)
 /// If end<=begin, then the range is empty
-template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, bool>::type = true>
+template <
+    typename Integer,
+    typename std::enable_if<std::is_integral<Integer>::value, bool>::type =
+        true>
 integer_range<Integer> irange(Integer end) {
-    //If end<=begin then the range is empty; we can achieve this effect by
-    //choosing the larger of {0, end} as the loop terminator
-    //Handles the case where end<0. irange only works for ranges >=0
-    return {Integer(), std::max(Integer(), end)};
+  // If end<=begin then the range is empty; we can achieve this effect by
+  // choosing the larger of {0, end} as the loop terminator
+  // Handles the case where end<0. irange only works for ranges >=0
+  return {Integer(), std::max(Integer(), end)};
 }
 
-} // namespace torch
+} // namespace c10
diff --git a/c10/util/llvmMathExtras.h b/c10/util/llvmMathExtras.h
index e1722b86223..46b3e1e3613 100644
--- a/c10/util/llvmMathExtras.h
+++ b/c10/util/llvmMathExtras.h
@@ -1,865 +1,900 @@
 //===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
- //
- // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
- // See https://llvm.org/LICENSE.txt for license information.
- // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- //
- //===----------------------------------------------------------------------===//
- //
- // This file contains some functions that are useful for math stuff.
- //
- //===----------------------------------------------------------------------===//
-
- #pragma once
-
- #include <algorithm>
- #include <cassert>
- #include <climits>
- #include <cmath>
- #include <cstdint>
- #include <cstring>
- #include <limits>
- #include <type_traits>
-
- #ifdef __ANDROID_NDK__
- #include <android/api-level.h>
- #endif
-
- #ifndef __has_builtin
- # define __has_builtin(x) 0
- #endif
-
- #ifndef LLVM_GNUC_PREREQ
- # if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
- #  define LLVM_GNUC_PREREQ(maj, min, patch) \
-     ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
-      ((maj) << 20) + ((min) << 10) + (patch))
- # elif defined(__GNUC__) && defined(__GNUC_MINOR__)
- #  define LLVM_GNUC_PREREQ(maj, min, patch) \
-     ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
- # else
- #  define LLVM_GNUC_PREREQ(maj, min, patch) 0
- # endif
- #endif
-
- #ifdef _MSC_VER
- // Declare these intrinsics manually rather including intrin.h. It's very
- // expensive, and MathExtras.h is popular.
- // #include <intrin.h>
- extern "C" {
- unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
- unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
- unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
- unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
- }
- #endif
-
- namespace c10 {
- namespace llvm {
- /// The behavior an operation has on an input of 0.
- enum ZeroBehavior {
-   /// The returned value is undefined.
-   ZB_Undefined,
-   /// The returned value is numeric_limits<T>::max()
-   ZB_Max,
-   /// The returned value is numeric_limits<T>::digits
-   ZB_Width
- };
-
- namespace detail {
- template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
-   static std::size_t count(T Val, ZeroBehavior) {
-     if (!Val)
-       return std::numeric_limits<T>::digits;
-     if (Val & 0x1)
-       return 0;
-
-     // Bisection method.
-     std::size_t ZeroBits = 0;
-     T Shift = std::numeric_limits<T>::digits >> 1;
-     T Mask = std::numeric_limits<T>::max() >> Shift;
-     while (Shift) {
-       if ((Val & Mask) == 0) {
-         Val >>= Shift;
-         ZeroBits |= Shift;
-       }
-       Shift >>= 1;
-       Mask >>= Shift;
-     }
-     return ZeroBits;
-   }
- };
-
- #if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
- template <typename T> struct TrailingZerosCounter<T, 4> {
-   static std::size_t count(T Val, ZeroBehavior ZB) {
-     if (ZB != ZB_Undefined && Val == 0)
-       return 32;
-
- #if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
-     return __builtin_ctz(Val);
- #elif defined(_MSC_VER)
-     unsigned long Index;
-     _BitScanForward(&Index, Val);
-     return Index;
- #endif
-   }
- };
-
- #if !defined(_MSC_VER) || defined(_M_X64)
- template <typename T> struct TrailingZerosCounter<T, 8> {
-   static std::size_t count(T Val, ZeroBehavior ZB) {
-     if (ZB != ZB_Undefined && Val == 0)
-       return 64;
-
- #if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
-     return __builtin_ctzll(Val);
- #elif defined(_MSC_VER)
-     unsigned long Index;
-     _BitScanForward64(&Index, Val);
-     return Index;
- #endif
-   }
- };
- #endif
- #endif
- } // namespace detail
-
- /// Count number of 0's from the least significant bit to the most
- ///   stopping at the first 1.
- ///
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
- ///   valid arguments.
- template <typename T>
- std::size_t countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-   static_assert(std::numeric_limits<T>::is_integer &&
-                     !std::numeric_limits<T>::is_signed,
-                 "Only unsigned integral types are allowed.");
-   return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
- }
-
- namespace detail {
- template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
-   static std::size_t count(T Val, ZeroBehavior) {
-     if (!Val)
-       return std::numeric_limits<T>::digits;
-
-     // Bisection method.
-     std::size_t ZeroBits = 0;
-     for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
-       T Tmp = Val >> Shift;
-       if (Tmp)
-         Val = Tmp;
-       else
-         ZeroBits |= Shift;
-     }
-     return ZeroBits;
-   }
- };
-
- #if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
- template <typename T> struct LeadingZerosCounter<T, 4> {
-   static std::size_t count(T Val, ZeroBehavior ZB) {
-     if (ZB != ZB_Undefined && Val == 0)
-       return 32;
-
- #if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
-     return __builtin_clz(Val);
- #elif defined(_MSC_VER)
-     unsigned long Index;
-     _BitScanReverse(&Index, Val);
-     return Index ^ 31;
- #endif
-   }
- };
-
- #if !defined(_MSC_VER) || defined(_M_X64)
- template <typename T> struct LeadingZerosCounter<T, 8> {
-   static std::size_t count(T Val, ZeroBehavior ZB) {
-     if (ZB != ZB_Undefined && Val == 0)
-       return 64;
-
- #if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
-     return __builtin_clzll(Val);
- #elif defined(_MSC_VER)
-     unsigned long Index;
-     _BitScanReverse64(&Index, Val);
-     return Index ^ 63;
- #endif
-   }
- };
- #endif
- #endif
- } // namespace detail
-
- /// Count number of 0's from the most significant bit to the least
- ///   stopping at the first 1.
- ///
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
- ///   valid arguments.
- template <typename T>
- std::size_t countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-   static_assert(std::numeric_limits<T>::is_integer &&
-                     !std::numeric_limits<T>::is_signed,
-                 "Only unsigned integral types are allowed.");
-   return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
- }
-
- /// Get the index of the first set bit starting from the least
- ///   significant bit.
- ///
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
- ///   valid arguments.
- template <typename T> T findFirstSet(T Val, ZeroBehavior ZB = ZB_Max) {
-   if (ZB == ZB_Max && Val == 0)
-     return std::numeric_limits<T>::max();
-
-   return countTrailingZeros(Val, ZB_Undefined);
- }
-
- /// Create a bitmask with the N right-most bits set to 1, and all other
- /// bits set to 0.  Only unsigned types are allowed.
- template <typename T> T maskTrailingOnes(unsigned N) {
-   static_assert(std::is_unsigned<T>::value, "Invalid type!");
-   const unsigned Bits = CHAR_BIT * sizeof(T);
-   assert(N <= Bits && "Invalid bit index");
-   return N == 0 ? 0 : (T(-1) >> (Bits - N));
- }
-
- /// Create a bitmask with the N left-most bits set to 1, and all other
- /// bits set to 0.  Only unsigned types are allowed.
- template <typename T> T maskLeadingOnes(unsigned N) {
-   return ~maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
- }
-
- /// Create a bitmask with the N right-most bits set to 0, and all other
- /// bits set to 1.  Only unsigned types are allowed.
- template <typename T> T maskTrailingZeros(unsigned N) {
-   return maskLeadingOnes<T>(CHAR_BIT * sizeof(T) - N);
- }
-
- /// Create a bitmask with the N left-most bits set to 0, and all other
- /// bits set to 1.  Only unsigned types are allowed.
- template <typename T> T maskLeadingZeros(unsigned N) {
-   return maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
- }
-
- /// Get the index of the last set bit starting from the least
- ///   significant bit.
- ///
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
- ///   valid arguments.
- template <typename T> T findLastSet(T Val, ZeroBehavior ZB = ZB_Max) {
-   if (ZB == ZB_Max && Val == 0)
-     return std::numeric_limits<T>::max();
-
-   // Use ^ instead of - because both gcc and llvm can remove the associated ^
-   // in the __builtin_clz intrinsic on x86.
-   return countLeadingZeros(Val, ZB_Undefined) ^
-          (std::numeric_limits<T>::digits - 1);
- }
-
- /// Macro compressed bit reversal table for 256 bits.
- ///
- /// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
- static const unsigned char BitReverseTable256[256] = {
- #define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
- #define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
- #define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
-   R6(0), R6(2), R6(1), R6(3)
- #undef R2
- #undef R4
- #undef R6
- };
-
- /// Reverse the bits in \p Val.
- template <typename T>
- T reverseBits(T Val) {
-   unsigned char in[sizeof(Val)];
-   unsigned char out[sizeof(Val)];
-   std::memcpy(in, &Val, sizeof(Val));
-   for (unsigned i = 0; i < sizeof(Val); ++i)
-     out[(sizeof(Val) - i) - 1] = BitReverseTable256[in[i]];
-   std::memcpy(&Val, out, sizeof(Val));
-   return Val;
- }
-
- // NOTE: The following support functions use the _32/_64 extensions instead of
- // type overloading so that signed and unsigned integers can be used without
- // ambiguity.
-
- /// Return the high 32 bits of a 64 bit value.
- constexpr inline uint32_t Hi_32(uint64_t Value) {
-   return static_cast<uint32_t>(Value >> 32);
- }
-
- /// Return the low 32 bits of a 64 bit value.
- constexpr inline uint32_t Lo_32(uint64_t Value) {
-   return static_cast<uint32_t>(Value);
- }
-
- /// Make a 64-bit integer from a high / low pair of 32-bit integers.
- constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
-   return ((uint64_t)High << 32) | (uint64_t)Low;
- }
-
- /// Checks if an integer fits into the given bit width.
- template <unsigned N> constexpr inline bool isInt(int64_t x) {
-   return N >= 64 || (-(INT64_C(1)<<(N-1)) <= x && x < (INT64_C(1)<<(N-1)));
- }
- // Template specializations to get better code for common cases.
- template <> constexpr inline bool isInt<8>(int64_t x) {
-   return static_cast<int8_t>(x) == x;
- }
- template <> constexpr inline bool isInt<16>(int64_t x) {
-   return static_cast<int16_t>(x) == x;
- }
- template <> constexpr inline bool isInt<32>(int64_t x) {
-   return static_cast<int32_t>(x) == x;
- }
-
- /// Checks if a signed integer is an N bit number shifted left by S.
- template <unsigned N, unsigned S>
- constexpr inline bool isShiftedInt(int64_t x) {
-   static_assert(
-       N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
-   static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
-   return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
- }
-
- /// Checks if an unsigned integer fits into the given bit width.
- ///
- /// This is written as two functions rather than as simply
- ///
- ///   return N >= 64 || X < (UINT64_C(1) << N);
- ///
- /// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
- /// left too many places.
- template <unsigned N>
- constexpr inline typename std::enable_if<(N < 64), bool>::type
- isUInt(uint64_t X) {
-   static_assert(N > 0, "isUInt<0> doesn't make sense");
-   return X < (UINT64_C(1) << (N));
- }
- template <unsigned N>
- constexpr inline typename std::enable_if<N >= 64, bool>::type
- isUInt(uint64_t X) {
-   return true;
- }
-
- // Template specializations to get better code for common cases.
- template <> constexpr inline bool isUInt<8>(uint64_t x) {
-   return static_cast<uint8_t>(x) == x;
- }
- template <> constexpr inline bool isUInt<16>(uint64_t x) {
-   return static_cast<uint16_t>(x) == x;
- }
- template <> constexpr inline bool isUInt<32>(uint64_t x) {
-   return static_cast<uint32_t>(x) == x;
- }
-
- /// Checks if a unsigned integer is an N bit number shifted left by S.
- template <unsigned N, unsigned S>
- constexpr inline bool isShiftedUInt(uint64_t x) {
-   static_assert(
-       N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
-   static_assert(N + S <= 64,
-                 "isShiftedUInt<N, S> with N + S > 64 is too wide.");
-   // Per the two static_asserts above, S must be strictly less than 64.  So
-   // 1 << S is not undefined behavior.
-   return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
- }
-
- /// Gets the maximum value for a N-bit unsigned integer.
- inline uint64_t maxUIntN(uint64_t N) {
-   assert(N > 0 && N <= 64 && "integer width out of range");
-
-   // uint64_t(1) << 64 is undefined behavior, so we can't do
-   //   (uint64_t(1) << N) - 1
-   // without checking first that N != 64.  But this works and doesn't have a
-   // branch.
-   return UINT64_MAX >> (64 - N);
- }
-
- // Ignore the false warning "Arithmetic overflow" for MSVC
- #ifdef _MSC_VER
- # pragma warning(push)
- # pragma warning(disable : 4146)
- #endif
-
- /// Gets the minimum value for a N-bit signed integer.
- inline int64_t minIntN(int64_t N) {
-   assert(N > 0 && N <= 64 && "integer width out of range");
-
-   return -(UINT64_C(1) << (N - 1));
- }
-
- #ifdef _MSC_VER
- # pragma warning(pop)
- #endif
-
- /// Gets the maximum value for a N-bit signed integer.
- inline int64_t maxIntN(int64_t N) {
-   assert(N > 0 && N <= 64 && "integer width out of range");
-
-   // This relies on two's complement wraparound when N == 64, so we convert to
-   // int64_t only at the very end to avoid UB.
-   return (UINT64_C(1) << (N - 1)) - 1;
- }
-
- /// Checks if an unsigned integer fits into the given (dynamic) bit width.
- inline bool isUIntN(unsigned N, uint64_t x) {
-   return N >= 64 || x <= maxUIntN(N);
- }
-
- /// Checks if an signed integer fits into the given (dynamic) bit width.
- inline bool isIntN(unsigned N, int64_t x) {
-   return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
- }
-
- /// Return true if the argument is a non-empty sequence of ones starting at the
- /// least significant bit with the remainder zero (32 bit version).
- /// Ex. isMask_32(0x0000FFFFU) == true.
- constexpr inline bool isMask_32(uint32_t Value) {
-   return Value && ((Value + 1) & Value) == 0;
- }
-
- /// Return true if the argument is a non-empty sequence of ones starting at the
- /// least significant bit with the remainder zero (64 bit version).
- constexpr inline bool isMask_64(uint64_t Value) {
-   return Value && ((Value + 1) & Value) == 0;
- }
-
- /// Return true if the argument contains a non-empty sequence of ones with the
- /// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.
- constexpr inline bool isShiftedMask_32(uint32_t Value) {
-   return Value && isMask_32((Value - 1) | Value);
- }
-
- /// Return true if the argument contains a non-empty sequence of ones with the
- /// remainder zero (64 bit version.)
- constexpr inline bool isShiftedMask_64(uint64_t Value) {
-   return Value && isMask_64((Value - 1) | Value);
- }
-
- /// Return true if the argument is a power of two > 0.
- /// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
- constexpr inline bool isPowerOf2_32(uint32_t Value) {
-   return Value && !(Value & (Value - 1));
- }
-
- /// Return true if the argument is a power of two > 0 (64 bit edition.)
- constexpr inline bool isPowerOf2_64(uint64_t Value) {
-   return Value && !(Value & (Value - 1));
- }
-
- /// Count the number of ones from the most significant bit to the first
- /// zero bit.
- ///
- /// Ex. countLeadingOnes(0xFF0FFF00) == 8.
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of all ones. Only ZB_Width and
- /// ZB_Undefined are valid arguments.
- template <typename T>
- std::size_t countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-   static_assert(std::numeric_limits<T>::is_integer &&
-                     !std::numeric_limits<T>::is_signed,
-                 "Only unsigned integral types are allowed.");
-   return countLeadingZeros<T>(~Value, ZB);
- }
-
- /// Count the number of ones from the least significant bit to the first
- /// zero bit.
- ///
- /// Ex. countTrailingOnes(0x00FF00FF) == 8.
- /// Only unsigned integral types are allowed.
- ///
- /// \param ZB the behavior on an input of all ones. Only ZB_Width and
- /// ZB_Undefined are valid arguments.
- template <typename T>
- std::size_t countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-   static_assert(std::numeric_limits<T>::is_integer &&
-                     !std::numeric_limits<T>::is_signed,
-                 "Only unsigned integral types are allowed.");
-   return countTrailingZeros<T>(~Value, ZB);
- }
-
- namespace detail {
- template <typename T, std::size_t SizeOfT> struct PopulationCounter {
-   static unsigned count(T Value) {
-     // Generic version, forward to 32 bits.
-     static_assert(SizeOfT <= 4, "Not implemented!");
- #if defined(__GNUC__) && __GNUC__ >= 4
-     return __builtin_popcount(Value);
- #else
-     uint32_t v = Value;
-     v = v - ((v >> 1) & 0x55555555);
-     v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-     return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
- #endif
-   }
- };
-
- template <typename T> struct PopulationCounter<T, 8> {
-   static unsigned count(T Value) {
- #if defined(__GNUC__) && __GNUC__ >= 4
-     return __builtin_popcountll(Value);
- #else
-     uint64_t v = Value;
-     v = v - ((v >> 1) & 0x5555555555555555ULL);
-     v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
-     v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-     return unsigned((uint64_t)(v * 0x0101010101010101ULL) >> 56);
- #endif
-   }
- };
- } // namespace detail
-
- /// Count the number of set bits in a value.
- /// Ex. countPopulation(0xF000F000) = 8
- /// Returns 0 if the word is zero.
- template <typename T>
- inline unsigned countPopulation(T Value) {
-   static_assert(std::numeric_limits<T>::is_integer &&
-                     !std::numeric_limits<T>::is_signed,
-                 "Only unsigned integral types are allowed.");
-   return detail::PopulationCounter<T, sizeof(T)>::count(Value);
- }
-
- /// Return the log base 2 of the specified value.
- inline double Log2(double Value) {
- #if defined(__ANDROID_API__) && __ANDROID_API__ < 18
-   return __builtin_log(Value) / __builtin_log(2.0);
- #else
-   return log2(Value);
- #endif
- }
-
- /// Return the floor log base 2 of the specified value, -1 if the value is zero.
- /// (32 bit edition.)
- /// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2
- inline unsigned Log2_32(uint32_t Value) {
-   return static_cast<unsigned>(31 - countLeadingZeros(Value));
- }
-
- /// Return the floor log base 2 of the specified value, -1 if the value is zero.
- /// (64 bit edition.)
- inline unsigned Log2_64(uint64_t Value) {
-   return static_cast<unsigned>(63 - countLeadingZeros(Value));
- }
-
- /// Return the ceil log base 2 of the specified value, 32 if the value is zero.
- /// (32 bit edition).
- /// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3
- inline unsigned Log2_32_Ceil(uint32_t Value) {
-   return static_cast<unsigned>(32 - countLeadingZeros(Value - 1));
- }
-
- /// Return the ceil log base 2 of the specified value, 64 if the value is zero.
- /// (64 bit edition.)
- inline unsigned Log2_64_Ceil(uint64_t Value) {
-   return static_cast<unsigned>(64 - countLeadingZeros(Value - 1));
- }
-
- /// Return the greatest common divisor of the values using Euclid's algorithm.
- inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
-   while (B) {
-     uint64_t T = B;
-     B = A % B;
-     A = T;
-   }
-   return A;
- }
-
- /// This function takes a 64-bit integer and returns the bit equivalent double.
- inline double BitsToDouble(uint64_t Bits) {
-   double D;
-   static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-   memcpy(&D, &Bits, sizeof(Bits));
-   return D;
- }
-
- /// This function takes a 32-bit integer and returns the bit equivalent float.
- inline float BitsToFloat(uint32_t Bits) {
-   //TODO: Use bit_cast once C++20 becomes available.
-   float F;
-   static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
-   memcpy(&F, &Bits, sizeof(Bits));
-   return F;
- }
-
- /// This function takes a double and returns the bit equivalent 64-bit integer.
- /// Note that copying doubles around changes the bits of NaNs on some hosts,
- /// notably x86, so this routine cannot be used if these bits are needed.
- inline uint64_t DoubleToBits(double Double) {
-   uint64_t Bits;
-   static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-   memcpy(&Bits, &Double, sizeof(Double));
-   return Bits;
- }
-
- /// This function takes a float and returns the bit equivalent 32-bit integer.
- /// Note that copying floats around changes the bits of NaNs on some hosts,
- /// notably x86, so this routine cannot be used if these bits are needed.
- inline uint32_t FloatToBits(float Float) {
-   uint32_t Bits;
-   static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
-   memcpy(&Bits, &Float, sizeof(Float));
-   return Bits;
- }
-
- /// A and B are either alignments or offsets. Return the minimum alignment that
- /// may be assumed after adding the two together.
- constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
-   // The largest power of 2 that divides both A and B.
-   //
-   // Replace "-Value" by "1+~Value" in the following commented code to avoid
-   // MSVC warning C4146
-   //    return (A | B) & -(A | B);
-   return (A | B) & (1 + ~(A | B));
- }
-
- /// Aligns \c Addr to \c Alignment bytes, rounding up.
- ///
- /// Alignment should be a power of two.  This method rounds up, so
- /// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
- inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
-   assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&
-          "Alignment is not a power of two!");
-
-   assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
-
-   return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
- }
-
- /// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
- /// bytes, rounding up.
- inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
-   return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
- }
-
- /// Returns the next power of two (in 64-bits) that is strictly greater than A.
- /// Returns zero on overflow.
- inline uint64_t NextPowerOf2(uint64_t A) {
-   A |= (A >> 1);
-   A |= (A >> 2);
-   A |= (A >> 4);
-   A |= (A >> 8);
-   A |= (A >> 16);
-   A |= (A >> 32);
-   return A + 1;
- }
-
- /// Returns the power of two which is less than or equal to the given value.
- /// Essentially, it is a floor operation across the domain of powers of two.
- inline uint64_t PowerOf2Floor(uint64_t A) {
-   if (!A) return 0;
-   return 1ull << (63 - countLeadingZeros(A, ZB_Undefined));
- }
-
- /// Returns the power of two which is greater than or equal to the given value.
- /// Essentially, it is a ceil operation across the domain of powers of two.
- inline uint64_t PowerOf2Ceil(uint64_t A) {
-   if (!A)
-     return 0;
-   return NextPowerOf2(A - 1);
- }
-
- /// Returns the next integer (mod 2**64) that is greater than or equal to
- /// \p Value and is a multiple of \p Align. \p Align must be non-zero.
- ///
- /// If non-zero \p Skew is specified, the return value will be a minimal
- /// integer that is greater than or equal to \p Value and equal to
- /// \p Align * N + \p Skew for some integer N. If \p Skew is larger than
- /// \p Align, its value is adjusted to '\p Skew mod \p Align'.
- ///
- /// Examples:
- /// \code
- ///   alignTo(5, 8) = 8
- ///   alignTo(17, 8) = 24
- ///   alignTo(~0LL, 8) = 0
- ///   alignTo(321, 255) = 510
- ///
- ///   alignTo(5, 8, 7) = 7
- ///   alignTo(17, 8, 1) = 17
- ///   alignTo(~0LL, 8, 3) = 3
- ///   alignTo(321, 255, 42) = 552
- /// \endcode
- inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-   assert(Align != 0u && "Align can't be 0.");
-   Skew %= Align;
-   return (Value + Align - 1 - Skew) / Align * Align + Skew;
- }
-
- /// Returns the next integer (mod 2**64) that is greater than or equal to
- /// \p Value and is a multiple of \c Align. \c Align must be non-zero.
- template <uint64_t Align> constexpr inline uint64_t alignTo(uint64_t Value) {
-   static_assert(Align != 0u, "Align must be non-zero");
-   return (Value + Align - 1) / Align * Align;
- }
-
- /// Returns the integer ceil(Numerator / Denominator).
- inline uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator) {
-   return alignTo(Numerator, Denominator) / Denominator;
- }
-
- /// \c alignTo for contexts where a constant expression is required.
- /// \sa alignTo
- ///
- /// \todo FIXME: remove when \c constexpr becomes really \c constexpr
- template <uint64_t Align>
- struct AlignTo {
-   static_assert(Align != 0u, "Align must be non-zero");
-   template <uint64_t Value>
-   struct from_value {
-     static const uint64_t value = (Value + Align - 1) / Align * Align;
-   };
- };
-
- /// Returns the largest uint64_t less than or equal to \p Value and is
- /// \p Skew mod \p Align. \p Align must be non-zero
- inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-   assert(Align != 0u && "Align can't be 0.");
-   Skew %= Align;
-   return (Value - Skew) / Align * Align + Skew;
- }
-
- /// Returns the offset to the next integer (mod 2**64) that is greater than
- /// or equal to \p Value and is a multiple of \p Align. \p Align must be
- /// non-zero.
- inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
-   return alignTo(Value, Align) - Value;
- }
-
- /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
- /// Requires 0 < B <= 32.
- template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
-   static_assert(B > 0, "Bit width can't be 0.");
-   static_assert(B <= 32, "Bit width out of range.");
-   return int32_t(X << (32 - B)) >> (32 - B);
- }
-
- /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
- /// Requires 0 < B < 32.
- inline int32_t SignExtend32(uint32_t X, unsigned B) {
-   assert(B > 0 && "Bit width can't be 0.");
-   assert(B <= 32 && "Bit width out of range.");
-   return int32_t(X << (32 - B)) >> (32 - B);
- }
-
- /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
- /// Requires 0 < B < 64.
- template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
-   static_assert(B > 0, "Bit width can't be 0.");
-   static_assert(B <= 64, "Bit width out of range.");
-   return int64_t(x << (64 - B)) >> (64 - B);
- }
-
- /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
- /// Requires 0 < B < 64.
- inline int64_t SignExtend64(uint64_t X, unsigned B) {
-   assert(B > 0 && "Bit width can't be 0.");
-   assert(B <= 64 && "Bit width out of range.");
-   return int64_t(X << (64 - B)) >> (64 - B);
- }
-
- /// Subtract two unsigned integers, X and Y, of type T and return the absolute
- /// value of the result.
- template <typename T>
- typename std::enable_if<std::is_unsigned<T>::value, T>::type
- AbsoluteDifference(T X, T Y) {
-   return std::max(X, Y) - std::min(X, Y);
- }
-
- /// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
- /// maximum representable value of T on overflow.  ResultOverflowed indicates if
- /// the result is larger than the maximum representable value of type T.
- template <typename T>
- typename std::enable_if<std::is_unsigned<T>::value, T>::type
- SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
-   bool Dummy;
-   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-   // Hacker's Delight, p. 29
-   T Z = X + Y;
-   Overflowed = (Z < X || Z < Y);
-   if (Overflowed)
-     return std::numeric_limits<T>::max();
-   else
-     return Z;
- }
-
- /// Multiply two unsigned integers, X and Y, of type T.  Clamp the result to the
- /// maximum representable value of T on overflow.  ResultOverflowed indicates if
- /// the result is larger than the maximum representable value of type T.
- template <typename T>
- typename std::enable_if<std::is_unsigned<T>::value, T>::type
- SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
-   bool Dummy;
-   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-   // Hacker's Delight, p. 30 has a different algorithm, but we don't use that
-   // because it fails for uint16_t (where multiplication can have undefined
-   // behavior due to promotion to int), and requires a division in addition
-   // to the multiplication.
-
-   Overflowed = false;
-
-   // Log2(Z) would be either Log2Z or Log2Z + 1.
-   // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
-   // will necessarily be less than Log2Max as desired.
-   int Log2Z = Log2_64(X) + Log2_64(Y);
-   const T Max = std::numeric_limits<T>::max();
-   int Log2Max = Log2_64(Max);
-   if (Log2Z < Log2Max) {
-     return X * Y;
-   }
-   if (Log2Z > Log2Max) {
-     Overflowed = true;
-     return Max;
-   }
-
-   // We're going to use the top bit, and maybe overflow one
-   // bit past it. Multiply all but the bottom bit then add
-   // that on at the end.
-   T Z = (X >> 1) * Y;
-   if (Z & ~(Max >> 1)) {
-     Overflowed = true;
-     return Max;
-   }
-   Z <<= 1;
-   if (X & 1)
-     return SaturatingAdd(Z, Y, ResultOverflowed);
-
-   return Z;
- }
-
- /// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to
- /// the product. Clamp the result to the maximum representable value of T on
- /// overflow. ResultOverflowed indicates if the result is larger than the
- /// maximum representable value of type T.
- template <typename T>
- typename std::enable_if<std::is_unsigned<T>::value, T>::type
- SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
-   bool Dummy;
-   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-   T Product = SaturatingMultiply(X, Y, &Overflowed);
-   if (Overflowed)
-     return Product;
-
-   return SaturatingAdd(A, Product, &Overflowed);
- }
-
- /// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
- extern const float huge_valf;
- } // End llvm namespace
- } // End c10 namespace
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains some functions that are useful for math stuff.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <climits>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#ifdef __ANDROID_NDK__
+#include <android/api-level.h>
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#ifndef LLVM_GNUC_PREREQ
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#define LLVM_GNUC_PREREQ(maj, min, patch)                             \
+  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
+   ((maj) << 20) + ((min) << 10) + (patch))
+#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
+#define LLVM_GNUC_PREREQ(maj, min, patch) \
+  ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
+#else
+#define LLVM_GNUC_PREREQ(maj, min, patch) 0
+#endif
+#endif
+
+#ifdef _MSC_VER
+// Declare these intrinsics manually rather including intrin.h. It's very
+// expensive, and MathExtras.h is popular.
+// #include <intrin.h>
+extern "C" {
+unsigned char _BitScanForward(unsigned long* _Index, unsigned long _Mask);
+unsigned char _BitScanForward64(unsigned long* _Index, unsigned __int64 _Mask);
+unsigned char _BitScanReverse(unsigned long* _Index, unsigned long _Mask);
+unsigned char _BitScanReverse64(unsigned long* _Index, unsigned __int64 _Mask);
+}
+#endif
+
+namespace c10 {
+namespace llvm {
+/// The behavior an operation has on an input of 0.
+enum ZeroBehavior {
+  /// The returned value is undefined.
+  ZB_Undefined,
+  /// The returned value is numeric_limits<T>::max()
+  ZB_Max,
+  /// The returned value is numeric_limits<T>::digits
+  ZB_Width
+};
+
+namespace detail {
+template <typename T, std::size_t SizeOfT>
+struct TrailingZerosCounter {
+  static std::size_t count(T Val, ZeroBehavior) {
+    if (!Val)
+      return std::numeric_limits<T>::digits;
+    if (Val & 0x1)
+      return 0;
+
+    // Bisection method.
+    std::size_t ZeroBits = 0;
+    T Shift = std::numeric_limits<T>::digits >> 1;
+    T Mask = std::numeric_limits<T>::max() >> Shift;
+    while (Shift) {
+      if ((Val & Mask) == 0) {
+        Val >>= Shift;
+        ZeroBits |= Shift;
+      }
+      Shift >>= 1;
+      Mask >>= Shift;
+    }
+    return ZeroBits;
+  }
+};
+
+#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
+template <typename T>
+struct TrailingZerosCounter<T, 4> {
+  static std::size_t count(T Val, ZeroBehavior ZB) {
+    if (ZB != ZB_Undefined && Val == 0)
+      return 32;
+
+#if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
+    return __builtin_ctz(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanForward(&Index, Val);
+    return Index;
+#endif
+  }
+};
+
+#if !defined(_MSC_VER) || defined(_M_X64)
+template <typename T>
+struct TrailingZerosCounter<T, 8> {
+  static std::size_t count(T Val, ZeroBehavior ZB) {
+    if (ZB != ZB_Undefined && Val == 0)
+      return 64;
+
+#if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+    return __builtin_ctzll(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanForward64(&Index, Val);
+    return Index;
+#endif
+  }
+};
+#endif
+#endif
+} // namespace detail
+
+/// Count number of 0's from the least significant bit to the most
+///   stopping at the first 1.
+///
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
+///   valid arguments.
+template <typename T>
+std::size_t countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+  static_assert(
+      std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
+      "Only unsigned integral types are allowed.");
+  return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
+}
+
+namespace detail {
+template <typename T, std::size_t SizeOfT>
+struct LeadingZerosCounter {
+  static std::size_t count(T Val, ZeroBehavior) {
+    if (!Val)
+      return std::numeric_limits<T>::digits;
+
+    // Bisection method.
+    std::size_t ZeroBits = 0;
+    for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
+      T Tmp = Val >> Shift;
+      if (Tmp)
+        Val = Tmp;
+      else
+        ZeroBits |= Shift;
+    }
+    return ZeroBits;
+  }
+};
+
+#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(_MSC_VER)
+template <typename T>
+struct LeadingZerosCounter<T, 4> {
+  static std::size_t count(T Val, ZeroBehavior ZB) {
+    if (ZB != ZB_Undefined && Val == 0)
+      return 32;
+
+#if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
+    return __builtin_clz(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanReverse(&Index, Val);
+    return Index ^ 31;
+#endif
+  }
+};
+
+#if !defined(_MSC_VER) || defined(_M_X64)
+template <typename T>
+struct LeadingZerosCounter<T, 8> {
+  static std::size_t count(T Val, ZeroBehavior ZB) {
+    if (ZB != ZB_Undefined && Val == 0)
+      return 64;
+
+#if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+    return __builtin_clzll(Val);
+#elif defined(_MSC_VER)
+    unsigned long Index;
+    _BitScanReverse64(&Index, Val);
+    return Index ^ 63;
+#endif
+  }
+};
+#endif
+#endif
+} // namespace detail
+
+/// Count number of 0's from the most significant bit to the least
+///   stopping at the first 1.
+///
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
+///   valid arguments.
+template <typename T>
+std::size_t countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+  static_assert(
+      std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
+      "Only unsigned integral types are allowed.");
+  return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
+}
+
+/// Get the index of the first set bit starting from the least
+///   significant bit.
+///
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
+///   valid arguments.
+template <typename T>
+T findFirstSet(T Val, ZeroBehavior ZB = ZB_Max) {
+  if (ZB == ZB_Max && Val == 0)
+    return std::numeric_limits<T>::max();
+
+  return countTrailingZeros(Val, ZB_Undefined);
+}
+
+/// Create a bitmask with the N right-most bits set to 1, and all other
+/// bits set to 0.  Only unsigned types are allowed.
+template <typename T>
+T maskTrailingOnes(unsigned N) {
+  static_assert(std::is_unsigned<T>::value, "Invalid type!");
+  const unsigned Bits = CHAR_BIT * sizeof(T);
+  assert(N <= Bits && "Invalid bit index");
+  return N == 0 ? 0 : (T(-1) >> (Bits - N));
+}
+
+/// Create a bitmask with the N left-most bits set to 1, and all other
+/// bits set to 0.  Only unsigned types are allowed.
+template <typename T>
+T maskLeadingOnes(unsigned N) {
+  return ~maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
+}
+
+/// Create a bitmask with the N right-most bits set to 0, and all other
+/// bits set to 1.  Only unsigned types are allowed.
+template <typename T>
+T maskTrailingZeros(unsigned N) {
+  return maskLeadingOnes<T>(CHAR_BIT * sizeof(T) - N);
+}
+
+/// Create a bitmask with the N left-most bits set to 0, and all other
+/// bits set to 1.  Only unsigned types are allowed.
+template <typename T>
+T maskLeadingZeros(unsigned N) {
+  return maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
+}
+
+/// Get the index of the last set bit starting from the least
+///   significant bit.
+///
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
+///   valid arguments.
+template <typename T>
+T findLastSet(T Val, ZeroBehavior ZB = ZB_Max) {
+  if (ZB == ZB_Max && Val == 0)
+    return std::numeric_limits<T>::max();
+
+  // Use ^ instead of - because both gcc and llvm can remove the associated ^
+  // in the __builtin_clz intrinsic on x86.
+  return countLeadingZeros(Val, ZB_Undefined) ^
+      (std::numeric_limits<T>::digits - 1);
+}
+
+/// Macro compressed bit reversal table for 256 bits.
+///
+/// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
+static const unsigned char BitReverseTable256[256] = {
+#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
+#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
+#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
+    R6(0),
+    R6(2),
+    R6(1),
+    R6(3)
+#undef R2
+#undef R4
+#undef R6
+};
+
+/// Reverse the bits in \p Val.
+template <typename T>
+T reverseBits(T Val) {
+  unsigned char in[sizeof(Val)];
+  unsigned char out[sizeof(Val)];
+  std::memcpy(in, &Val, sizeof(Val));
+  for (unsigned i = 0; i < sizeof(Val); ++i)
+    out[(sizeof(Val) - i) - 1] = BitReverseTable256[in[i]];
+  std::memcpy(&Val, out, sizeof(Val));
+  return Val;
+}
+
+// NOTE: The following support functions use the _32/_64 extensions instead of
+// type overloading so that signed and unsigned integers can be used without
+// ambiguity.
+
+/// Return the high 32 bits of a 64 bit value.
+constexpr inline uint32_t Hi_32(uint64_t Value) {
+  return static_cast<uint32_t>(Value >> 32);
+}
+
+/// Return the low 32 bits of a 64 bit value.
+constexpr inline uint32_t Lo_32(uint64_t Value) {
+  return static_cast<uint32_t>(Value);
+}
+
+/// Make a 64-bit integer from a high / low pair of 32-bit integers.
+constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
+  return ((uint64_t)High << 32) | (uint64_t)Low;
+}
+
+/// Checks if an integer fits into the given bit width.
+template <unsigned N>
+constexpr inline bool isInt(int64_t x) {
+  return N >= 64 ||
+      (-(INT64_C(1) << (N - 1)) <= x && x < (INT64_C(1) << (N - 1)));
+}
+// Template specializations to get better code for common cases.
+template <>
+constexpr inline bool isInt<8>(int64_t x) {
+  return static_cast<int8_t>(x) == x;
+}
+template <>
+constexpr inline bool isInt<16>(int64_t x) {
+  return static_cast<int16_t>(x) == x;
+}
+template <>
+constexpr inline bool isInt<32>(int64_t x) {
+  return static_cast<int32_t>(x) == x;
+}
+
+/// Checks if a signed integer is an N bit number shifted left by S.
+template <unsigned N, unsigned S>
+constexpr inline bool isShiftedInt(int64_t x) {
+  static_assert(
+      N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
+  static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
+  return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
+}
+
+/// Checks if an unsigned integer fits into the given bit width.
+///
+/// This is written as two functions rather than as simply
+///
+///   return N >= 64 || X < (UINT64_C(1) << N);
+///
+/// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
+/// left too many places.
+template <unsigned N>
+constexpr inline typename std::enable_if<(N < 64), bool>::type isUInt(
+    uint64_t X) {
+  static_assert(N > 0, "isUInt<0> doesn't make sense");
+  return X < (UINT64_C(1) << (N));
+}
+template <unsigned N>
+constexpr inline typename std::enable_if<N >= 64, bool>::type isUInt(
+    uint64_t X) {
+  return true;
+}
+
+// Template specializations to get better code for common cases.
+template <>
+constexpr inline bool isUInt<8>(uint64_t x) {
+  return static_cast<uint8_t>(x) == x;
+}
+template <>
+constexpr inline bool isUInt<16>(uint64_t x) {
+  return static_cast<uint16_t>(x) == x;
+}
+template <>
+constexpr inline bool isUInt<32>(uint64_t x) {
+  return static_cast<uint32_t>(x) == x;
+}
+
+/// Checks if a unsigned integer is an N bit number shifted left by S.
+template <unsigned N, unsigned S>
+constexpr inline bool isShiftedUInt(uint64_t x) {
+  static_assert(
+      N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
+  static_assert(
+      N + S <= 64, "isShiftedUInt<N, S> with N + S > 64 is too wide.");
+  // Per the two static_asserts above, S must be strictly less than 64.  So
+  // 1 << S is not undefined behavior.
+  return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
+}
+
+/// Gets the maximum value for a N-bit unsigned integer.
+inline uint64_t maxUIntN(uint64_t N) {
+  assert(N > 0 && N <= 64 && "integer width out of range");
+
+  // uint64_t(1) << 64 is undefined behavior, so we can't do
+  //   (uint64_t(1) << N) - 1
+  // without checking first that N != 64.  But this works and doesn't have a
+  // branch.
+  return UINT64_MAX >> (64 - N);
+}
+
+// Ignore the false warning "Arithmetic overflow" for MSVC
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4146)
+#endif
+
+/// Gets the minimum value for a N-bit signed integer.
+inline int64_t minIntN(int64_t N) {
+  assert(N > 0 && N <= 64 && "integer width out of range");
+
+  return -(UINT64_C(1) << (N - 1));
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+/// Gets the maximum value for a N-bit signed integer.
+inline int64_t maxIntN(int64_t N) {
+  assert(N > 0 && N <= 64 && "integer width out of range");
+
+  // This relies on two's complement wraparound when N == 64, so we convert to
+  // int64_t only at the very end to avoid UB.
+  return (UINT64_C(1) << (N - 1)) - 1;
+}
+
+/// Checks if an unsigned integer fits into the given (dynamic) bit width.
+inline bool isUIntN(unsigned N, uint64_t x) {
+  return N >= 64 || x <= maxUIntN(N);
+}
+
+/// Checks if an signed integer fits into the given (dynamic) bit width.
+inline bool isIntN(unsigned N, int64_t x) {
+  return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
+}
+
+/// Return true if the argument is a non-empty sequence of ones starting at the
+/// least significant bit with the remainder zero (32 bit version).
+/// Ex. isMask_32(0x0000FFFFU) == true.
+constexpr inline bool isMask_32(uint32_t Value) {
+  return Value && ((Value + 1) & Value) == 0;
+}
+
+/// Return true if the argument is a non-empty sequence of ones starting at the
+/// least significant bit with the remainder zero (64 bit version).
+constexpr inline bool isMask_64(uint64_t Value) {
+  return Value && ((Value + 1) & Value) == 0;
+}
+
+/// Return true if the argument contains a non-empty sequence of ones with the
+/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.
+constexpr inline bool isShiftedMask_32(uint32_t Value) {
+  return Value && isMask_32((Value - 1) | Value);
+}
+
+/// Return true if the argument contains a non-empty sequence of ones with the
+/// remainder zero (64 bit version.)
+constexpr inline bool isShiftedMask_64(uint64_t Value) {
+  return Value && isMask_64((Value - 1) | Value);
+}
+
+/// Return true if the argument is a power of two > 0.
+/// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
+constexpr inline bool isPowerOf2_32(uint32_t Value) {
+  return Value && !(Value & (Value - 1));
+}
+
+/// Return true if the argument is a power of two > 0 (64 bit edition.)
+constexpr inline bool isPowerOf2_64(uint64_t Value) {
+  return Value && !(Value & (Value - 1));
+}
+
+/// Count the number of ones from the most significant bit to the first
+/// zero bit.
+///
+/// Ex. countLeadingOnes(0xFF0FFF00) == 8.
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of all ones. Only ZB_Width and
+/// ZB_Undefined are valid arguments.
+template <typename T>
+std::size_t countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
+  static_assert(
+      std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
+      "Only unsigned integral types are allowed.");
+  return countLeadingZeros<T>(~Value, ZB);
+}
+
+/// Count the number of ones from the least significant bit to the first
+/// zero bit.
+///
+/// Ex. countTrailingOnes(0x00FF00FF) == 8.
+/// Only unsigned integral types are allowed.
+///
+/// \param ZB the behavior on an input of all ones. Only ZB_Width and
+/// ZB_Undefined are valid arguments.
+template <typename T>
+std::size_t countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
+  static_assert(
+      std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
+      "Only unsigned integral types are allowed.");
+  return countTrailingZeros<T>(~Value, ZB);
+}
+
+namespace detail {
+template <typename T, std::size_t SizeOfT>
+struct PopulationCounter {
+  static unsigned count(T Value) {
+    // Generic version, forward to 32 bits.
+    static_assert(SizeOfT <= 4, "Not implemented!");
+#if defined(__GNUC__) && __GNUC__ >= 4
+    return __builtin_popcount(Value);
+#else
+    uint32_t v = Value;
+    v = v - ((v >> 1) & 0x55555555);
+    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+    return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
+#endif
+  }
+};
+
+template <typename T>
+struct PopulationCounter<T, 8> {
+  static unsigned count(T Value) {
+#if defined(__GNUC__) && __GNUC__ >= 4
+    return __builtin_popcountll(Value);
+#else
+    uint64_t v = Value;
+    v = v - ((v >> 1) & 0x5555555555555555ULL);
+    v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
+    v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+    return unsigned((uint64_t)(v * 0x0101010101010101ULL) >> 56);
+#endif
+  }
+};
+} // namespace detail
+
+/// Count the number of set bits in a value.
+/// Ex. countPopulation(0xF000F000) = 8
+/// Returns 0 if the word is zero.
+template <typename T>
+inline unsigned countPopulation(T Value) {
+  static_assert(
+      std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed,
+      "Only unsigned integral types are allowed.");
+  return detail::PopulationCounter<T, sizeof(T)>::count(Value);
+}
+
+/// Return the log base 2 of the specified value.
+inline double Log2(double Value) {
+#if defined(__ANDROID_API__) && __ANDROID_API__ < 18
+  return __builtin_log(Value) / __builtin_log(2.0);
+#else
+  return log2(Value);
+#endif
+}
+
+/// Return the floor log base 2 of the specified value, -1 if the value is zero.
+/// (32 bit edition.)
+/// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2
+inline unsigned Log2_32(uint32_t Value) {
+  return static_cast<unsigned>(31 - countLeadingZeros(Value));
+}
+
+/// Return the floor log base 2 of the specified value, -1 if the value is zero.
+/// (64 bit edition.)
+inline unsigned Log2_64(uint64_t Value) {
+  return static_cast<unsigned>(63 - countLeadingZeros(Value));
+}
+
+/// Return the ceil log base 2 of the specified value, 32 if the value is zero.
+/// (32 bit edition).
+/// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3
+inline unsigned Log2_32_Ceil(uint32_t Value) {
+  return static_cast<unsigned>(32 - countLeadingZeros(Value - 1));
+}
+
+/// Return the ceil log base 2 of the specified value, 64 if the value is zero.
+/// (64 bit edition.)
+inline unsigned Log2_64_Ceil(uint64_t Value) {
+  return static_cast<unsigned>(64 - countLeadingZeros(Value - 1));
+}
+
+/// Return the greatest common divisor of the values using Euclid's algorithm.
+inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
+  while (B) {
+    uint64_t T = B;
+    B = A % B;
+    A = T;
+  }
+  return A;
+}
+
+/// This function takes a 64-bit integer and returns the bit equivalent double.
+inline double BitsToDouble(uint64_t Bits) {
+  double D;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
+  memcpy(&D, &Bits, sizeof(Bits));
+  return D;
+}
+
+/// This function takes a 32-bit integer and returns the bit equivalent float.
+inline float BitsToFloat(uint32_t Bits) {
+  // TODO: Use bit_cast once C++20 becomes available.
+  float F;
+  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
+  memcpy(&F, &Bits, sizeof(Bits));
+  return F;
+}
+
+/// This function takes a double and returns the bit equivalent 64-bit integer.
+/// Note that copying doubles around changes the bits of NaNs on some hosts,
+/// notably x86, so this routine cannot be used if these bits are needed.
+inline uint64_t DoubleToBits(double Double) {
+  uint64_t Bits;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
+  memcpy(&Bits, &Double, sizeof(Double));
+  return Bits;
+}
+
+/// This function takes a float and returns the bit equivalent 32-bit integer.
+/// Note that copying floats around changes the bits of NaNs on some hosts,
+/// notably x86, so this routine cannot be used if these bits are needed.
+inline uint32_t FloatToBits(float Float) {
+  uint32_t Bits;
+  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
+  memcpy(&Bits, &Float, sizeof(Float));
+  return Bits;
+}
+
+/// A and B are either alignments or offsets. Return the minimum alignment that
+/// may be assumed after adding the two together.
+constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
+  // The largest power of 2 that divides both A and B.
+  //
+  // Replace "-Value" by "1+~Value" in the following commented code to avoid
+  // MSVC warning C4146
+  //    return (A | B) & -(A | B);
+  return (A | B) & (1 + ~(A | B));
+}
+
+/// Aligns \c Addr to \c Alignment bytes, rounding up.
+///
+/// Alignment should be a power of two.  This method rounds up, so
+/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
+inline uintptr_t alignAddr(const void* Addr, size_t Alignment) {
+  assert(
+      Alignment && isPowerOf2_64((uint64_t)Alignment) &&
+      "Alignment is not a power of two!");
+
+  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
+
+  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
+}
+
+/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
+/// bytes, rounding up.
+inline size_t alignmentAdjustment(const void* Ptr, size_t Alignment) {
+  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
+}
+
+/// Returns the next power of two (in 64-bits) that is strictly greater than A.
+/// Returns zero on overflow.
+inline uint64_t NextPowerOf2(uint64_t A) {
+  A |= (A >> 1);
+  A |= (A >> 2);
+  A |= (A >> 4);
+  A |= (A >> 8);
+  A |= (A >> 16);
+  A |= (A >> 32);
+  return A + 1;
+}
+
+/// Returns the power of two which is less than or equal to the given value.
+/// Essentially, it is a floor operation across the domain of powers of two.
+inline uint64_t PowerOf2Floor(uint64_t A) {
+  if (!A)
+    return 0;
+  return 1ull << (63 - countLeadingZeros(A, ZB_Undefined));
+}
+
+/// Returns the power of two which is greater than or equal to the given value.
+/// Essentially, it is a ceil operation across the domain of powers of two.
+inline uint64_t PowerOf2Ceil(uint64_t A) {
+  if (!A)
+    return 0;
+  return NextPowerOf2(A - 1);
+}
+
+/// Returns the next integer (mod 2**64) that is greater than or equal to
+/// \p Value and is a multiple of \p Align. \p Align must be non-zero.
+///
+/// If non-zero \p Skew is specified, the return value will be a minimal
+/// integer that is greater than or equal to \p Value and equal to
+/// \p Align * N + \p Skew for some integer N. If \p Skew is larger than
+/// \p Align, its value is adjusted to '\p Skew mod \p Align'.
+///
+/// Examples:
+/// \code
+///   alignTo(5, 8) = 8
+///   alignTo(17, 8) = 24
+///   alignTo(~0LL, 8) = 0
+///   alignTo(321, 255) = 510
+///
+///   alignTo(5, 8, 7) = 7
+///   alignTo(17, 8, 1) = 17
+///   alignTo(~0LL, 8, 3) = 3
+///   alignTo(321, 255, 42) = 552
+/// \endcode
+inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
+  assert(Align != 0u && "Align can't be 0.");
+  Skew %= Align;
+  return (Value + Align - 1 - Skew) / Align * Align + Skew;
+}
+
+/// Returns the next integer (mod 2**64) that is greater than or equal to
+/// \p Value and is a multiple of \c Align. \c Align must be non-zero.
+template <uint64_t Align>
+constexpr inline uint64_t alignTo(uint64_t Value) {
+  static_assert(Align != 0u, "Align must be non-zero");
+  return (Value + Align - 1) / Align * Align;
+}
+
+/// Returns the integer ceil(Numerator / Denominator).
+inline uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator) {
+  return alignTo(Numerator, Denominator) / Denominator;
+}
+
+/// \c alignTo for contexts where a constant expression is required.
+/// \sa alignTo
+///
+/// \todo FIXME: remove when \c constexpr becomes really \c constexpr
+template <uint64_t Align>
+struct AlignTo {
+  static_assert(Align != 0u, "Align must be non-zero");
+  template <uint64_t Value>
+  struct from_value {
+    static const uint64_t value = (Value + Align - 1) / Align * Align;
+  };
+};
+
+/// Returns the largest uint64_t less than or equal to \p Value and is
+/// \p Skew mod \p Align. \p Align must be non-zero
+inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
+  assert(Align != 0u && "Align can't be 0.");
+  Skew %= Align;
+  return (Value - Skew) / Align * Align + Skew;
+}
+
+/// Returns the offset to the next integer (mod 2**64) that is greater than
+/// or equal to \p Value and is a multiple of \p Align. \p Align must be
+/// non-zero.
+inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
+  return alignTo(Value, Align) - Value;
+}
+
+/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
+/// Requires 0 < B <= 32.
+template <unsigned B>
+constexpr inline int32_t SignExtend32(uint32_t X) {
+  static_assert(B > 0, "Bit width can't be 0.");
+  static_assert(B <= 32, "Bit width out of range.");
+  return int32_t(X << (32 - B)) >> (32 - B);
+}
+
+/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
+/// Requires 0 < B < 32.
+inline int32_t SignExtend32(uint32_t X, unsigned B) {
+  assert(B > 0 && "Bit width can't be 0.");
+  assert(B <= 32 && "Bit width out of range.");
+  return int32_t(X << (32 - B)) >> (32 - B);
+}
+
+/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
+/// Requires 0 < B < 64.
+template <unsigned B>
+constexpr inline int64_t SignExtend64(uint64_t x) {
+  static_assert(B > 0, "Bit width can't be 0.");
+  static_assert(B <= 64, "Bit width out of range.");
+  return int64_t(x << (64 - B)) >> (64 - B);
+}
+
+/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
+/// Requires 0 < B < 64.
+inline int64_t SignExtend64(uint64_t X, unsigned B) {
+  assert(B > 0 && "Bit width can't be 0.");
+  assert(B <= 64 && "Bit width out of range.");
+  return int64_t(X << (64 - B)) >> (64 - B);
+}
+
+/// Subtract two unsigned integers, X and Y, of type T and return the absolute
+/// value of the result.
+template <typename T>
+typename std::enable_if<std::is_unsigned<T>::value, T>::type AbsoluteDifference(
+    T X,
+    T Y) {
+  return std::max(X, Y) - std::min(X, Y);
+}
+
+/// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
+/// maximum representable value of T on overflow.  ResultOverflowed indicates if
+/// the result is larger than the maximum representable value of type T.
+template <typename T>
+typename std::enable_if<std::is_unsigned<T>::value, T>::type SaturatingAdd(
+    T X,
+    T Y,
+    bool* ResultOverflowed = nullptr) {
+  bool Dummy;
+  bool& Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
+  // Hacker's Delight, p. 29
+  T Z = X + Y;
+  Overflowed = (Z < X || Z < Y);
+  if (Overflowed)
+    return std::numeric_limits<T>::max();
+  else
+    return Z;
+}
+
+/// Multiply two unsigned integers, X and Y, of type T.  Clamp the result to the
+/// maximum representable value of T on overflow.  ResultOverflowed indicates if
+/// the result is larger than the maximum representable value of type T.
+template <typename T>
+typename std::enable_if<std::is_unsigned<T>::value, T>::type SaturatingMultiply(
+    T X,
+    T Y,
+    bool* ResultOverflowed = nullptr) {
+  bool Dummy;
+  bool& Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
+
+  // Hacker's Delight, p. 30 has a different algorithm, but we don't use that
+  // because it fails for uint16_t (where multiplication can have undefined
+  // behavior due to promotion to int), and requires a division in addition
+  // to the multiplication.
+
+  Overflowed = false;
+
+  // Log2(Z) would be either Log2Z or Log2Z + 1.
+  // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
+  // will necessarily be less than Log2Max as desired.
+  int Log2Z = Log2_64(X) + Log2_64(Y);
+  const T Max = std::numeric_limits<T>::max();
+  int Log2Max = Log2_64(Max);
+  if (Log2Z < Log2Max) {
+    return X * Y;
+  }
+  if (Log2Z > Log2Max) {
+    Overflowed = true;
+    return Max;
+  }
+
+  // We're going to use the top bit, and maybe overflow one
+  // bit past it. Multiply all but the bottom bit then add
+  // that on at the end.
+  T Z = (X >> 1) * Y;
+  if (Z & ~(Max >> 1)) {
+    Overflowed = true;
+    return Max;
+  }
+  Z <<= 1;
+  if (X & 1)
+    return SaturatingAdd(Z, Y, ResultOverflowed);
+
+  return Z;
+}
+
+/// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to
+/// the product. Clamp the result to the maximum representable value of T on
+/// overflow. ResultOverflowed indicates if the result is larger than the
+/// maximum representable value of type T.
+template <typename T>
+typename std::enable_if<std::is_unsigned<T>::value, T>::type
+SaturatingMultiplyAdd(T X, T Y, T A, bool* ResultOverflowed = nullptr) {
+  bool Dummy;
+  bool& Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
+
+  T Product = SaturatingMultiply(X, Y, &Overflowed);
+  if (Overflowed)
+    return Product;
+
+  return SaturatingAdd(A, Product, &Overflowed);
+}
+
+/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
+extern const float huge_valf;
+} // namespace llvm
+} // namespace c10
diff --git a/c10/util/logging_is_not_google_glog.h b/c10/util/logging_is_not_google_glog.h
index 9a743c2025d..2b11c7fbbf2 100644
--- a/c10/util/logging_is_not_google_glog.h
+++ b/c10/util/logging_is_not_google_glog.h
@@ -89,14 +89,14 @@ static_assert(
     "CAFFE2_LOG_THRESHOLD should at most be GLOG_FATAL.");
 // If n is under the compile time caffe log threshold, The _CAFFE_LOG(n)
 // should not generate anything in optimized code.
-#define LOG(n)                                    \
+#define LOG(n)                                 \
   if (::c10::GLOG_##n >= CAFFE2_LOG_THRESHOLD) \
   ::c10::MessageLogger((char*)__FILE__, __LINE__, ::c10::GLOG_##n).stream()
 #define VLOG(n)                   \
   if (-n >= CAFFE2_LOG_THRESHOLD) \
   ::c10::MessageLogger((char*)__FILE__, __LINE__, -n).stream()
 
-#define LOG_IF(n, condition)                                     \
+#define LOG_IF(n, condition)                                  \
   if (::c10::GLOG_##n >= CAFFE2_LOG_THRESHOLD && (condition)) \
   ::c10::MessageLogger((char*)__FILE__, __LINE__, ::c10::GLOG_##n).stream()
 #define VLOG_IF(n, condition)                    \
@@ -107,16 +107,15 @@ static_assert(
 
 // Log with source location information override (to be used in generic
 // warning/error handlers implemented as functions, not macros)
-#define LOG_AT_FILE_LINE(n, file, line)           \
+#define LOG_AT_FILE_LINE(n, file, line)        \
   if (::c10::GLOG_##n >= CAFFE2_LOG_THRESHOLD) \
   ::c10::MessageLogger(file, line, ::c10::GLOG_##n).stream()
 
 // Log only if condition is met.  Otherwise evaluates to void.
-#define FATAL_IF(condition)                                    \
-  condition ? (void)0                                          \
-            : ::c10::LoggerVoidify() &                         \
-          ::c10::MessageLogger(                                \
-              (char*)__FILE__, __LINE__, ::c10::GLOG_FATAL) \
+#define FATAL_IF(condition)                                                  \
+  condition ? (void)0                                                        \
+            : ::c10::LoggerVoidify() &                                       \
+          ::c10::MessageLogger((char*)__FILE__, __LINE__, ::c10::GLOG_FATAL) \
               .stream()
 
 // Check for a given boolean condition.
diff --git a/c10/util/math_compat.h b/c10/util/math_compat.h
index 825e4fbb30a..9a7ee1899d1 100644
--- a/c10/util/math_compat.h
+++ b/c10/util/math_compat.h
@@ -9,145 +9,215 @@
 #include <stdexcept>
 
 namespace std {
-  // Import double versions of these functions from the global namespace.
-  using ::acosh;
-  using ::asinh;
-  using ::atanh;
-  using ::erf;
-  using ::erfc;
-  using ::expm1;
-  using ::lgamma;
-  using ::log1p;
-  using ::nearbyint;
-  using ::round;
-  using ::tgamma;
-  using ::trunc;
-  using ::truncf;
+// Import double versions of these functions from the global namespace.
+using ::acosh;
+using ::asinh;
+using ::atanh;
+using ::erf;
+using ::erfc;
+using ::expm1;
+using ::lgamma;
+using ::log1p;
+using ::nearbyint;
+using ::round;
+using ::tgamma;
+using ::trunc;
+using ::truncf;
 
-  // Define float versions the same way as more recent libstdc++
-  inline float acosh(float x) { return __builtin_acoshf(x); }
-  inline float asinh(float x) { return __builtin_asinhf(x); }
-  inline float atanh(float x) { return __builtin_atanhf(x); }
-  inline float copysign(float x, float y) { return __builtin_copysignf(x, y); }
-  inline float erf(float x) { return __builtin_erff(x); }
-  inline float erfc(float x) { return __builtin_erfcf(x); }
-  inline float expm1(float x) { return __builtin_expm1f(x); }
-  inline float fmax(float x, float y) { return __builtin_fmaxf(x, y); }
-  inline float fmin(float x, float y) { return __builtin_fminf(x, y); }
-  inline float lgamma(float x) { return __builtin_lgammaf(x); }
-  inline float log1p(float x) { return __builtin_log1pf(x); }
-  inline float nearbyint(float x) { return __builtin_nearbyintf(x); }
-  inline float remainder(float x, float y) { return __builtin_remainderf(x, y); }
-  inline float round(float x) { return __builtin_roundf(x); }
-  inline float tgamma(float x) { return __builtin_tgammaf(x); }
-  inline float trunc(float x) { return __builtin_truncf(x); }
-
-  // __builtin_nexttoward isn't doesn't work.  It appears to try to
-  // link against the global nexttoward function, which is not present
-  // prior to API 18.  Just bail for now.
-  inline float nexttoward(float x, long double y) {
-    throw std::runtime_error("std::nexttoward is not present on older Android");
-  }
-  inline double nexttoward(double x, long double y) {
-    throw std::runtime_error("std::nexttoward is not present on older Android");
-  }
-
-  // TODO: this function needs to be implemented and tested. Currently just throw an error.
-  inline float hypot(float x, float y) {
-    throw std::runtime_error("std::hypot is not implemented on older Android");
-  }
-  inline double hypot(double x, double y) {
-    throw std::runtime_error("std::hypot is not implemented on older Android");
-  }
-
-  // TODO: this function needs to be implemented and tested. Currently just throw an error.
-  inline float igamma(float x, float y) {
-    throw std::runtime_error("igamma is not implemented on older Android");
-  }
-  inline double igamma(double x, double y) {
-    throw std::runtime_error("igamma is not implemented on older Android");
-  }
-  inline float igammac(float x, float y) {
-    throw std::runtime_error("igammac is not implemented on older Android");
-  }
-  inline double igammac(double x, double y) {
-    throw std::runtime_error("igammac is not implemented on older Android");
-  }
-
-  // TODO: this function needs to be implemented and tested. Currently just throw an error.
-  inline float nextafter(float x, float y) {
-    throw std::runtime_error("std::nextafter is not implemented on older Android");
-  }
-  inline double nextafter(double x, double y) {
-    throw std::runtime_error("std::nextafter is not implemented on older Android");
-  }
-
-   // TODO: this function needs to be implemented and tested. Currently just throw an error.
-  inline float exp2(float x) {
-    throw std::runtime_error("std::exp2 is not implemented on older Android");
-  }
-  inline double exp2(double x) {
-    throw std::runtime_error("std::exp2 is not implemented on older Android");
-  }
-
-  // Define integral versions the same way as more recent libstdc++
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type acosh(T x) { return __builtin_acosh(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type asinh(T x) { return __builtin_asinh(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type atanh(T x) { return __builtin_atanh(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type erf(T x) { return __builtin_erf(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type erfc(T x) { return __builtin_erfc(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type expm1(T x) { return __builtin_expm1(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type lgamma(T x) { return __builtin_lgamma(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type log1p(T x) { return __builtin_log1p(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type nearbyint(T x) { return __builtin_nearbyint(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type round(T x) { return __builtin_round(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type tgamma(T x) { return __builtin_tgamma(x); }
-  template<typename T> typename std::enable_if<std::is_integral<T>::value, double>::type trunc(T x) { return __builtin_trunc(x); }
-
-  // Convoluted definition of these binary functions for overloads other than
-  // (float,float) and (double,double).  Using a template from __gnu_cxx
-  // is dirty, but this code is only enabled on a dead platform, so there
-  // shouldn't be any risk of it breaking due to updates.
-  template<typename T, typename U>
-  typename __gnu_cxx::__promote_2<T, U>::__type
-  fmax(T x, U y) {
-    typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
-    return fmax(type(x), type(y));
-  }
-  template<typename T, typename U>
-  typename __gnu_cxx::__promote_2<T, U>::__type
-  fmin(T x, U y) {
-    typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
-    return fmin(type(x), type(y));
-  }
-  template<typename T, typename U>
-  typename __gnu_cxx::__promote_2<T, U>::__type
-  copysign(T x, U y) {
-    typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
-    return copysign(type(x), type(y));
-  }
-  template<typename T, typename U>
-  typename __gnu_cxx::__promote_2<T, U>::__type
-  remainder(T x, U y) {
-    typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
-    return remainder(type(x), type(y));
-  }
-
-  // log2 is a macro on Android API < 21, so we need to define it ourselves.
-  inline float log2(float arg) {
-    return ::log(arg) / ::log(2.0);
-  }
-  inline double log2(double arg) {
-    return ::log(arg) / ::log(2.0);
-  }
-  inline long double log2(long double arg) {
-    return ::log(arg) / ::log(2.0);
-  }
-  template<typename T>
-  typename std::enable_if<std::is_integral<T>::value, double>::type
-  log2(T x) {
-    return ::log(x) / ::log(2.0);
-  }
+// Define float versions the same way as more recent libstdc++
+inline float acosh(float x) {
+  return __builtin_acoshf(x);
+}
+inline float asinh(float x) {
+  return __builtin_asinhf(x);
+}
+inline float atanh(float x) {
+  return __builtin_atanhf(x);
+}
+inline float copysign(float x, float y) {
+  return __builtin_copysignf(x, y);
+}
+inline float erf(float x) {
+  return __builtin_erff(x);
+}
+inline float erfc(float x) {
+  return __builtin_erfcf(x);
+}
+inline float expm1(float x) {
+  return __builtin_expm1f(x);
+}
+inline float fmax(float x, float y) {
+  return __builtin_fmaxf(x, y);
+}
+inline float fmin(float x, float y) {
+  return __builtin_fminf(x, y);
+}
+inline float lgamma(float x) {
+  return __builtin_lgammaf(x);
+}
+inline float log1p(float x) {
+  return __builtin_log1pf(x);
+}
+inline float nearbyint(float x) {
+  return __builtin_nearbyintf(x);
+}
+inline float remainder(float x, float y) {
+  return __builtin_remainderf(x, y);
+}
+inline float round(float x) {
+  return __builtin_roundf(x);
+}
+inline float tgamma(float x) {
+  return __builtin_tgammaf(x);
+}
+inline float trunc(float x) {
+  return __builtin_truncf(x);
 }
 
+// __builtin_nexttoward isn't doesn't work.  It appears to try to
+// link against the global nexttoward function, which is not present
+// prior to API 18.  Just bail for now.
+inline float nexttoward(float x, long double y) {
+  throw std::runtime_error("std::nexttoward is not present on older Android");
+}
+inline double nexttoward(double x, long double y) {
+  throw std::runtime_error("std::nexttoward is not present on older Android");
+}
+
+// TODO: this function needs to be implemented and tested. Currently just throw
+// an error.
+inline float hypot(float x, float y) {
+  throw std::runtime_error("std::hypot is not implemented on older Android");
+}
+inline double hypot(double x, double y) {
+  throw std::runtime_error("std::hypot is not implemented on older Android");
+}
+
+// TODO: this function needs to be implemented and tested. Currently just throw
+// an error.
+inline float igamma(float x, float y) {
+  throw std::runtime_error("igamma is not implemented on older Android");
+}
+inline double igamma(double x, double y) {
+  throw std::runtime_error("igamma is not implemented on older Android");
+}
+inline float igammac(float x, float y) {
+  throw std::runtime_error("igammac is not implemented on older Android");
+}
+inline double igammac(double x, double y) {
+  throw std::runtime_error("igammac is not implemented on older Android");
+}
+
+// TODO: this function needs to be implemented and tested. Currently just throw
+// an error.
+inline float nextafter(float x, float y) {
+  throw std::runtime_error(
+      "std::nextafter is not implemented on older Android");
+}
+inline double nextafter(double x, double y) {
+  throw std::runtime_error(
+      "std::nextafter is not implemented on older Android");
+}
+
+// TODO: this function needs to be implemented and tested. Currently just throw
+// an error.
+inline float exp2(float x) {
+  throw std::runtime_error("std::exp2 is not implemented on older Android");
+}
+inline double exp2(double x) {
+  throw std::runtime_error("std::exp2 is not implemented on older Android");
+}
+
+// Define integral versions the same way as more recent libstdc++
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type acosh(T x) {
+  return __builtin_acosh(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type asinh(T x) {
+  return __builtin_asinh(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type atanh(T x) {
+  return __builtin_atanh(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type erf(T x) {
+  return __builtin_erf(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type erfc(T x) {
+  return __builtin_erfc(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type expm1(T x) {
+  return __builtin_expm1(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type lgamma(T x) {
+  return __builtin_lgamma(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type log1p(T x) {
+  return __builtin_log1p(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type nearbyint(
+    T x) {
+  return __builtin_nearbyint(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type round(T x) {
+  return __builtin_round(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type tgamma(T x) {
+  return __builtin_tgamma(x);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type trunc(T x) {
+  return __builtin_trunc(x);
+}
+
+// Convoluted definition of these binary functions for overloads other than
+// (float,float) and (double,double).  Using a template from __gnu_cxx
+// is dirty, but this code is only enabled on a dead platform, so there
+// shouldn't be any risk of it breaking due to updates.
+template <typename T, typename U>
+typename __gnu_cxx::__promote_2<T, U>::__type fmax(T x, U y) {
+  typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
+  return fmax(type(x), type(y));
+}
+template <typename T, typename U>
+typename __gnu_cxx::__promote_2<T, U>::__type fmin(T x, U y) {
+  typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
+  return fmin(type(x), type(y));
+}
+template <typename T, typename U>
+typename __gnu_cxx::__promote_2<T, U>::__type copysign(T x, U y) {
+  typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
+  return copysign(type(x), type(y));
+}
+template <typename T, typename U>
+typename __gnu_cxx::__promote_2<T, U>::__type remainder(T x, U y) {
+  typedef typename __gnu_cxx::__promote_2<T, U>::__type type;
+  return remainder(type(x), type(y));
+}
+
+// log2 is a macro on Android API < 21, so we need to define it ourselves.
+inline float log2(float arg) {
+  return ::log(arg) / ::log(2.0);
+}
+inline double log2(double arg) {
+  return ::log(arg) / ::log(2.0);
+}
+inline long double log2(long double arg) {
+  return ::log(arg) / ::log(2.0);
+}
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, double>::type log2(T x) {
+  return ::log(x) / ::log(2.0);
+}
+} // namespace std
+
 #endif
diff --git a/c10/util/numa.cpp b/c10/util/numa.cpp
index ef387305b72..77db5f42218 100644
--- a/c10/util/numa.cpp
+++ b/c10/util/numa.cpp
@@ -110,8 +110,7 @@ bool IsNUMAEnabled() {
   return false;
 }
 
-void NUMABind(int numa_node_id) {
-}
+void NUMABind(int numa_node_id) {}
 
 int GetNUMANode(const void* ptr) {
   return -1;
@@ -121,8 +120,7 @@ int GetNumNUMANodes() {
   return -1;
 }
 
-void NUMAMove(void* ptr, size_t size, int numa_node_id) {
-}
+void NUMAMove(void* ptr, size_t size, int numa_node_id) {}
 
 int GetCurrentNUMANode() {
   return -1;
diff --git a/c10/util/order_preserving_flat_hash_map.h b/c10/util/order_preserving_flat_hash_map.h
index 7648c07eea8..081733fd60a 100644
--- a/c10/util/order_preserving_flat_hash_map.h
+++ b/c10/util/order_preserving_flat_hash_map.h
@@ -1,29 +1,32 @@
-// Taken from https://github.com/skarupke/flat_hash_map/blob/2c4687431f978f02a3780e24b8b701d22aa32d9c/flat_hash_map.hpp
+// Taken from
+// https://github.com/skarupke/flat_hash_map/blob/2c4687431f978f02a3780e24b8b701d22aa32d9c/flat_hash_map.hpp
 // with fixes applied:
 // - https://github.com/skarupke/flat_hash_map/pull/25
 // - https://github.com/skarupke/flat_hash_map/pull/26
 // - replace size_t with uint64_t to fix it for 32bit
 // - add "GCC diagnostic" pragma to ignore -Wshadow
-// - make sherwood_v3_table::convertible_to_iterator public because GCC5 seems to have issues with it otherwise
+// - make sherwood_v3_table::convertible_to_iterator public because GCC5 seems
+// to have issues with it otherwise
 // - fix compiler warnings in operator templated_iterator<const value_type>
 
 //          Copyright Malte Skarupke 2017.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See http://www.boost.org/LICENSE_1_0.txt)
 
-// Modified to maintain insertion and deletion order through a doubly-linked list
+// Modified to maintain insertion and deletion order through a doubly-linked
+// list
 
 #pragma once
 
-#include <cstdint>
-#include <cstddef>
-#include <functional>
-#include <cmath>
-#include <algorithm>
-#include <iterator>
-#include <utility>
-#include <type_traits>
 #include <c10/util/C++17.h>
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <type_traits>
+#include <utility>
 
 #ifndef _MSC_VER
 #pragma GCC diagnostic push
@@ -36,1607 +39,2195 @@
 #define SKA_NOINLINE(...) __VA_ARGS__ __attribute__((noinline))
 #endif
 
-namespace ska_ordered
-{
+namespace ska_ordered {
 
 struct prime_number_hash_policy;
 struct power_of_two_hash_policy;
 struct fibonacci_hash_policy;
 
-namespace detailv3
-{
-template<typename Result, typename Functor>
-struct functor_storage : Functor
-{
-    functor_storage() = default;
-    functor_storage(const Functor & functor)
-        : Functor(functor)
-    {
-    }
-    template<typename... Args>
-    Result operator()(Args &&... args)
-    {
-        return static_cast<Functor &>(*this)(std::forward<Args>(args)...);
-    }
-    template<typename... Args>
-    Result operator()(Args &&... args) const
-    {
-        return static_cast<const Functor &>(*this)(std::forward<Args>(args)...);
-    }
+namespace detailv3 {
+template <typename Result, typename Functor>
+struct functor_storage : Functor {
+  functor_storage() = default;
+  functor_storage(const Functor& functor) : Functor(functor) {}
+  template <typename... Args>
+  Result operator()(Args&&... args) {
+    return static_cast<Functor&>(*this)(std::forward<Args>(args)...);
+  }
+  template <typename... Args>
+  Result operator()(Args&&... args) const {
+    return static_cast<const Functor&>(*this)(std::forward<Args>(args)...);
+  }
 };
-template<typename Result, typename... Args>
-struct functor_storage<Result, Result (*)(Args...)>
-{
-    typedef Result (*function_ptr)(Args...);
-    function_ptr function;
-    functor_storage(function_ptr function)
-        : function(function)
-    {
-    }
-    Result operator()(Args... args) const
-    {
-        return function(std::forward<Args>(args)...);
-    }
-    operator function_ptr &()
-    {
-        return function;
-    }
-    operator const function_ptr &()
-    {
-        return function;
-    }
+template <typename Result, typename... Args>
+struct functor_storage<Result, Result (*)(Args...)> {
+  typedef Result (*function_ptr)(Args...);
+  function_ptr function;
+  functor_storage(function_ptr function) : function(function) {}
+  Result operator()(Args... args) const {
+    return function(std::forward<Args>(args)...);
+  }
+  operator function_ptr&() {
+    return function;
+  }
+  operator const function_ptr&() {
+    return function;
+  }
 };
-template<typename key_type, typename value_type, typename hasher>
-struct KeyOrValueHasher : functor_storage<uint64_t, hasher>
-{
-    typedef functor_storage<uint64_t, hasher> hasher_storage;
-    KeyOrValueHasher() = default;
-    KeyOrValueHasher(const hasher & hash)
-        : hasher_storage(hash)
-    {
-    }
-    uint64_t operator()(const key_type & key)
-    {
-        return static_cast<hasher_storage &>(*this)(key);
-    }
-    uint64_t operator()(const key_type & key) const
-    {
-        return static_cast<const hasher_storage &>(*this)(key);
-    }
-    uint64_t operator()(const value_type & value)
-    {
-        return static_cast<hasher_storage &>(*this)(value.first);
-    }
-    uint64_t operator()(const value_type & value) const
-    {
-        return static_cast<const hasher_storage &>(*this)(value.first);
-    }
-    template<typename F, typename S>
-    uint64_t operator()(const std::pair<F, S> & value)
-    {
-        return static_cast<hasher_storage &>(*this)(value.first);
-    }
-    template<typename F, typename S>
-    uint64_t operator()(const std::pair<F, S> & value) const
-    {
-        return static_cast<const hasher_storage &>(*this)(value.first);
-    }
+template <typename key_type, typename value_type, typename hasher>
+struct KeyOrValueHasher : functor_storage<uint64_t, hasher> {
+  typedef functor_storage<uint64_t, hasher> hasher_storage;
+  KeyOrValueHasher() = default;
+  KeyOrValueHasher(const hasher& hash) : hasher_storage(hash) {}
+  uint64_t operator()(const key_type& key) {
+    return static_cast<hasher_storage&>(*this)(key);
+  }
+  uint64_t operator()(const key_type& key) const {
+    return static_cast<const hasher_storage&>(*this)(key);
+  }
+  uint64_t operator()(const value_type& value) {
+    return static_cast<hasher_storage&>(*this)(value.first);
+  }
+  uint64_t operator()(const value_type& value) const {
+    return static_cast<const hasher_storage&>(*this)(value.first);
+  }
+  template <typename F, typename S>
+  uint64_t operator()(const std::pair<F, S>& value) {
+    return static_cast<hasher_storage&>(*this)(value.first);
+  }
+  template <typename F, typename S>
+  uint64_t operator()(const std::pair<F, S>& value) const {
+    return static_cast<const hasher_storage&>(*this)(value.first);
+  }
 };
-template<typename key_type, typename value_type, typename key_equal>
-struct KeyOrValueEquality : functor_storage<bool, key_equal>
-{
-    typedef functor_storage<bool, key_equal> equality_storage;
-    KeyOrValueEquality() = default;
-    KeyOrValueEquality(const key_equal & equality)
-        : equality_storage(equality)
-    {
-    }
-    bool operator()(const key_type & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs);
-    }
-    bool operator()(const key_type & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs.first);
-    }
-    bool operator()(const value_type & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs);
-    }
-    bool operator()(const value_type & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const key_type & lhs, const std::pair<F, S> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const std::pair<F, S> & lhs, const key_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs);
-    }
-    template<typename F, typename S>
-    bool operator()(const value_type & lhs, const std::pair<F, S> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename F, typename S>
-    bool operator()(const std::pair<F, S> & lhs, const value_type & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
-    template<typename FL, typename SL, typename FR, typename SR>
-    bool operator()(const std::pair<FL, SL> & lhs, const std::pair<FR, SR> & rhs)
-    {
-        return static_cast<equality_storage &>(*this)(lhs.first, rhs.first);
-    }
+template <typename key_type, typename value_type, typename key_equal>
+struct KeyOrValueEquality : functor_storage<bool, key_equal> {
+  typedef functor_storage<bool, key_equal> equality_storage;
+  KeyOrValueEquality() = default;
+  KeyOrValueEquality(const key_equal& equality) : equality_storage(equality) {}
+  bool operator()(const key_type& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs);
+  }
+  bool operator()(const key_type& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs.first);
+  }
+  bool operator()(const value_type& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs);
+  }
+  bool operator()(const value_type& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const key_type& lhs, const std::pair<F, S>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const std::pair<F, S>& lhs, const key_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs);
+  }
+  template <typename F, typename S>
+  bool operator()(const value_type& lhs, const std::pair<F, S>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename F, typename S>
+  bool operator()(const std::pair<F, S>& lhs, const value_type& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
+  template <typename FL, typename SL, typename FR, typename SR>
+  bool operator()(const std::pair<FL, SL>& lhs, const std::pair<FR, SR>& rhs) {
+    return static_cast<equality_storage&>(*this)(lhs.first, rhs.first);
+  }
 };
 static constexpr int8_t min_lookups = 4;
-template<typename T>
-struct sherwood_v3_entry
-{
-    sherwood_v3_entry()
-    {
-    }
-    sherwood_v3_entry(int8_t distance_from_desired)
-        : distance_from_desired(distance_from_desired)
-    {
-    }
-    ~sherwood_v3_entry()
-    {
-    }
+template <typename T>
+struct sherwood_v3_entry {
+  sherwood_v3_entry() {}
+  sherwood_v3_entry(int8_t distance_from_desired)
+      : distance_from_desired(distance_from_desired) {}
+  ~sherwood_v3_entry() {}
 
-    bool has_value() const
-    {
-        return distance_from_desired >= 0;
-    }
-    bool is_empty() const
-    {
-        return distance_from_desired < 0;
-    }
-    bool is_at_desired_position() const
-    {
-        return distance_from_desired <= 0;
-    }
-    template<typename... Args>
-    void emplace(int8_t distance, Args &&... args)
-    {
-        new (std::addressof(value)) T(std::forward<Args>(args)...);
-        distance_from_desired = distance;
-    }
+  bool has_value() const {
+    return distance_from_desired >= 0;
+  }
+  bool is_empty() const {
+    return distance_from_desired < 0;
+  }
+  bool is_at_desired_position() const {
+    return distance_from_desired <= 0;
+  }
+  template <typename... Args>
+  void emplace(int8_t distance, Args&&... args) {
+    new (std::addressof(value)) T(std::forward<Args>(args)...);
+    distance_from_desired = distance;
+  }
 
-    void destroy_value()
-    {
-        value.~T();
-        distance_from_desired = -1;
-    }
+  void destroy_value() {
+    value.~T();
+    distance_from_desired = -1;
+  }
 
-    sherwood_v3_entry<T> * prev = nullptr;
-    sherwood_v3_entry<T> * next = nullptr;
-    int8_t distance_from_desired = -1;
-    static constexpr int8_t special_end_value = 0;
-    union { T value; };
+  sherwood_v3_entry<T>* prev = nullptr;
+  sherwood_v3_entry<T>* next = nullptr;
+  int8_t distance_from_desired = -1;
+  static constexpr int8_t special_end_value = 0;
+  union {
+    T value;
+  };
 };
 
-inline int8_t log2(uint64_t value)
-{
-    static constexpr int8_t table[64] =
-    {
-        63,  0, 58,  1, 59, 47, 53,  2,
-        60, 39, 48, 27, 54, 33, 42,  3,
-        61, 51, 37, 40, 49, 18, 28, 20,
-        55, 30, 34, 11, 43, 14, 22,  4,
-        62, 57, 46, 52, 38, 26, 32, 41,
-        50, 36, 17, 19, 29, 10, 13, 21,
-        56, 45, 25, 31, 35, 16,  9, 12,
-        44, 24, 15,  8, 23,  7,  6,  5
-    };
-    value |= value >> 1;
-    value |= value >> 2;
-    value |= value >> 4;
-    value |= value >> 8;
-    value |= value >> 16;
-    value |= value >> 32;
-    return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
+inline int8_t log2(uint64_t value) {
+  static constexpr int8_t table[64] = {
+      63, 0,  58, 1,  59, 47, 53, 2,  60, 39, 48, 27, 54, 33, 42, 3,
+      61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4,
+      62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21,
+      56, 45, 25, 31, 35, 16, 9,  12, 44, 24, 15, 8,  23, 7,  6,  5};
+  value |= value >> 1;
+  value |= value >> 2;
+  value |= value >> 4;
+  value |= value >> 8;
+  value |= value >> 16;
+  value |= value >> 32;
+  return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
 }
 
-template<typename T, bool>
-struct AssignIfTrue
-{
-    void operator()(T & lhs, const T & rhs)
-    {
-        lhs = rhs;
-    }
-    void operator()(T & lhs, T && rhs)
-    {
-        lhs = std::move(rhs);
-    }
+template <typename T, bool>
+struct AssignIfTrue {
+  void operator()(T& lhs, const T& rhs) {
+    lhs = rhs;
+  }
+  void operator()(T& lhs, T&& rhs) {
+    lhs = std::move(rhs);
+  }
 };
-template<typename T>
-struct AssignIfTrue<T, false>
-{
-    void operator()(T &, const T &)
-    {
-    }
-    void operator()(T &, T &&)
-    {
-    }
+template <typename T>
+struct AssignIfTrue<T, false> {
+  void operator()(T&, const T&) {}
+  void operator()(T&, T&&) {}
 };
 
-inline uint64_t next_power_of_two(uint64_t i)
-{
-    --i;
-    i |= i >> 1;
-    i |= i >> 2;
-    i |= i >> 4;
-    i |= i >> 8;
-    i |= i >> 16;
-    i |= i >> 32;
-    ++i;
-    return i;
+inline uint64_t next_power_of_two(uint64_t i) {
+  --i;
+  i |= i >> 1;
+  i |= i >> 2;
+  i |= i >> 4;
+  i |= i >> 8;
+  i |= i >> 16;
+  i |= i >> 32;
+  ++i;
+  return i;
 }
 
 // Implementation taken from http://en.cppreference.com/w/cpp/types/void_t
 // (it takes CWG1558 into account and also works for older compilers)
-template<typename... Ts> struct make_void { typedef void type;};
-template<typename... Ts> using void_t = typename make_void<Ts...>::type;
-
-template<typename T, typename = void>
-struct HashPolicySelector
-{
-    typedef fibonacci_hash_policy type;
+template <typename... Ts>
+struct make_void {
+  typedef void type;
 };
-template<typename T>
-struct HashPolicySelector<T, void_t<typename T::hash_policy>>
-{
-    typedef typename T::hash_policy type;
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
+template <typename T, typename = void>
+struct HashPolicySelector {
+  typedef fibonacci_hash_policy type;
+};
+template <typename T>
+struct HashPolicySelector<T, void_t<typename T::hash_policy>> {
+  typedef typename T::hash_policy type;
 };
 
-template<typename T, typename FindKey, typename ArgumentHash, typename Hasher, typename ArgumentEqual, typename Equal, typename ArgumentAlloc, typename EntryAlloc>
-class sherwood_v3_table : private EntryAlloc, private Hasher, private Equal
-{
-    using Entry = detailv3::sherwood_v3_entry<T>;
-    using AllocatorTraits = std::allocator_traits<EntryAlloc>;
-    using EntryPointer = typename AllocatorTraits::pointer;
+template <
+    typename T,
+    typename FindKey,
+    typename ArgumentHash,
+    typename Hasher,
+    typename ArgumentEqual,
+    typename Equal,
+    typename ArgumentAlloc,
+    typename EntryAlloc>
+class sherwood_v3_table : private EntryAlloc, private Hasher, private Equal {
+  using Entry = detailv3::sherwood_v3_entry<T>;
+  using AllocatorTraits = std::allocator_traits<EntryAlloc>;
+  using EntryPointer = typename AllocatorTraits::pointer;
 
-public:
-    struct convertible_to_iterator;
+ public:
+  struct convertible_to_iterator;
 
-    using value_type = T;
-    using size_type = uint64_t;
-    using difference_type = std::ptrdiff_t;
-    using hasher = ArgumentHash;
-    using key_equal = ArgumentEqual;
-    using allocator_type = EntryAlloc;
-    using reference = value_type &;
-    using const_reference = const value_type &;
-    using pointer = value_type *;
-    using const_pointer = const value_type *;
+  using value_type = T;
+  using size_type = uint64_t;
+  using difference_type = std::ptrdiff_t;
+  using hasher = ArgumentHash;
+  using key_equal = ArgumentEqual;
+  using allocator_type = EntryAlloc;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
 
-    sherwood_v3_table()
-    {
+  sherwood_v3_table() {}
+  explicit sherwood_v3_table(
+      size_type bucket_count,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : EntryAlloc(alloc), Hasher(hash), Equal(equal) {
+    rehash(bucket_count);
+  }
+  sherwood_v3_table(size_type bucket_count, const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc) {}
+  explicit sherwood_v3_table(const ArgumentAlloc& alloc) : EntryAlloc(alloc) {}
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count = 0,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : sherwood_v3_table(bucket_count, hash, equal, alloc) {
+    insert(first, last);
+  }
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            first,
+            last,
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  template <typename It>
+  sherwood_v3_table(
+      It first,
+      It last,
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            first,
+            last,
+            bucket_count,
+            hash,
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count = 0,
+      const ArgumentHash& hash = ArgumentHash(),
+      const ArgumentEqual& equal = ArgumentEqual(),
+      const ArgumentAlloc& alloc = ArgumentAlloc())
+      : sherwood_v3_table(bucket_count, hash, equal, alloc) {
+    if (bucket_count == 0)
+      rehash(il.size());
+    insert(il.begin(), il.end());
+  }
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(
+            il,
+            bucket_count,
+            ArgumentHash(),
+            ArgumentEqual(),
+            alloc) {}
+  sherwood_v3_table(
+      std::initializer_list<T> il,
+      size_type bucket_count,
+      const ArgumentHash& hash,
+      const ArgumentAlloc& alloc)
+      : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc) {}
+  sherwood_v3_table(const sherwood_v3_table& other)
+      : sherwood_v3_table(
+            other,
+            AllocatorTraits::select_on_container_copy_construction(
+                other.get_allocator())) {}
+  sherwood_v3_table(const sherwood_v3_table& other, const ArgumentAlloc& alloc)
+      : EntryAlloc(alloc),
+        Hasher(other),
+        Equal(other),
+        _max_load_factor(other._max_load_factor) {
+    rehash_for_other_container(other);
+    try {
+      insert(other.begin(), other.end());
+    } catch (...) {
+      clear();
+      deallocate_data(entries, num_slots_minus_one, max_lookups);
+      throw;
     }
-    explicit sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : EntryAlloc(alloc), Hasher(hash), Equal(equal)
-    {
-        rehash(bucket_count);
-    }
-    sherwood_v3_table(size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    explicit sherwood_v3_table(const ArgumentAlloc & alloc)
-        : EntryAlloc(alloc)
-    {
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : sherwood_v3_table(bucket_count, hash, equal, alloc)
-    {
-        insert(first, last);
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(first, last, bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    template<typename It>
-    sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(first, last, bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc())
-        : sherwood_v3_table(bucket_count, hash, equal, alloc)
-    {
-        if (bucket_count == 0)
-            rehash(il.size());
-        insert(il.begin(), il.end());
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(il, bucket_count, ArgumentHash(), ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(std::initializer_list<T> il, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc)
-        : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc)
-    {
-    }
-    sherwood_v3_table(const sherwood_v3_table & other)
-        : sherwood_v3_table(other, AllocatorTraits::select_on_container_copy_construction(other.get_allocator()))
-    {
-    }
-    sherwood_v3_table(const sherwood_v3_table & other, const ArgumentAlloc & alloc)
-        : EntryAlloc(alloc), Hasher(other), Equal(other), _max_load_factor(other._max_load_factor)
-    {
-        rehash_for_other_container(other);
-        try
-        {
-            insert(other.begin(), other.end());
-        }
-        catch(...)
-        {
-            clear();
-            deallocate_data(entries, num_slots_minus_one, max_lookups);
-            throw;
-        }
-    }
-    sherwood_v3_table(sherwood_v3_table && other) noexcept
-        : EntryAlloc(std::move(other)), Hasher(std::move(other)), Equal(std::move(other))
-    {
-        swap_pointers(other);
-    }
-    sherwood_v3_table(sherwood_v3_table && other, const ArgumentAlloc & alloc) noexcept
-        : EntryAlloc(alloc), Hasher(std::move(other)), Equal(std::move(other))
-    {
-        swap_pointers(other);
-    }
-    sherwood_v3_table & operator=(const sherwood_v3_table & other)
-    {
-        if (this == std::addressof(other))
-            return *this;
+  }
+  sherwood_v3_table(sherwood_v3_table&& other) noexcept
+      : EntryAlloc(std::move(other)),
+        Hasher(std::move(other)),
+        Equal(std::move(other)) {
+    swap_pointers(other);
+  }
+  sherwood_v3_table(
+      sherwood_v3_table&& other,
+      const ArgumentAlloc& alloc) noexcept
+      : EntryAlloc(alloc), Hasher(std::move(other)), Equal(std::move(other)) {
+    swap_pointers(other);
+  }
+  sherwood_v3_table& operator=(const sherwood_v3_table& other) {
+    if (this == std::addressof(other))
+      return *this;
 
-        clear();
-        if (AllocatorTraits::propagate_on_container_copy_assignment::value)
-        {
-            if (static_cast<EntryAlloc &>(*this) != static_cast<const EntryAlloc &>(other))
-            {
-                reset_to_empty_state();
-            }
-            AssignIfTrue<EntryAlloc, AllocatorTraits::propagate_on_container_copy_assignment::value>()(*this, other);
-        }
-        _max_load_factor = other._max_load_factor;
-        static_cast<Hasher &>(*this) = other;
-        static_cast<Equal &>(*this) = other;
-        rehash_for_other_container(other);
-        insert(other.begin(), other.end());
-        return *this;
-    }
-    sherwood_v3_table & operator=(sherwood_v3_table && other) noexcept
-    {
-        if (this == std::addressof(other))
-            return *this;
-        else if (AllocatorTraits::propagate_on_container_move_assignment::value)
-        {
-            clear();
-            reset_to_empty_state();
-            AssignIfTrue<EntryAlloc, AllocatorTraits::propagate_on_container_move_assignment::value>()(*this, std::move(other));
-            swap_pointers(other);
-        }
-        else if (static_cast<EntryAlloc &>(*this) == static_cast<EntryAlloc &>(other))
-        {
-            swap_pointers(other);
-        }
-        else
-        {
-            clear();
-            _max_load_factor = other._max_load_factor;
-            rehash_for_other_container(other);
-            for (T & elem : other)
-                emplace(std::move(elem));
-            other.clear();
-        }
-        static_cast<Hasher &>(*this) = std::move(other);
-        static_cast<Equal &>(*this) = std::move(other);
-        return *this;
-    }
-    ~sherwood_v3_table()
-    {
-        clear();
-        deallocate_data(entries, num_slots_minus_one, max_lookups);
-    }
-
-    const allocator_type & get_allocator() const
-    {
-        return static_cast<const allocator_type &>(*this);
-    }
-    const ArgumentEqual & key_eq() const
-    {
-        return static_cast<const ArgumentEqual &>(*this);
-    }
-    const ArgumentHash & hash_function() const
-    {
-        return static_cast<const ArgumentHash &>(*this);
-    }
-
-    template<typename ValueType>
-    struct templated_iterator
-    {
-        templated_iterator() = default;
-        templated_iterator(EntryPointer current)
-            : current(current)
-        {
-        }
-        EntryPointer current = EntryPointer();
-
-        using iterator_category = std::forward_iterator_tag;
-        using value_type = ValueType;
-        using difference_type = ptrdiff_t;
-        using pointer = ValueType *;
-        using reference = ValueType &;
-
-        friend bool operator==(const templated_iterator & lhs, const templated_iterator & rhs)
-        {
-            return lhs.current == rhs.current;
-        }
-        friend bool operator!=(const templated_iterator & lhs, const templated_iterator & rhs)
-        {
-            return !(lhs == rhs);
-        }
-
-        templated_iterator & operator++()
-        {
-            current = current->next;
-            return *this;
-        }
-        templated_iterator operator++(int)
-        {
-            templated_iterator copy(*this);
-            ++*this;
-            return copy;
-        }
-
-        ValueType & operator*() const
-        {
-            return current->value;
-        }
-        ValueType * operator->() const
-        {
-            return std::addressof(current->value);
-        }
-
-        // the template automatically disables the operator when value_type is already
-        // const, because that would cause a lot of compiler warnings otherwise.
-        template<class target_type = const value_type, class = typename std::enable_if<std::is_same<target_type, const value_type>::value && !std::is_same<target_type, value_type>::value>::type>
-        operator templated_iterator<target_type>() const
-        {
-            return { current };
-        }
-    };
-    using iterator = templated_iterator<value_type>;
-    using const_iterator = templated_iterator<const value_type>;
-
-    iterator begin()
-    {
-        return sentinel->next;
-    }
-    const_iterator begin() const
-    {
-        return sentinel->next;
-    }
-    const_iterator cbegin() const
-    {
-        return begin();
-    }
-    iterator end()
-    {
-        return sentinel;
-    }
-    const_iterator end() const
-    {
-        return sentinel;
-    }
-    const_iterator cend() const
-    {
-        return end();
-    }
-
-    iterator find(const FindKey & key)
-    {
-        uint64_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-        EntryPointer it = entries + ptrdiff_t(index);
-        for (int8_t distance = 0; it->distance_from_desired >= distance; ++distance, ++it)
-        {
-            if (compares_equal(key, it->value))
-                return { it };
-        }
-        return end();
-    }
-    const_iterator find(const FindKey & key) const
-    {
-        return const_cast<sherwood_v3_table *>(this)->find(key);
-    }
-    uint64_t count(const FindKey & key) const
-    {
-        return find(key) == end() ? 0 : 1;
-    }
-    std::pair<iterator, iterator> equal_range(const FindKey & key)
-    {
-        iterator found = find(key);
-        if (found == end())
-            return { found, found };
-        else
-            return { found, std::next(found) };
-    }
-    std::pair<const_iterator, const_iterator> equal_range(const FindKey & key) const
-    {
-        const_iterator found = find(key);
-        if (found == end())
-            return { found, found };
-        else
-            return { found, std::next(found) };
-    }
-
-    template<typename Key, typename... Args>
-    std::pair<iterator, bool> emplace(Key && key, Args &&... args)
-    {
-        uint64_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-        EntryPointer current_entry = entries + ptrdiff_t(index);
-        int8_t distance_from_desired = 0;
-        for (; current_entry->distance_from_desired >= distance_from_desired; ++current_entry, ++distance_from_desired)
-        {
-            // insertion of an existing key does not change ordering
-            if (compares_equal(key, current_entry->value))
-                return { { current_entry }, false };
-        }
-        return emplace_new_key(distance_from_desired, current_entry, std::forward<Key>(key), std::forward<Args>(args)...);
-    }
-
-    std::pair<iterator, bool> insert(const value_type & value)
-    {
-        return emplace(value);
-    }
-    std::pair<iterator, bool> insert(value_type && value)
-    {
-        return emplace(std::move(value));
-    }
-    template<typename... Args>
-    iterator emplace_hint(const_iterator, Args &&... args)
-    {
-        return emplace(std::forward<Args>(args)...).first;
-    }
-    iterator insert(const_iterator, const value_type & value)
-    {
-        return emplace(value).first;
-    }
-    iterator insert(const_iterator, value_type && value)
-    {
-        return emplace(std::move(value)).first;
-    }
-
-    template<typename It>
-    void insert(It begin, It end)
-    {
-        for (; begin != end; ++begin)
-        {
-            emplace(*begin);
-        }
-    }
-    void insert(std::initializer_list<value_type> il)
-    {
-        insert(il.begin(), il.end());
-    }
-
-    void rehash(uint64_t num_buckets)
-    {
-        num_buckets = std::max(num_buckets, static_cast<uint64_t>(std::ceil(num_elements / static_cast<double>(_max_load_factor))));
-        if (num_buckets == 0)
-        {
-            reset_to_empty_state();
-            return;
-        }
-        auto new_prime_index = hash_policy.next_size_over(num_buckets);
-        if (num_buckets == bucket_count())
-            return;
-        int8_t new_max_lookups = compute_max_lookups(num_buckets);
-        EntryPointer new_buckets(AllocatorTraits::allocate(*this, num_buckets + new_max_lookups));
-        EntryPointer special_end_item = new_buckets + static_cast<ptrdiff_t>(num_buckets + new_max_lookups - 1);
-        for (EntryPointer it = new_buckets; it != special_end_item; ++it)
-            it->distance_from_desired = -1;
-        special_end_item->distance_from_desired = Entry::special_end_value;
-        std::swap(entries, new_buckets);
-        std::swap(num_slots_minus_one, num_buckets);
-        --num_slots_minus_one;
-        hash_policy.commit(new_prime_index);
-        int8_t old_max_lookups = max_lookups;
-        max_lookups = new_max_lookups;
-        num_elements = 0;
-
-        auto start = sentinel->next;
-        // point sentinel to itself;
-        reset_list();
-        // reinsert list
-        for (EntryPointer it = start; it != sentinel;) {
-          auto next = it->next;
-          emplace(std::move(it->value));
-          it->destroy_value();
-          it = next;
-        }
-
-        deallocate_data(new_buckets, num_buckets, old_max_lookups);
-    }
-
-    void reserve(uint64_t num_elements)
-    {
-        uint64_t required_buckets = num_buckets_for_reserve(num_elements);
-        if (required_buckets > bucket_count())
-            rehash(required_buckets);
-    }
-
-    void replace_linked_list_position(EntryPointer to_be_replaced, EntryPointer new_node) {
-      remove_from_list(new_node);
-      insert_after(new_node, to_be_replaced->prev);
-      remove_from_list(to_be_replaced);
-    }
-
-    // the return value is a type that can be converted to an iterator
-    // the reason for doing this is that it's not free to find the
-    // iterator pointing at the next element. if you care about the
-    // next iterator, turn the return value into an iterator
-    convertible_to_iterator erase(const_iterator to_erase)
-    {
-        EntryPointer current = to_erase.current;
-        remove_from_list(current);
-        current->destroy_value();
-        --num_elements;
-
-        for (EntryPointer next = current + ptrdiff_t(1); !next->is_at_desired_position(); ++current, ++next)
-        {
-            // if an entry is being removed, and there are other entries with the
-            // same hash, the other entries get moved to their desired position by
-            // reinserting.
-            current->emplace(next->distance_from_desired - 1, std::move(next->value));
-            replace_linked_list_position(next, current);
-            next->destroy_value();
-        }
-        return { to_erase.current };
-    }
-
-    iterator erase(const_iterator begin_it, const_iterator end_it)
-    {
-        // whenever an entry is removed and there are other entries with the same
-        // hash, the other entries must get moved to their desired position.
-        // any reference to a moved entry is invalidated.
-        // here, we iterate through the range, and make sure that we update
-        // the pointer to our next entry in the list or the end of the iterator
-        // when it is invalidated.
-
-        auto curr_iter = begin_it.current;
-        auto next_iter = curr_iter->next;
-        auto end_iter = end_it.current;
-
-        while (curr_iter != end_iter) {
-          remove_from_list(curr_iter);
-          curr_iter->destroy_value();
-          --num_elements;
-
-          for (EntryPointer next_hash_slot = curr_iter + ptrdiff_t(1); !next_hash_slot->is_at_desired_position(); ++curr_iter, ++next_hash_slot)
-            {
-              curr_iter->emplace(next_hash_slot->distance_from_desired - 1, std::move(next_hash_slot->value));
-              replace_linked_list_position(next_hash_slot, curr_iter);
-              next_hash_slot->destroy_value();
-
-              // we are invalidating next_iter or end_iter
-              if (next_hash_slot == end_iter) {
-                end_iter = curr_iter;
-              } else if (next_hash_slot == next_iter) {
-                next_iter = curr_iter;
-              }
-          }
-          curr_iter = next_iter;
-          next_iter = curr_iter->next;
-        }
-
-        return { end_iter };
-    }
-
-    uint64_t erase(const FindKey & key)
-    {
-        auto found = find(key);
-        if (found == end())
-            return 0;
-        else
-        {
-            erase(found);
-            return 1;
-        }
-    }
-
-    void clear()
-    {
-        for (EntryPointer it = entries, end = it + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups); it != end; ++it)
-        {
-            if (it->has_value())
-                it->destroy_value();
-        }
-        reset_list();
-        num_elements = 0;
-    }
-
-    void shrink_to_fit()
-    {
-        rehash_for_other_container(*this);
-    }
-
-    void swap(sherwood_v3_table & other)
-    {
-        using std::swap;
-        swap_pointers(other);
-        swap(static_cast<ArgumentHash &>(*this), static_cast<ArgumentHash &>(other));
-        swap(static_cast<ArgumentEqual &>(*this), static_cast<ArgumentEqual &>(other));
-        if (AllocatorTraits::propagate_on_container_swap::value)
-            swap(static_cast<EntryAlloc &>(*this), static_cast<EntryAlloc &>(other));
-    }
-
-    uint64_t size() const
-    {
-        return num_elements;
-    }
-    uint64_t max_size() const
-    {
-        return (AllocatorTraits::max_size(*this)) / sizeof(Entry);
-    }
-    uint64_t bucket_count() const
-    {
-        return num_slots_minus_one ? num_slots_minus_one + 1 : 0;
-    }
-    size_type max_bucket_count() const
-    {
-        return (AllocatorTraits::max_size(*this) - min_lookups) / sizeof(Entry);
-    }
-    uint64_t bucket(const FindKey & key) const
-    {
-        return hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
-    }
-    float load_factor() const
-    {
-        uint64_t buckets = bucket_count();
-        if (buckets)
-            return static_cast<float>(num_elements) / bucket_count();
-        else
-            return 0;
-    }
-    void max_load_factor(float value)
-    {
-        _max_load_factor = value;
-    }
-    float max_load_factor() const
-    {
-        return _max_load_factor;
-    }
-
-    bool empty() const
-    {
-        return num_elements == 0;
-    }
-
-private:
-    EntryPointer entries = empty_default_table();
-    uint64_t num_slots_minus_one = 0;
-    typename HashPolicySelector<ArgumentHash>::type hash_policy;
-    int8_t max_lookups = detailv3::min_lookups - 1;
-    float _max_load_factor = 0.5f;
-    uint64_t num_elements = 0;
-    std::unique_ptr<sherwood_v3_entry<T>> sentinel_val;
-
-    // head of doubly linked list
-    EntryPointer sentinel = initSentinel();
-
-    EntryPointer initSentinel() {
-      // needs to be a pointer so that hash map can be used with forward declared types
-      sentinel_val = std::make_unique<sherwood_v3_entry<T>>();
-      sentinel = sentinel_val.get();
-      reset_list();
-      return sentinel;
-    }
-
-    EntryPointer empty_default_table()
-    {
-        EntryPointer result = AllocatorTraits::allocate(*this, detailv3::min_lookups);
-        EntryPointer special_end_item = result + static_cast<ptrdiff_t>(detailv3::min_lookups - 1);
-        for (EntryPointer it = result; it != special_end_item; ++it)
-            it->distance_from_desired = -1;
-        special_end_item->distance_from_desired = Entry::special_end_value;
-        return result;
-    }
-
-    static int8_t compute_max_lookups(uint64_t num_buckets)
-    {
-        int8_t desired = detailv3::log2(num_buckets);
-        return std::max(detailv3::min_lookups, desired);
-    }
-
-    uint64_t num_buckets_for_reserve(uint64_t num_elements) const
-    {
-        return static_cast<uint64_t>(std::ceil(num_elements / std::min(0.5, static_cast<double>(_max_load_factor))));
-    }
-    void rehash_for_other_container(const sherwood_v3_table & other)
-    {
-        rehash(std::min(num_buckets_for_reserve(other.size()), other.bucket_count()));
-    }
-
-    void swap_pointers(sherwood_v3_table & other)
-    {
-        using std::swap;
-        swap(hash_policy, other.hash_policy);
-        swap(entries, other.entries);
-        swap(num_slots_minus_one, other.num_slots_minus_one);
-        swap(num_elements, other.num_elements);
-        swap(max_lookups, other.max_lookups);
-        swap(_max_load_factor, other._max_load_factor);
-        swap(sentinel, other.sentinel);
-        swap(sentinel_val, other.sentinel_val);
-    }
-
-    void reset_list() {
-      sentinel->next = sentinel;
-      sentinel->prev = sentinel;
-    }
-
-    void remove_from_list(EntryPointer elem) {
-      elem->prev->next = elem->next;
-      elem->next->prev = elem->prev;
-    }
-
-    void insert_after(EntryPointer new_elem, EntryPointer prev) {
-      auto next = prev->next;
-
-      prev->next = new_elem;
-      new_elem->prev = prev;
-
-      new_elem->next = next;
-      next->prev = new_elem;
-    }
-
-    void swap_adjacent_nodes(EntryPointer before, EntryPointer after) {
-      // sentinel stays consant, so before->prev cannot equal after
-      auto before_prev = before->prev;
-      auto after_next = after->next;
-
-      before_prev->next = after;
-      after->prev = before_prev;
-
-      after_next->prev = before;
-      before->next = after_next;
-
-      before->prev = after;
-      after->next = before;
-    }
-
-    void swap_positions(EntryPointer p1, EntryPointer p2) {
-      if (p1 == p2) {
-        return;
+    clear();
+    if (AllocatorTraits::propagate_on_container_copy_assignment::value) {
+      if (static_cast<EntryAlloc&>(*this) !=
+          static_cast<const EntryAlloc&>(other)) {
+        reset_to_empty_state();
       }
-      if (p1->next == p2) {
-        return swap_adjacent_nodes(p1, p2);
-      } else if (p2->next == p1) {
-        return swap_adjacent_nodes(p2, p1);
+      AssignIfTrue<
+          EntryAlloc,
+          AllocatorTraits::propagate_on_container_copy_assignment::value>()(
+          *this, other);
+    }
+    _max_load_factor = other._max_load_factor;
+    static_cast<Hasher&>(*this) = other;
+    static_cast<Equal&>(*this) = other;
+    rehash_for_other_container(other);
+    insert(other.begin(), other.end());
+    return *this;
+  }
+  sherwood_v3_table& operator=(sherwood_v3_table&& other) noexcept {
+    if (this == std::addressof(other))
+      return *this;
+    else if (AllocatorTraits::propagate_on_container_move_assignment::value) {
+      clear();
+      reset_to_empty_state();
+      AssignIfTrue<
+          EntryAlloc,
+          AllocatorTraits::propagate_on_container_move_assignment::value>()(
+          *this, std::move(other));
+      swap_pointers(other);
+    } else if (
+        static_cast<EntryAlloc&>(*this) == static_cast<EntryAlloc&>(other)) {
+      swap_pointers(other);
+    } else {
+      clear();
+      _max_load_factor = other._max_load_factor;
+      rehash_for_other_container(other);
+      for (T& elem : other)
+        emplace(std::move(elem));
+      other.clear();
+    }
+    static_cast<Hasher&>(*this) = std::move(other);
+    static_cast<Equal&>(*this) = std::move(other);
+    return *this;
+  }
+  ~sherwood_v3_table() {
+    clear();
+    deallocate_data(entries, num_slots_minus_one, max_lookups);
+  }
+
+  const allocator_type& get_allocator() const {
+    return static_cast<const allocator_type&>(*this);
+  }
+  const ArgumentEqual& key_eq() const {
+    return static_cast<const ArgumentEqual&>(*this);
+  }
+  const ArgumentHash& hash_function() const {
+    return static_cast<const ArgumentHash&>(*this);
+  }
+
+  template <typename ValueType>
+  struct templated_iterator {
+    templated_iterator() = default;
+    templated_iterator(EntryPointer current) : current(current) {}
+    EntryPointer current = EntryPointer();
+
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = ValueType;
+    using difference_type = ptrdiff_t;
+    using pointer = ValueType*;
+    using reference = ValueType&;
+
+    friend bool operator==(
+        const templated_iterator& lhs,
+        const templated_iterator& rhs) {
+      return lhs.current == rhs.current;
+    }
+    friend bool operator!=(
+        const templated_iterator& lhs,
+        const templated_iterator& rhs) {
+      return !(lhs == rhs);
+    }
+
+    templated_iterator& operator++() {
+      current = current->next;
+      return *this;
+    }
+    templated_iterator operator++(int) {
+      templated_iterator copy(*this);
+      ++*this;
+      return copy;
+    }
+
+    ValueType& operator*() const {
+      return current->value;
+    }
+    ValueType* operator->() const {
+      return std::addressof(current->value);
+    }
+
+    // the template automatically disables the operator when value_type is
+    // already const, because that would cause a lot of compiler warnings
+    // otherwise.
+    template <
+        class target_type = const value_type,
+        class = typename std::enable_if<
+            std::is_same<target_type, const value_type>::value &&
+            !std::is_same<target_type, value_type>::value>::type>
+    operator templated_iterator<target_type>() const {
+      return {current};
+    }
+  };
+  using iterator = templated_iterator<value_type>;
+  using const_iterator = templated_iterator<const value_type>;
+
+  iterator begin() {
+    return sentinel->next;
+  }
+  const_iterator begin() const {
+    return sentinel->next;
+  }
+  const_iterator cbegin() const {
+    return begin();
+  }
+  iterator end() {
+    return sentinel;
+  }
+  const_iterator end() const {
+    return sentinel;
+  }
+  const_iterator cend() const {
+    return end();
+  }
+
+  iterator find(const FindKey& key) {
+    uint64_t index =
+        hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+    EntryPointer it = entries + ptrdiff_t(index);
+    for (int8_t distance = 0; it->distance_from_desired >= distance;
+         ++distance, ++it) {
+      if (compares_equal(key, it->value))
+        return {it};
+    }
+    return end();
+  }
+  const_iterator find(const FindKey& key) const {
+    return const_cast<sherwood_v3_table*>(this)->find(key);
+  }
+  uint64_t count(const FindKey& key) const {
+    return find(key) == end() ? 0 : 1;
+  }
+  std::pair<iterator, iterator> equal_range(const FindKey& key) {
+    iterator found = find(key);
+    if (found == end())
+      return {found, found};
+    else
+      return {found, std::next(found)};
+  }
+  std::pair<const_iterator, const_iterator> equal_range(
+      const FindKey& key) const {
+    const_iterator found = find(key);
+    if (found == end())
+      return {found, found};
+    else
+      return {found, std::next(found)};
+  }
+
+  template <typename Key, typename... Args>
+  std::pair<iterator, bool> emplace(Key&& key, Args&&... args) {
+    uint64_t index =
+        hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+    EntryPointer current_entry = entries + ptrdiff_t(index);
+    int8_t distance_from_desired = 0;
+    for (; current_entry->distance_from_desired >= distance_from_desired;
+         ++current_entry, ++distance_from_desired) {
+      // insertion of an existing key does not change ordering
+      if (compares_equal(key, current_entry->value))
+        return {{current_entry}, false};
+    }
+    return emplace_new_key(
+        distance_from_desired,
+        current_entry,
+        std::forward<Key>(key),
+        std::forward<Args>(args)...);
+  }
+
+  std::pair<iterator, bool> insert(const value_type& value) {
+    return emplace(value);
+  }
+  std::pair<iterator, bool> insert(value_type&& value) {
+    return emplace(std::move(value));
+  }
+  template <typename... Args>
+  iterator emplace_hint(const_iterator, Args&&... args) {
+    return emplace(std::forward<Args>(args)...).first;
+  }
+  iterator insert(const_iterator, const value_type& value) {
+    return emplace(value).first;
+  }
+  iterator insert(const_iterator, value_type&& value) {
+    return emplace(std::move(value)).first;
+  }
+
+  template <typename It>
+  void insert(It begin, It end) {
+    for (; begin != end; ++begin) {
+      emplace(*begin);
+    }
+  }
+  void insert(std::initializer_list<value_type> il) {
+    insert(il.begin(), il.end());
+  }
+
+  void rehash(uint64_t num_buckets) {
+    num_buckets = std::max(
+        num_buckets,
+        static_cast<uint64_t>(
+            std::ceil(num_elements / static_cast<double>(_max_load_factor))));
+    if (num_buckets == 0) {
+      reset_to_empty_state();
+      return;
+    }
+    auto new_prime_index = hash_policy.next_size_over(num_buckets);
+    if (num_buckets == bucket_count())
+      return;
+    int8_t new_max_lookups = compute_max_lookups(num_buckets);
+    EntryPointer new_buckets(
+        AllocatorTraits::allocate(*this, num_buckets + new_max_lookups));
+    EntryPointer special_end_item =
+        new_buckets + static_cast<ptrdiff_t>(num_buckets + new_max_lookups - 1);
+    for (EntryPointer it = new_buckets; it != special_end_item; ++it)
+      it->distance_from_desired = -1;
+    special_end_item->distance_from_desired = Entry::special_end_value;
+    std::swap(entries, new_buckets);
+    std::swap(num_slots_minus_one, num_buckets);
+    --num_slots_minus_one;
+    hash_policy.commit(new_prime_index);
+    int8_t old_max_lookups = max_lookups;
+    max_lookups = new_max_lookups;
+    num_elements = 0;
+
+    auto start = sentinel->next;
+    // point sentinel to itself;
+    reset_list();
+    // reinsert list
+    for (EntryPointer it = start; it != sentinel;) {
+      auto next = it->next;
+      emplace(std::move(it->value));
+      it->destroy_value();
+      it = next;
+    }
+
+    deallocate_data(new_buckets, num_buckets, old_max_lookups);
+  }
+
+  void reserve(uint64_t num_elements) {
+    uint64_t required_buckets = num_buckets_for_reserve(num_elements);
+    if (required_buckets > bucket_count())
+      rehash(required_buckets);
+  }
+
+  void replace_linked_list_position(
+      EntryPointer to_be_replaced,
+      EntryPointer new_node) {
+    remove_from_list(new_node);
+    insert_after(new_node, to_be_replaced->prev);
+    remove_from_list(to_be_replaced);
+  }
+
+  // the return value is a type that can be converted to an iterator
+  // the reason for doing this is that it's not free to find the
+  // iterator pointing at the next element. if you care about the
+  // next iterator, turn the return value into an iterator
+  convertible_to_iterator erase(const_iterator to_erase) {
+    EntryPointer current = to_erase.current;
+    remove_from_list(current);
+    current->destroy_value();
+    --num_elements;
+
+    for (EntryPointer next = current + ptrdiff_t(1);
+         !next->is_at_desired_position();
+         ++current, ++next) {
+      // if an entry is being removed, and there are other entries with the
+      // same hash, the other entries get moved to their desired position by
+      // reinserting.
+      current->emplace(next->distance_from_desired - 1, std::move(next->value));
+      replace_linked_list_position(next, current);
+      next->destroy_value();
+    }
+    return {to_erase.current};
+  }
+
+  iterator erase(const_iterator begin_it, const_iterator end_it) {
+    // whenever an entry is removed and there are other entries with the same
+    // hash, the other entries must get moved to their desired position.
+    // any reference to a moved entry is invalidated.
+    // here, we iterate through the range, and make sure that we update
+    // the pointer to our next entry in the list or the end of the iterator
+    // when it is invalidated.
+
+    auto curr_iter = begin_it.current;
+    auto next_iter = curr_iter->next;
+    auto end_iter = end_it.current;
+
+    while (curr_iter != end_iter) {
+      remove_from_list(curr_iter);
+      curr_iter->destroy_value();
+      --num_elements;
+
+      for (EntryPointer next_hash_slot = curr_iter + ptrdiff_t(1);
+           !next_hash_slot->is_at_desired_position();
+           ++curr_iter, ++next_hash_slot) {
+        curr_iter->emplace(
+            next_hash_slot->distance_from_desired - 1,
+            std::move(next_hash_slot->value));
+        replace_linked_list_position(next_hash_slot, curr_iter);
+        next_hash_slot->destroy_value();
+
+        // we are invalidating next_iter or end_iter
+        if (next_hash_slot == end_iter) {
+          end_iter = curr_iter;
+        } else if (next_hash_slot == next_iter) {
+          next_iter = curr_iter;
+        }
       }
-
-      auto p1_prev = p1->prev;
-      auto p1_next = p1->next;
-
-      auto p2_prev = p2->prev;
-      auto p2_next = p2->next;
-
-      p1_prev->next = p2;
-      p2->prev = p1_prev;
-
-      p1_next->prev = p2;
-      p2->next = p1_next;
-
-      p2_prev->next = p1;
-      p1->prev = p2_prev;
-
-      p2_next->prev = p1;
-      p1->next = p2_next;
+      curr_iter = next_iter;
+      next_iter = curr_iter->next;
     }
 
-    void append_to_list(EntryPointer new_tail) {
-      insert_after(new_tail, sentinel->prev);
+    return {end_iter};
+  }
+
+  uint64_t erase(const FindKey& key) {
+    auto found = find(key);
+    if (found == end())
+      return 0;
+    else {
+      erase(found);
+      return 1;
+    }
+  }
+
+  void clear() {
+    for (EntryPointer it = entries,
+                      end = it +
+             static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups);
+         it != end;
+         ++it) {
+      if (it->has_value())
+        it->destroy_value();
+    }
+    reset_list();
+    num_elements = 0;
+  }
+
+  void shrink_to_fit() {
+    rehash_for_other_container(*this);
+  }
+
+  void swap(sherwood_v3_table& other) {
+    using std::swap;
+    swap_pointers(other);
+    swap(static_cast<ArgumentHash&>(*this), static_cast<ArgumentHash&>(other));
+    swap(
+        static_cast<ArgumentEqual&>(*this), static_cast<ArgumentEqual&>(other));
+    if (AllocatorTraits::propagate_on_container_swap::value)
+      swap(static_cast<EntryAlloc&>(*this), static_cast<EntryAlloc&>(other));
+  }
+
+  uint64_t size() const {
+    return num_elements;
+  }
+  uint64_t max_size() const {
+    return (AllocatorTraits::max_size(*this)) / sizeof(Entry);
+  }
+  uint64_t bucket_count() const {
+    return num_slots_minus_one ? num_slots_minus_one + 1 : 0;
+  }
+  size_type max_bucket_count() const {
+    return (AllocatorTraits::max_size(*this) - min_lookups) / sizeof(Entry);
+  }
+  uint64_t bucket(const FindKey& key) const {
+    return hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
+  }
+  float load_factor() const {
+    uint64_t buckets = bucket_count();
+    if (buckets)
+      return static_cast<float>(num_elements) / bucket_count();
+    else
+      return 0;
+  }
+  void max_load_factor(float value) {
+    _max_load_factor = value;
+  }
+  float max_load_factor() const {
+    return _max_load_factor;
+  }
+
+  bool empty() const {
+    return num_elements == 0;
+  }
+
+ private:
+  EntryPointer entries = empty_default_table();
+  uint64_t num_slots_minus_one = 0;
+  typename HashPolicySelector<ArgumentHash>::type hash_policy;
+  int8_t max_lookups = detailv3::min_lookups - 1;
+  float _max_load_factor = 0.5f;
+  uint64_t num_elements = 0;
+  std::unique_ptr<sherwood_v3_entry<T>> sentinel_val;
+
+  // head of doubly linked list
+  EntryPointer sentinel = initSentinel();
+
+  EntryPointer initSentinel() {
+    // needs to be a pointer so that hash map can be used with forward declared
+    // types
+    sentinel_val = std::make_unique<sherwood_v3_entry<T>>();
+    sentinel = sentinel_val.get();
+    reset_list();
+    return sentinel;
+  }
+
+  EntryPointer empty_default_table() {
+    EntryPointer result =
+        AllocatorTraits::allocate(*this, detailv3::min_lookups);
+    EntryPointer special_end_item =
+        result + static_cast<ptrdiff_t>(detailv3::min_lookups - 1);
+    for (EntryPointer it = result; it != special_end_item; ++it)
+      it->distance_from_desired = -1;
+    special_end_item->distance_from_desired = Entry::special_end_value;
+    return result;
+  }
+
+  static int8_t compute_max_lookups(uint64_t num_buckets) {
+    int8_t desired = detailv3::log2(num_buckets);
+    return std::max(detailv3::min_lookups, desired);
+  }
+
+  uint64_t num_buckets_for_reserve(uint64_t num_elements) const {
+    return static_cast<uint64_t>(std::ceil(
+        num_elements / std::min(0.5, static_cast<double>(_max_load_factor))));
+  }
+  void rehash_for_other_container(const sherwood_v3_table& other) {
+    rehash(
+        std::min(num_buckets_for_reserve(other.size()), other.bucket_count()));
+  }
+
+  void swap_pointers(sherwood_v3_table& other) {
+    using std::swap;
+    swap(hash_policy, other.hash_policy);
+    swap(entries, other.entries);
+    swap(num_slots_minus_one, other.num_slots_minus_one);
+    swap(num_elements, other.num_elements);
+    swap(max_lookups, other.max_lookups);
+    swap(_max_load_factor, other._max_load_factor);
+    swap(sentinel, other.sentinel);
+    swap(sentinel_val, other.sentinel_val);
+  }
+
+  void reset_list() {
+    sentinel->next = sentinel;
+    sentinel->prev = sentinel;
+  }
+
+  void remove_from_list(EntryPointer elem) {
+    elem->prev->next = elem->next;
+    elem->next->prev = elem->prev;
+  }
+
+  void insert_after(EntryPointer new_elem, EntryPointer prev) {
+    auto next = prev->next;
+
+    prev->next = new_elem;
+    new_elem->prev = prev;
+
+    new_elem->next = next;
+    next->prev = new_elem;
+  }
+
+  void swap_adjacent_nodes(EntryPointer before, EntryPointer after) {
+    // sentinel stays consant, so before->prev cannot equal after
+    auto before_prev = before->prev;
+    auto after_next = after->next;
+
+    before_prev->next = after;
+    after->prev = before_prev;
+
+    after_next->prev = before;
+    before->next = after_next;
+
+    before->prev = after;
+    after->next = before;
+  }
+
+  void swap_positions(EntryPointer p1, EntryPointer p2) {
+    if (p1 == p2) {
+      return;
+    }
+    if (p1->next == p2) {
+      return swap_adjacent_nodes(p1, p2);
+    } else if (p2->next == p1) {
+      return swap_adjacent_nodes(p2, p1);
     }
 
-    template<typename Key, typename... Args>
-    SKA_NOINLINE(std::pair<iterator, bool>) emplace_new_key(int8_t distance_from_desired, EntryPointer current_entry, Key && key, Args &&... args)
-    {
-        using std::swap;
-        if (num_slots_minus_one == 0 || distance_from_desired == max_lookups || num_elements + 1 > (num_slots_minus_one + 1) * static_cast<double>(_max_load_factor))
-        {
-            grow();
-            return emplace(std::forward<Key>(key), std::forward<Args>(args)...);
-        }
-        else if (current_entry->is_empty())
-        {
-            current_entry->emplace(distance_from_desired, std::forward<Key>(key), std::forward<Args>(args)...);
-            ++num_elements;
-            append_to_list(current_entry);
-            return { { current_entry }, true };
-        }
-        value_type to_insert(std::forward<Key>(key), std::forward<Args>(args)...);
+    auto p1_prev = p1->prev;
+    auto p1_next = p1->next;
+
+    auto p2_prev = p2->prev;
+    auto p2_next = p2->next;
+
+    p1_prev->next = p2;
+    p2->prev = p1_prev;
+
+    p1_next->prev = p2;
+    p2->next = p1_next;
+
+    p2_prev->next = p1;
+    p1->prev = p2_prev;
+
+    p2_next->prev = p1;
+    p1->next = p2_next;
+  }
+
+  void append_to_list(EntryPointer new_tail) {
+    insert_after(new_tail, sentinel->prev);
+  }
+
+  template <typename Key, typename... Args>
+  SKA_NOINLINE(std::pair<iterator, bool>)
+  emplace_new_key(
+      int8_t distance_from_desired,
+      EntryPointer current_entry,
+      Key&& key,
+      Args&&... args) {
+    using std::swap;
+    if (num_slots_minus_one == 0 || distance_from_desired == max_lookups ||
+        num_elements + 1 >
+            (num_slots_minus_one + 1) * static_cast<double>(_max_load_factor)) {
+      grow();
+      return emplace(std::forward<Key>(key), std::forward<Args>(args)...);
+    } else if (current_entry->is_empty()) {
+      current_entry->emplace(
+          distance_from_desired,
+          std::forward<Key>(key),
+          std::forward<Args>(args)...);
+      ++num_elements;
+      append_to_list(current_entry);
+      return {{current_entry}, true};
+    }
+    value_type to_insert(std::forward<Key>(key), std::forward<Args>(args)...);
+    swap(distance_from_desired, current_entry->distance_from_desired);
+    // We maintain the invariant that:
+    // - result.current_entry contains the new value we're inserting
+    //   and is in the LinkedList position of to_insert
+    // - to_insert contains the value that reprseents the position of
+    //   result.current_entry
+    swap(to_insert, current_entry->value);
+    iterator result = {current_entry};
+    for (++distance_from_desired, ++current_entry;; ++current_entry) {
+      if (current_entry->is_empty()) {
+        current_entry->emplace(distance_from_desired, std::move(to_insert));
+        append_to_list(current_entry);
+        // now we can swap back the displaced value to its correct position,
+        // putting the new value we're inserting to the front of the list
+        swap_positions(current_entry, result.current);
+        ++num_elements;
+        return {result, true};
+      } else if (current_entry->distance_from_desired < distance_from_desired) {
         swap(distance_from_desired, current_entry->distance_from_desired);
-        // We maintain the invariant that:
-        // - result.current_entry contains the new value we're inserting
-        //   and is in the LinkedList position of to_insert
-        // - to_insert contains the value that reprseents the position of
-        //   result.current_entry
         swap(to_insert, current_entry->value);
-        iterator result = { current_entry };
-        for (++distance_from_desired, ++current_entry;; ++current_entry)
-        {
-            if (current_entry->is_empty())
-            {
-                current_entry->emplace(distance_from_desired, std::move(to_insert));
-                append_to_list(current_entry);
-                // now we can swap back the displaced value to its correct position,
-                // putting the new value we're inserting to the front of the list
-                swap_positions(current_entry, result.current);
-                ++num_elements;
-                return { result, true };
-            }
-            else if (current_entry->distance_from_desired < distance_from_desired)
-            {
-                swap(distance_from_desired, current_entry->distance_from_desired);
-                swap(to_insert, current_entry->value);
-                // to maintain our invariants we need to swap positions
-                // of result.current & current_entry:
-                swap_positions(result.current, current_entry);
-                ++distance_from_desired;
-            }
-            else
-            {
-                ++distance_from_desired;
-                if (distance_from_desired == max_lookups)
-                {
-                    // the displaced element gets put back into its correct position
-                    // we grow the hash table, and then try again to reinsert the new element
-                    swap(to_insert, result.current->value);
-                    grow();
-                    return emplace(std::move(to_insert));
-                }
-            }
+        // to maintain our invariants we need to swap positions
+        // of result.current & current_entry:
+        swap_positions(result.current, current_entry);
+        ++distance_from_desired;
+      } else {
+        ++distance_from_desired;
+        if (distance_from_desired == max_lookups) {
+          // the displaced element gets put back into its correct position
+          // we grow the hash table, and then try again to reinsert the new
+          // element
+          swap(to_insert, result.current->value);
+          grow();
+          return emplace(std::move(to_insert));
         }
+      }
     }
+  }
 
-    void grow()
-    {
-        rehash(std::max(uint64_t(4), 2 * bucket_count()));
+  void grow() {
+    rehash(std::max(uint64_t(4), 2 * bucket_count()));
+  }
+
+  void deallocate_data(
+      EntryPointer begin,
+      uint64_t num_slots_minus_one,
+      int8_t max_lookups) {
+    AllocatorTraits::deallocate(
+        *this, begin, num_slots_minus_one + max_lookups + 1);
+  }
+
+  void reset_to_empty_state() {
+    deallocate_data(entries, num_slots_minus_one, max_lookups);
+    entries = empty_default_table();
+    num_slots_minus_one = 0;
+    hash_policy.reset();
+    max_lookups = detailv3::min_lookups - 1;
+  }
+
+  template <typename U>
+  uint64_t hash_object(const U& key) {
+    return static_cast<Hasher&>(*this)(key);
+  }
+  template <typename U>
+  uint64_t hash_object(const U& key) const {
+    return static_cast<const Hasher&>(*this)(key);
+  }
+  template <typename L, typename R>
+  bool compares_equal(const L& lhs, const R& rhs) {
+    return static_cast<Equal&>(*this)(lhs, rhs);
+  }
+
+ public:
+  struct convertible_to_iterator {
+    EntryPointer it;
+
+    operator iterator() {
+      if (it->has_value())
+        return {it};
+      else
+        return ++iterator{it};
     }
-
-    void deallocate_data(EntryPointer begin, uint64_t num_slots_minus_one, int8_t max_lookups)
-    {
-        AllocatorTraits::deallocate(*this, begin, num_slots_minus_one + max_lookups + 1);
+    operator const_iterator() {
+      if (it->has_value())
+        return {it};
+      else
+        return ++const_iterator{it};
     }
-
-    void reset_to_empty_state()
-    {
-        deallocate_data(entries, num_slots_minus_one, max_lookups);
-        entries = empty_default_table();
-        num_slots_minus_one = 0;
-        hash_policy.reset();
-        max_lookups = detailv3::min_lookups - 1;
-    }
-
-    template<typename U>
-    uint64_t hash_object(const U & key)
-    {
-        return static_cast<Hasher &>(*this)(key);
-    }
-    template<typename U>
-    uint64_t hash_object(const U & key) const
-    {
-        return static_cast<const Hasher &>(*this)(key);
-    }
-    template<typename L, typename R>
-    bool compares_equal(const L & lhs, const R & rhs)
-    {
-        return static_cast<Equal &>(*this)(lhs, rhs);
-    }
-
-public:
-    struct convertible_to_iterator
-    {
-        EntryPointer it;
-
-        operator iterator()
-        {
-            if (it->has_value())
-                return { it };
-            else
-                return ++iterator{it};
-        }
-        operator const_iterator()
-        {
-            if (it->has_value())
-                return { it };
-            else
-                return ++const_iterator{it};
-        }
-    };
-
+  };
 };
-}
+} // namespace detailv3
 
-struct prime_number_hash_policy
-{
-    static uint64_t mod0(uint64_t) { return 0llu; }
-    static uint64_t mod2(uint64_t hash) { return hash % 2llu; }
-    static uint64_t mod3(uint64_t hash) { return hash % 3llu; }
-    static uint64_t mod5(uint64_t hash) { return hash % 5llu; }
-    static uint64_t mod7(uint64_t hash) { return hash % 7llu; }
-    static uint64_t mod11(uint64_t hash) { return hash % 11llu; }
-    static uint64_t mod13(uint64_t hash) { return hash % 13llu; }
-    static uint64_t mod17(uint64_t hash) { return hash % 17llu; }
-    static uint64_t mod23(uint64_t hash) { return hash % 23llu; }
-    static uint64_t mod29(uint64_t hash) { return hash % 29llu; }
-    static uint64_t mod37(uint64_t hash) { return hash % 37llu; }
-    static uint64_t mod47(uint64_t hash) { return hash % 47llu; }
-    static uint64_t mod59(uint64_t hash) { return hash % 59llu; }
-    static uint64_t mod73(uint64_t hash) { return hash % 73llu; }
-    static uint64_t mod97(uint64_t hash) { return hash % 97llu; }
-    static uint64_t mod127(uint64_t hash) { return hash % 127llu; }
-    static uint64_t mod151(uint64_t hash) { return hash % 151llu; }
-    static uint64_t mod197(uint64_t hash) { return hash % 197llu; }
-    static uint64_t mod251(uint64_t hash) { return hash % 251llu; }
-    static uint64_t mod313(uint64_t hash) { return hash % 313llu; }
-    static uint64_t mod397(uint64_t hash) { return hash % 397llu; }
-    static uint64_t mod499(uint64_t hash) { return hash % 499llu; }
-    static uint64_t mod631(uint64_t hash) { return hash % 631llu; }
-    static uint64_t mod797(uint64_t hash) { return hash % 797llu; }
-    static uint64_t mod1009(uint64_t hash) { return hash % 1009llu; }
-    static uint64_t mod1259(uint64_t hash) { return hash % 1259llu; }
-    static uint64_t mod1597(uint64_t hash) { return hash % 1597llu; }
-    static uint64_t mod2011(uint64_t hash) { return hash % 2011llu; }
-    static uint64_t mod2539(uint64_t hash) { return hash % 2539llu; }
-    static uint64_t mod3203(uint64_t hash) { return hash % 3203llu; }
-    static uint64_t mod4027(uint64_t hash) { return hash % 4027llu; }
-    static uint64_t mod5087(uint64_t hash) { return hash % 5087llu; }
-    static uint64_t mod6421(uint64_t hash) { return hash % 6421llu; }
-    static uint64_t mod8089(uint64_t hash) { return hash % 8089llu; }
-    static uint64_t mod10193(uint64_t hash) { return hash % 10193llu; }
-    static uint64_t mod12853(uint64_t hash) { return hash % 12853llu; }
-    static uint64_t mod16193(uint64_t hash) { return hash % 16193llu; }
-    static uint64_t mod20399(uint64_t hash) { return hash % 20399llu; }
-    static uint64_t mod25717(uint64_t hash) { return hash % 25717llu; }
-    static uint64_t mod32401(uint64_t hash) { return hash % 32401llu; }
-    static uint64_t mod40823(uint64_t hash) { return hash % 40823llu; }
-    static uint64_t mod51437(uint64_t hash) { return hash % 51437llu; }
-    static uint64_t mod64811(uint64_t hash) { return hash % 64811llu; }
-    static uint64_t mod81649(uint64_t hash) { return hash % 81649llu; }
-    static uint64_t mod102877(uint64_t hash) { return hash % 102877llu; }
-    static uint64_t mod129607(uint64_t hash) { return hash % 129607llu; }
-    static uint64_t mod163307(uint64_t hash) { return hash % 163307llu; }
-    static uint64_t mod205759(uint64_t hash) { return hash % 205759llu; }
-    static uint64_t mod259229(uint64_t hash) { return hash % 259229llu; }
-    static uint64_t mod326617(uint64_t hash) { return hash % 326617llu; }
-    static uint64_t mod411527(uint64_t hash) { return hash % 411527llu; }
-    static uint64_t mod518509(uint64_t hash) { return hash % 518509llu; }
-    static uint64_t mod653267(uint64_t hash) { return hash % 653267llu; }
-    static uint64_t mod823117(uint64_t hash) { return hash % 823117llu; }
-    static uint64_t mod1037059(uint64_t hash) { return hash % 1037059llu; }
-    static uint64_t mod1306601(uint64_t hash) { return hash % 1306601llu; }
-    static uint64_t mod1646237(uint64_t hash) { return hash % 1646237llu; }
-    static uint64_t mod2074129(uint64_t hash) { return hash % 2074129llu; }
-    static uint64_t mod2613229(uint64_t hash) { return hash % 2613229llu; }
-    static uint64_t mod3292489(uint64_t hash) { return hash % 3292489llu; }
-    static uint64_t mod4148279(uint64_t hash) { return hash % 4148279llu; }
-    static uint64_t mod5226491(uint64_t hash) { return hash % 5226491llu; }
-    static uint64_t mod6584983(uint64_t hash) { return hash % 6584983llu; }
-    static uint64_t mod8296553(uint64_t hash) { return hash % 8296553llu; }
-    static uint64_t mod10453007(uint64_t hash) { return hash % 10453007llu; }
-    static uint64_t mod13169977(uint64_t hash) { return hash % 13169977llu; }
-    static uint64_t mod16593127(uint64_t hash) { return hash % 16593127llu; }
-    static uint64_t mod20906033(uint64_t hash) { return hash % 20906033llu; }
-    static uint64_t mod26339969(uint64_t hash) { return hash % 26339969llu; }
-    static uint64_t mod33186281(uint64_t hash) { return hash % 33186281llu; }
-    static uint64_t mod41812097(uint64_t hash) { return hash % 41812097llu; }
-    static uint64_t mod52679969(uint64_t hash) { return hash % 52679969llu; }
-    static uint64_t mod66372617(uint64_t hash) { return hash % 66372617llu; }
-    static uint64_t mod83624237(uint64_t hash) { return hash % 83624237llu; }
-    static uint64_t mod105359939(uint64_t hash) { return hash % 105359939llu; }
-    static uint64_t mod132745199(uint64_t hash) { return hash % 132745199llu; }
-    static uint64_t mod167248483(uint64_t hash) { return hash % 167248483llu; }
-    static uint64_t mod210719881(uint64_t hash) { return hash % 210719881llu; }
-    static uint64_t mod265490441(uint64_t hash) { return hash % 265490441llu; }
-    static uint64_t mod334496971(uint64_t hash) { return hash % 334496971llu; }
-    static uint64_t mod421439783(uint64_t hash) { return hash % 421439783llu; }
-    static uint64_t mod530980861(uint64_t hash) { return hash % 530980861llu; }
-    static uint64_t mod668993977(uint64_t hash) { return hash % 668993977llu; }
-    static uint64_t mod842879579(uint64_t hash) { return hash % 842879579llu; }
-    static uint64_t mod1061961721(uint64_t hash) { return hash % 1061961721llu; }
-    static uint64_t mod1337987929(uint64_t hash) { return hash % 1337987929llu; }
-    static uint64_t mod1685759167(uint64_t hash) { return hash % 1685759167llu; }
-    static uint64_t mod2123923447(uint64_t hash) { return hash % 2123923447llu; }
-    static uint64_t mod2675975881(uint64_t hash) { return hash % 2675975881llu; }
-    static uint64_t mod3371518343(uint64_t hash) { return hash % 3371518343llu; }
-    static uint64_t mod4247846927(uint64_t hash) { return hash % 4247846927llu; }
-    static uint64_t mod5351951779(uint64_t hash) { return hash % 5351951779llu; }
-    static uint64_t mod6743036717(uint64_t hash) { return hash % 6743036717llu; }
-    static uint64_t mod8495693897(uint64_t hash) { return hash % 8495693897llu; }
-    static uint64_t mod10703903591(uint64_t hash) { return hash % 10703903591llu; }
-    static uint64_t mod13486073473(uint64_t hash) { return hash % 13486073473llu; }
-    static uint64_t mod16991387857(uint64_t hash) { return hash % 16991387857llu; }
-    static uint64_t mod21407807219(uint64_t hash) { return hash % 21407807219llu; }
-    static uint64_t mod26972146961(uint64_t hash) { return hash % 26972146961llu; }
-    static uint64_t mod33982775741(uint64_t hash) { return hash % 33982775741llu; }
-    static uint64_t mod42815614441(uint64_t hash) { return hash % 42815614441llu; }
-    static uint64_t mod53944293929(uint64_t hash) { return hash % 53944293929llu; }
-    static uint64_t mod67965551447(uint64_t hash) { return hash % 67965551447llu; }
-    static uint64_t mod85631228929(uint64_t hash) { return hash % 85631228929llu; }
-    static uint64_t mod107888587883(uint64_t hash) { return hash % 107888587883llu; }
-    static uint64_t mod135931102921(uint64_t hash) { return hash % 135931102921llu; }
-    static uint64_t mod171262457903(uint64_t hash) { return hash % 171262457903llu; }
-    static uint64_t mod215777175787(uint64_t hash) { return hash % 215777175787llu; }
-    static uint64_t mod271862205833(uint64_t hash) { return hash % 271862205833llu; }
-    static uint64_t mod342524915839(uint64_t hash) { return hash % 342524915839llu; }
-    static uint64_t mod431554351609(uint64_t hash) { return hash % 431554351609llu; }
-    static uint64_t mod543724411781(uint64_t hash) { return hash % 543724411781llu; }
-    static uint64_t mod685049831731(uint64_t hash) { return hash % 685049831731llu; }
-    static uint64_t mod863108703229(uint64_t hash) { return hash % 863108703229llu; }
-    static uint64_t mod1087448823553(uint64_t hash) { return hash % 1087448823553llu; }
-    static uint64_t mod1370099663459(uint64_t hash) { return hash % 1370099663459llu; }
-    static uint64_t mod1726217406467(uint64_t hash) { return hash % 1726217406467llu; }
-    static uint64_t mod2174897647073(uint64_t hash) { return hash % 2174897647073llu; }
-    static uint64_t mod2740199326961(uint64_t hash) { return hash % 2740199326961llu; }
-    static uint64_t mod3452434812973(uint64_t hash) { return hash % 3452434812973llu; }
-    static uint64_t mod4349795294267(uint64_t hash) { return hash % 4349795294267llu; }
-    static uint64_t mod5480398654009(uint64_t hash) { return hash % 5480398654009llu; }
-    static uint64_t mod6904869625999(uint64_t hash) { return hash % 6904869625999llu; }
-    static uint64_t mod8699590588571(uint64_t hash) { return hash % 8699590588571llu; }
-    static uint64_t mod10960797308051(uint64_t hash) { return hash % 10960797308051llu; }
-    static uint64_t mod13809739252051(uint64_t hash) { return hash % 13809739252051llu; }
-    static uint64_t mod17399181177241(uint64_t hash) { return hash % 17399181177241llu; }
-    static uint64_t mod21921594616111(uint64_t hash) { return hash % 21921594616111llu; }
-    static uint64_t mod27619478504183(uint64_t hash) { return hash % 27619478504183llu; }
-    static uint64_t mod34798362354533(uint64_t hash) { return hash % 34798362354533llu; }
-    static uint64_t mod43843189232363(uint64_t hash) { return hash % 43843189232363llu; }
-    static uint64_t mod55238957008387(uint64_t hash) { return hash % 55238957008387llu; }
-    static uint64_t mod69596724709081(uint64_t hash) { return hash % 69596724709081llu; }
-    static uint64_t mod87686378464759(uint64_t hash) { return hash % 87686378464759llu; }
-    static uint64_t mod110477914016779(uint64_t hash) { return hash % 110477914016779llu; }
-    static uint64_t mod139193449418173(uint64_t hash) { return hash % 139193449418173llu; }
-    static uint64_t mod175372756929481(uint64_t hash) { return hash % 175372756929481llu; }
-    static uint64_t mod220955828033581(uint64_t hash) { return hash % 220955828033581llu; }
-    static uint64_t mod278386898836457(uint64_t hash) { return hash % 278386898836457llu; }
-    static uint64_t mod350745513859007(uint64_t hash) { return hash % 350745513859007llu; }
-    static uint64_t mod441911656067171(uint64_t hash) { return hash % 441911656067171llu; }
-    static uint64_t mod556773797672909(uint64_t hash) { return hash % 556773797672909llu; }
-    static uint64_t mod701491027718027(uint64_t hash) { return hash % 701491027718027llu; }
-    static uint64_t mod883823312134381(uint64_t hash) { return hash % 883823312134381llu; }
-    static uint64_t mod1113547595345903(uint64_t hash) { return hash % 1113547595345903llu; }
-    static uint64_t mod1402982055436147(uint64_t hash) { return hash % 1402982055436147llu; }
-    static uint64_t mod1767646624268779(uint64_t hash) { return hash % 1767646624268779llu; }
-    static uint64_t mod2227095190691797(uint64_t hash) { return hash % 2227095190691797llu; }
-    static uint64_t mod2805964110872297(uint64_t hash) { return hash % 2805964110872297llu; }
-    static uint64_t mod3535293248537579(uint64_t hash) { return hash % 3535293248537579llu; }
-    static uint64_t mod4454190381383713(uint64_t hash) { return hash % 4454190381383713llu; }
-    static uint64_t mod5611928221744609(uint64_t hash) { return hash % 5611928221744609llu; }
-    static uint64_t mod7070586497075177(uint64_t hash) { return hash % 7070586497075177llu; }
-    static uint64_t mod8908380762767489(uint64_t hash) { return hash % 8908380762767489llu; }
-    static uint64_t mod11223856443489329(uint64_t hash) { return hash % 11223856443489329llu; }
-    static uint64_t mod14141172994150357(uint64_t hash) { return hash % 14141172994150357llu; }
-    static uint64_t mod17816761525534927(uint64_t hash) { return hash % 17816761525534927llu; }
-    static uint64_t mod22447712886978529(uint64_t hash) { return hash % 22447712886978529llu; }
-    static uint64_t mod28282345988300791(uint64_t hash) { return hash % 28282345988300791llu; }
-    static uint64_t mod35633523051069991(uint64_t hash) { return hash % 35633523051069991llu; }
-    static uint64_t mod44895425773957261(uint64_t hash) { return hash % 44895425773957261llu; }
-    static uint64_t mod56564691976601587(uint64_t hash) { return hash % 56564691976601587llu; }
-    static uint64_t mod71267046102139967(uint64_t hash) { return hash % 71267046102139967llu; }
-    static uint64_t mod89790851547914507(uint64_t hash) { return hash % 89790851547914507llu; }
-    static uint64_t mod113129383953203213(uint64_t hash) { return hash % 113129383953203213llu; }
-    static uint64_t mod142534092204280003(uint64_t hash) { return hash % 142534092204280003llu; }
-    static uint64_t mod179581703095829107(uint64_t hash) { return hash % 179581703095829107llu; }
-    static uint64_t mod226258767906406483(uint64_t hash) { return hash % 226258767906406483llu; }
-    static uint64_t mod285068184408560057(uint64_t hash) { return hash % 285068184408560057llu; }
-    static uint64_t mod359163406191658253(uint64_t hash) { return hash % 359163406191658253llu; }
-    static uint64_t mod452517535812813007(uint64_t hash) { return hash % 452517535812813007llu; }
-    static uint64_t mod570136368817120201(uint64_t hash) { return hash % 570136368817120201llu; }
-    static uint64_t mod718326812383316683(uint64_t hash) { return hash % 718326812383316683llu; }
-    static uint64_t mod905035071625626043(uint64_t hash) { return hash % 905035071625626043llu; }
-    static uint64_t mod1140272737634240411(uint64_t hash) { return hash % 1140272737634240411llu; }
-    static uint64_t mod1436653624766633509(uint64_t hash) { return hash % 1436653624766633509llu; }
-    static uint64_t mod1810070143251252131(uint64_t hash) { return hash % 1810070143251252131llu; }
-    static uint64_t mod2280545475268481167(uint64_t hash) { return hash % 2280545475268481167llu; }
-    static uint64_t mod2873307249533267101(uint64_t hash) { return hash % 2873307249533267101llu; }
-    static uint64_t mod3620140286502504283(uint64_t hash) { return hash % 3620140286502504283llu; }
-    static uint64_t mod4561090950536962147(uint64_t hash) { return hash % 4561090950536962147llu; }
-    static uint64_t mod5746614499066534157(uint64_t hash) { return hash % 5746614499066534157llu; }
-    static uint64_t mod7240280573005008577(uint64_t hash) { return hash % 7240280573005008577llu; }
-    static uint64_t mod9122181901073924329(uint64_t hash) { return hash % 9122181901073924329llu; }
-    static uint64_t mod11493228998133068689(uint64_t hash) { return hash % 11493228998133068689llu; }
-    static uint64_t mod14480561146010017169(uint64_t hash) { return hash % 14480561146010017169llu; }
-    static uint64_t mod18446744073709551557(uint64_t hash) { return hash % 18446744073709551557llu; }
+struct prime_number_hash_policy {
+  static uint64_t mod0(uint64_t) {
+    return 0llu;
+  }
+  static uint64_t mod2(uint64_t hash) {
+    return hash % 2llu;
+  }
+  static uint64_t mod3(uint64_t hash) {
+    return hash % 3llu;
+  }
+  static uint64_t mod5(uint64_t hash) {
+    return hash % 5llu;
+  }
+  static uint64_t mod7(uint64_t hash) {
+    return hash % 7llu;
+  }
+  static uint64_t mod11(uint64_t hash) {
+    return hash % 11llu;
+  }
+  static uint64_t mod13(uint64_t hash) {
+    return hash % 13llu;
+  }
+  static uint64_t mod17(uint64_t hash) {
+    return hash % 17llu;
+  }
+  static uint64_t mod23(uint64_t hash) {
+    return hash % 23llu;
+  }
+  static uint64_t mod29(uint64_t hash) {
+    return hash % 29llu;
+  }
+  static uint64_t mod37(uint64_t hash) {
+    return hash % 37llu;
+  }
+  static uint64_t mod47(uint64_t hash) {
+    return hash % 47llu;
+  }
+  static uint64_t mod59(uint64_t hash) {
+    return hash % 59llu;
+  }
+  static uint64_t mod73(uint64_t hash) {
+    return hash % 73llu;
+  }
+  static uint64_t mod97(uint64_t hash) {
+    return hash % 97llu;
+  }
+  static uint64_t mod127(uint64_t hash) {
+    return hash % 127llu;
+  }
+  static uint64_t mod151(uint64_t hash) {
+    return hash % 151llu;
+  }
+  static uint64_t mod197(uint64_t hash) {
+    return hash % 197llu;
+  }
+  static uint64_t mod251(uint64_t hash) {
+    return hash % 251llu;
+  }
+  static uint64_t mod313(uint64_t hash) {
+    return hash % 313llu;
+  }
+  static uint64_t mod397(uint64_t hash) {
+    return hash % 397llu;
+  }
+  static uint64_t mod499(uint64_t hash) {
+    return hash % 499llu;
+  }
+  static uint64_t mod631(uint64_t hash) {
+    return hash % 631llu;
+  }
+  static uint64_t mod797(uint64_t hash) {
+    return hash % 797llu;
+  }
+  static uint64_t mod1009(uint64_t hash) {
+    return hash % 1009llu;
+  }
+  static uint64_t mod1259(uint64_t hash) {
+    return hash % 1259llu;
+  }
+  static uint64_t mod1597(uint64_t hash) {
+    return hash % 1597llu;
+  }
+  static uint64_t mod2011(uint64_t hash) {
+    return hash % 2011llu;
+  }
+  static uint64_t mod2539(uint64_t hash) {
+    return hash % 2539llu;
+  }
+  static uint64_t mod3203(uint64_t hash) {
+    return hash % 3203llu;
+  }
+  static uint64_t mod4027(uint64_t hash) {
+    return hash % 4027llu;
+  }
+  static uint64_t mod5087(uint64_t hash) {
+    return hash % 5087llu;
+  }
+  static uint64_t mod6421(uint64_t hash) {
+    return hash % 6421llu;
+  }
+  static uint64_t mod8089(uint64_t hash) {
+    return hash % 8089llu;
+  }
+  static uint64_t mod10193(uint64_t hash) {
+    return hash % 10193llu;
+  }
+  static uint64_t mod12853(uint64_t hash) {
+    return hash % 12853llu;
+  }
+  static uint64_t mod16193(uint64_t hash) {
+    return hash % 16193llu;
+  }
+  static uint64_t mod20399(uint64_t hash) {
+    return hash % 20399llu;
+  }
+  static uint64_t mod25717(uint64_t hash) {
+    return hash % 25717llu;
+  }
+  static uint64_t mod32401(uint64_t hash) {
+    return hash % 32401llu;
+  }
+  static uint64_t mod40823(uint64_t hash) {
+    return hash % 40823llu;
+  }
+  static uint64_t mod51437(uint64_t hash) {
+    return hash % 51437llu;
+  }
+  static uint64_t mod64811(uint64_t hash) {
+    return hash % 64811llu;
+  }
+  static uint64_t mod81649(uint64_t hash) {
+    return hash % 81649llu;
+  }
+  static uint64_t mod102877(uint64_t hash) {
+    return hash % 102877llu;
+  }
+  static uint64_t mod129607(uint64_t hash) {
+    return hash % 129607llu;
+  }
+  static uint64_t mod163307(uint64_t hash) {
+    return hash % 163307llu;
+  }
+  static uint64_t mod205759(uint64_t hash) {
+    return hash % 205759llu;
+  }
+  static uint64_t mod259229(uint64_t hash) {
+    return hash % 259229llu;
+  }
+  static uint64_t mod326617(uint64_t hash) {
+    return hash % 326617llu;
+  }
+  static uint64_t mod411527(uint64_t hash) {
+    return hash % 411527llu;
+  }
+  static uint64_t mod518509(uint64_t hash) {
+    return hash % 518509llu;
+  }
+  static uint64_t mod653267(uint64_t hash) {
+    return hash % 653267llu;
+  }
+  static uint64_t mod823117(uint64_t hash) {
+    return hash % 823117llu;
+  }
+  static uint64_t mod1037059(uint64_t hash) {
+    return hash % 1037059llu;
+  }
+  static uint64_t mod1306601(uint64_t hash) {
+    return hash % 1306601llu;
+  }
+  static uint64_t mod1646237(uint64_t hash) {
+    return hash % 1646237llu;
+  }
+  static uint64_t mod2074129(uint64_t hash) {
+    return hash % 2074129llu;
+  }
+  static uint64_t mod2613229(uint64_t hash) {
+    return hash % 2613229llu;
+  }
+  static uint64_t mod3292489(uint64_t hash) {
+    return hash % 3292489llu;
+  }
+  static uint64_t mod4148279(uint64_t hash) {
+    return hash % 4148279llu;
+  }
+  static uint64_t mod5226491(uint64_t hash) {
+    return hash % 5226491llu;
+  }
+  static uint64_t mod6584983(uint64_t hash) {
+    return hash % 6584983llu;
+  }
+  static uint64_t mod8296553(uint64_t hash) {
+    return hash % 8296553llu;
+  }
+  static uint64_t mod10453007(uint64_t hash) {
+    return hash % 10453007llu;
+  }
+  static uint64_t mod13169977(uint64_t hash) {
+    return hash % 13169977llu;
+  }
+  static uint64_t mod16593127(uint64_t hash) {
+    return hash % 16593127llu;
+  }
+  static uint64_t mod20906033(uint64_t hash) {
+    return hash % 20906033llu;
+  }
+  static uint64_t mod26339969(uint64_t hash) {
+    return hash % 26339969llu;
+  }
+  static uint64_t mod33186281(uint64_t hash) {
+    return hash % 33186281llu;
+  }
+  static uint64_t mod41812097(uint64_t hash) {
+    return hash % 41812097llu;
+  }
+  static uint64_t mod52679969(uint64_t hash) {
+    return hash % 52679969llu;
+  }
+  static uint64_t mod66372617(uint64_t hash) {
+    return hash % 66372617llu;
+  }
+  static uint64_t mod83624237(uint64_t hash) {
+    return hash % 83624237llu;
+  }
+  static uint64_t mod105359939(uint64_t hash) {
+    return hash % 105359939llu;
+  }
+  static uint64_t mod132745199(uint64_t hash) {
+    return hash % 132745199llu;
+  }
+  static uint64_t mod167248483(uint64_t hash) {
+    return hash % 167248483llu;
+  }
+  static uint64_t mod210719881(uint64_t hash) {
+    return hash % 210719881llu;
+  }
+  static uint64_t mod265490441(uint64_t hash) {
+    return hash % 265490441llu;
+  }
+  static uint64_t mod334496971(uint64_t hash) {
+    return hash % 334496971llu;
+  }
+  static uint64_t mod421439783(uint64_t hash) {
+    return hash % 421439783llu;
+  }
+  static uint64_t mod530980861(uint64_t hash) {
+    return hash % 530980861llu;
+  }
+  static uint64_t mod668993977(uint64_t hash) {
+    return hash % 668993977llu;
+  }
+  static uint64_t mod842879579(uint64_t hash) {
+    return hash % 842879579llu;
+  }
+  static uint64_t mod1061961721(uint64_t hash) {
+    return hash % 1061961721llu;
+  }
+  static uint64_t mod1337987929(uint64_t hash) {
+    return hash % 1337987929llu;
+  }
+  static uint64_t mod1685759167(uint64_t hash) {
+    return hash % 1685759167llu;
+  }
+  static uint64_t mod2123923447(uint64_t hash) {
+    return hash % 2123923447llu;
+  }
+  static uint64_t mod2675975881(uint64_t hash) {
+    return hash % 2675975881llu;
+  }
+  static uint64_t mod3371518343(uint64_t hash) {
+    return hash % 3371518343llu;
+  }
+  static uint64_t mod4247846927(uint64_t hash) {
+    return hash % 4247846927llu;
+  }
+  static uint64_t mod5351951779(uint64_t hash) {
+    return hash % 5351951779llu;
+  }
+  static uint64_t mod6743036717(uint64_t hash) {
+    return hash % 6743036717llu;
+  }
+  static uint64_t mod8495693897(uint64_t hash) {
+    return hash % 8495693897llu;
+  }
+  static uint64_t mod10703903591(uint64_t hash) {
+    return hash % 10703903591llu;
+  }
+  static uint64_t mod13486073473(uint64_t hash) {
+    return hash % 13486073473llu;
+  }
+  static uint64_t mod16991387857(uint64_t hash) {
+    return hash % 16991387857llu;
+  }
+  static uint64_t mod21407807219(uint64_t hash) {
+    return hash % 21407807219llu;
+  }
+  static uint64_t mod26972146961(uint64_t hash) {
+    return hash % 26972146961llu;
+  }
+  static uint64_t mod33982775741(uint64_t hash) {
+    return hash % 33982775741llu;
+  }
+  static uint64_t mod42815614441(uint64_t hash) {
+    return hash % 42815614441llu;
+  }
+  static uint64_t mod53944293929(uint64_t hash) {
+    return hash % 53944293929llu;
+  }
+  static uint64_t mod67965551447(uint64_t hash) {
+    return hash % 67965551447llu;
+  }
+  static uint64_t mod85631228929(uint64_t hash) {
+    return hash % 85631228929llu;
+  }
+  static uint64_t mod107888587883(uint64_t hash) {
+    return hash % 107888587883llu;
+  }
+  static uint64_t mod135931102921(uint64_t hash) {
+    return hash % 135931102921llu;
+  }
+  static uint64_t mod171262457903(uint64_t hash) {
+    return hash % 171262457903llu;
+  }
+  static uint64_t mod215777175787(uint64_t hash) {
+    return hash % 215777175787llu;
+  }
+  static uint64_t mod271862205833(uint64_t hash) {
+    return hash % 271862205833llu;
+  }
+  static uint64_t mod342524915839(uint64_t hash) {
+    return hash % 342524915839llu;
+  }
+  static uint64_t mod431554351609(uint64_t hash) {
+    return hash % 431554351609llu;
+  }
+  static uint64_t mod543724411781(uint64_t hash) {
+    return hash % 543724411781llu;
+  }
+  static uint64_t mod685049831731(uint64_t hash) {
+    return hash % 685049831731llu;
+  }
+  static uint64_t mod863108703229(uint64_t hash) {
+    return hash % 863108703229llu;
+  }
+  static uint64_t mod1087448823553(uint64_t hash) {
+    return hash % 1087448823553llu;
+  }
+  static uint64_t mod1370099663459(uint64_t hash) {
+    return hash % 1370099663459llu;
+  }
+  static uint64_t mod1726217406467(uint64_t hash) {
+    return hash % 1726217406467llu;
+  }
+  static uint64_t mod2174897647073(uint64_t hash) {
+    return hash % 2174897647073llu;
+  }
+  static uint64_t mod2740199326961(uint64_t hash) {
+    return hash % 2740199326961llu;
+  }
+  static uint64_t mod3452434812973(uint64_t hash) {
+    return hash % 3452434812973llu;
+  }
+  static uint64_t mod4349795294267(uint64_t hash) {
+    return hash % 4349795294267llu;
+  }
+  static uint64_t mod5480398654009(uint64_t hash) {
+    return hash % 5480398654009llu;
+  }
+  static uint64_t mod6904869625999(uint64_t hash) {
+    return hash % 6904869625999llu;
+  }
+  static uint64_t mod8699590588571(uint64_t hash) {
+    return hash % 8699590588571llu;
+  }
+  static uint64_t mod10960797308051(uint64_t hash) {
+    return hash % 10960797308051llu;
+  }
+  static uint64_t mod13809739252051(uint64_t hash) {
+    return hash % 13809739252051llu;
+  }
+  static uint64_t mod17399181177241(uint64_t hash) {
+    return hash % 17399181177241llu;
+  }
+  static uint64_t mod21921594616111(uint64_t hash) {
+    return hash % 21921594616111llu;
+  }
+  static uint64_t mod27619478504183(uint64_t hash) {
+    return hash % 27619478504183llu;
+  }
+  static uint64_t mod34798362354533(uint64_t hash) {
+    return hash % 34798362354533llu;
+  }
+  static uint64_t mod43843189232363(uint64_t hash) {
+    return hash % 43843189232363llu;
+  }
+  static uint64_t mod55238957008387(uint64_t hash) {
+    return hash % 55238957008387llu;
+  }
+  static uint64_t mod69596724709081(uint64_t hash) {
+    return hash % 69596724709081llu;
+  }
+  static uint64_t mod87686378464759(uint64_t hash) {
+    return hash % 87686378464759llu;
+  }
+  static uint64_t mod110477914016779(uint64_t hash) {
+    return hash % 110477914016779llu;
+  }
+  static uint64_t mod139193449418173(uint64_t hash) {
+    return hash % 139193449418173llu;
+  }
+  static uint64_t mod175372756929481(uint64_t hash) {
+    return hash % 175372756929481llu;
+  }
+  static uint64_t mod220955828033581(uint64_t hash) {
+    return hash % 220955828033581llu;
+  }
+  static uint64_t mod278386898836457(uint64_t hash) {
+    return hash % 278386898836457llu;
+  }
+  static uint64_t mod350745513859007(uint64_t hash) {
+    return hash % 350745513859007llu;
+  }
+  static uint64_t mod441911656067171(uint64_t hash) {
+    return hash % 441911656067171llu;
+  }
+  static uint64_t mod556773797672909(uint64_t hash) {
+    return hash % 556773797672909llu;
+  }
+  static uint64_t mod701491027718027(uint64_t hash) {
+    return hash % 701491027718027llu;
+  }
+  static uint64_t mod883823312134381(uint64_t hash) {
+    return hash % 883823312134381llu;
+  }
+  static uint64_t mod1113547595345903(uint64_t hash) {
+    return hash % 1113547595345903llu;
+  }
+  static uint64_t mod1402982055436147(uint64_t hash) {
+    return hash % 1402982055436147llu;
+  }
+  static uint64_t mod1767646624268779(uint64_t hash) {
+    return hash % 1767646624268779llu;
+  }
+  static uint64_t mod2227095190691797(uint64_t hash) {
+    return hash % 2227095190691797llu;
+  }
+  static uint64_t mod2805964110872297(uint64_t hash) {
+    return hash % 2805964110872297llu;
+  }
+  static uint64_t mod3535293248537579(uint64_t hash) {
+    return hash % 3535293248537579llu;
+  }
+  static uint64_t mod4454190381383713(uint64_t hash) {
+    return hash % 4454190381383713llu;
+  }
+  static uint64_t mod5611928221744609(uint64_t hash) {
+    return hash % 5611928221744609llu;
+  }
+  static uint64_t mod7070586497075177(uint64_t hash) {
+    return hash % 7070586497075177llu;
+  }
+  static uint64_t mod8908380762767489(uint64_t hash) {
+    return hash % 8908380762767489llu;
+  }
+  static uint64_t mod11223856443489329(uint64_t hash) {
+    return hash % 11223856443489329llu;
+  }
+  static uint64_t mod14141172994150357(uint64_t hash) {
+    return hash % 14141172994150357llu;
+  }
+  static uint64_t mod17816761525534927(uint64_t hash) {
+    return hash % 17816761525534927llu;
+  }
+  static uint64_t mod22447712886978529(uint64_t hash) {
+    return hash % 22447712886978529llu;
+  }
+  static uint64_t mod28282345988300791(uint64_t hash) {
+    return hash % 28282345988300791llu;
+  }
+  static uint64_t mod35633523051069991(uint64_t hash) {
+    return hash % 35633523051069991llu;
+  }
+  static uint64_t mod44895425773957261(uint64_t hash) {
+    return hash % 44895425773957261llu;
+  }
+  static uint64_t mod56564691976601587(uint64_t hash) {
+    return hash % 56564691976601587llu;
+  }
+  static uint64_t mod71267046102139967(uint64_t hash) {
+    return hash % 71267046102139967llu;
+  }
+  static uint64_t mod89790851547914507(uint64_t hash) {
+    return hash % 89790851547914507llu;
+  }
+  static uint64_t mod113129383953203213(uint64_t hash) {
+    return hash % 113129383953203213llu;
+  }
+  static uint64_t mod142534092204280003(uint64_t hash) {
+    return hash % 142534092204280003llu;
+  }
+  static uint64_t mod179581703095829107(uint64_t hash) {
+    return hash % 179581703095829107llu;
+  }
+  static uint64_t mod226258767906406483(uint64_t hash) {
+    return hash % 226258767906406483llu;
+  }
+  static uint64_t mod285068184408560057(uint64_t hash) {
+    return hash % 285068184408560057llu;
+  }
+  static uint64_t mod359163406191658253(uint64_t hash) {
+    return hash % 359163406191658253llu;
+  }
+  static uint64_t mod452517535812813007(uint64_t hash) {
+    return hash % 452517535812813007llu;
+  }
+  static uint64_t mod570136368817120201(uint64_t hash) {
+    return hash % 570136368817120201llu;
+  }
+  static uint64_t mod718326812383316683(uint64_t hash) {
+    return hash % 718326812383316683llu;
+  }
+  static uint64_t mod905035071625626043(uint64_t hash) {
+    return hash % 905035071625626043llu;
+  }
+  static uint64_t mod1140272737634240411(uint64_t hash) {
+    return hash % 1140272737634240411llu;
+  }
+  static uint64_t mod1436653624766633509(uint64_t hash) {
+    return hash % 1436653624766633509llu;
+  }
+  static uint64_t mod1810070143251252131(uint64_t hash) {
+    return hash % 1810070143251252131llu;
+  }
+  static uint64_t mod2280545475268481167(uint64_t hash) {
+    return hash % 2280545475268481167llu;
+  }
+  static uint64_t mod2873307249533267101(uint64_t hash) {
+    return hash % 2873307249533267101llu;
+  }
+  static uint64_t mod3620140286502504283(uint64_t hash) {
+    return hash % 3620140286502504283llu;
+  }
+  static uint64_t mod4561090950536962147(uint64_t hash) {
+    return hash % 4561090950536962147llu;
+  }
+  static uint64_t mod5746614499066534157(uint64_t hash) {
+    return hash % 5746614499066534157llu;
+  }
+  static uint64_t mod7240280573005008577(uint64_t hash) {
+    return hash % 7240280573005008577llu;
+  }
+  static uint64_t mod9122181901073924329(uint64_t hash) {
+    return hash % 9122181901073924329llu;
+  }
+  static uint64_t mod11493228998133068689(uint64_t hash) {
+    return hash % 11493228998133068689llu;
+  }
+  static uint64_t mod14480561146010017169(uint64_t hash) {
+    return hash % 14480561146010017169llu;
+  }
+  static uint64_t mod18446744073709551557(uint64_t hash) {
+    return hash % 18446744073709551557llu;
+  }
 
-    using mod_function = uint64_t (*)(uint64_t);
+  using mod_function = uint64_t (*)(uint64_t);
 
-    mod_function next_size_over(uint64_t & size) const
-    {
-        // prime numbers generated by the following method:
-        // 1. start with a prime p = 2
-        // 2. go to wolfram alpha and get p = NextPrime(2 * p)
-        // 3. repeat 2. until you overflow 64 bits
-        // you now have large gaps which you would hit if somebody called reserve() with an unlucky number.
-        // 4. to fill the gaps for every prime p go to wolfram alpha and get ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in the gaps
-        // 5. get PrevPrime(2^64) and put it at the end
-        static constexpr const uint64_t prime_list[] =
-        {
-            2llu, 3llu, 5llu, 7llu, 11llu, 13llu, 17llu, 23llu, 29llu, 37llu, 47llu,
-            59llu, 73llu, 97llu, 127llu, 151llu, 197llu, 251llu, 313llu, 397llu,
-            499llu, 631llu, 797llu, 1009llu, 1259llu, 1597llu, 2011llu, 2539llu,
-            3203llu, 4027llu, 5087llu, 6421llu, 8089llu, 10193llu, 12853llu, 16193llu,
-            20399llu, 25717llu, 32401llu, 40823llu, 51437llu, 64811llu, 81649llu,
-            102877llu, 129607llu, 163307llu, 205759llu, 259229llu, 326617llu,
-            411527llu, 518509llu, 653267llu, 823117llu, 1037059llu, 1306601llu,
-            1646237llu, 2074129llu, 2613229llu, 3292489llu, 4148279llu, 5226491llu,
-            6584983llu, 8296553llu, 10453007llu, 13169977llu, 16593127llu, 20906033llu,
-            26339969llu, 33186281llu, 41812097llu, 52679969llu, 66372617llu,
-            83624237llu, 105359939llu, 132745199llu, 167248483llu, 210719881llu,
-            265490441llu, 334496971llu, 421439783llu, 530980861llu, 668993977llu,
-            842879579llu, 1061961721llu, 1337987929llu, 1685759167llu, 2123923447llu,
-            2675975881llu, 3371518343llu, 4247846927llu, 5351951779llu, 6743036717llu,
-            8495693897llu, 10703903591llu, 13486073473llu, 16991387857llu,
-            21407807219llu, 26972146961llu, 33982775741llu, 42815614441llu,
-            53944293929llu, 67965551447llu, 85631228929llu, 107888587883llu,
-            135931102921llu, 171262457903llu, 215777175787llu, 271862205833llu,
-            342524915839llu, 431554351609llu, 543724411781llu, 685049831731llu,
-            863108703229llu, 1087448823553llu, 1370099663459llu, 1726217406467llu,
-            2174897647073llu, 2740199326961llu, 3452434812973llu, 4349795294267llu,
-            5480398654009llu, 6904869625999llu, 8699590588571llu, 10960797308051llu,
-            13809739252051llu, 17399181177241llu, 21921594616111llu, 27619478504183llu,
-            34798362354533llu, 43843189232363llu, 55238957008387llu, 69596724709081llu,
-            87686378464759llu, 110477914016779llu, 139193449418173llu,
-            175372756929481llu, 220955828033581llu, 278386898836457llu,
-            350745513859007llu, 441911656067171llu, 556773797672909llu,
-            701491027718027llu, 883823312134381llu, 1113547595345903llu,
-            1402982055436147llu, 1767646624268779llu, 2227095190691797llu,
-            2805964110872297llu, 3535293248537579llu, 4454190381383713llu,
-            5611928221744609llu, 7070586497075177llu, 8908380762767489llu,
-            11223856443489329llu, 14141172994150357llu, 17816761525534927llu,
-            22447712886978529llu, 28282345988300791llu, 35633523051069991llu,
-            44895425773957261llu, 56564691976601587llu, 71267046102139967llu,
-            89790851547914507llu, 113129383953203213llu, 142534092204280003llu,
-            179581703095829107llu, 226258767906406483llu, 285068184408560057llu,
-            359163406191658253llu, 452517535812813007llu, 570136368817120201llu,
-            718326812383316683llu, 905035071625626043llu, 1140272737634240411llu,
-            1436653624766633509llu, 1810070143251252131llu, 2280545475268481167llu,
-            2873307249533267101llu, 3620140286502504283llu, 4561090950536962147llu,
-            5746614499066534157llu, 7240280573005008577llu, 9122181901073924329llu,
-            11493228998133068689llu, 14480561146010017169llu, 18446744073709551557llu
-        };
-        static constexpr uint64_t (* const mod_functions[])(uint64_t) =
-        {
-            &mod0, &mod2, &mod3, &mod5, &mod7, &mod11, &mod13, &mod17, &mod23, &mod29, &mod37,
-            &mod47, &mod59, &mod73, &mod97, &mod127, &mod151, &mod197, &mod251, &mod313, &mod397,
-            &mod499, &mod631, &mod797, &mod1009, &mod1259, &mod1597, &mod2011, &mod2539, &mod3203,
-            &mod4027, &mod5087, &mod6421, &mod8089, &mod10193, &mod12853, &mod16193, &mod20399,
-            &mod25717, &mod32401, &mod40823, &mod51437, &mod64811, &mod81649, &mod102877,
-            &mod129607, &mod163307, &mod205759, &mod259229, &mod326617, &mod411527, &mod518509,
-            &mod653267, &mod823117, &mod1037059, &mod1306601, &mod1646237, &mod2074129,
-            &mod2613229, &mod3292489, &mod4148279, &mod5226491, &mod6584983, &mod8296553,
-            &mod10453007, &mod13169977, &mod16593127, &mod20906033, &mod26339969, &mod33186281,
-            &mod41812097, &mod52679969, &mod66372617, &mod83624237, &mod105359939, &mod132745199,
-            &mod167248483, &mod210719881, &mod265490441, &mod334496971, &mod421439783,
-            &mod530980861, &mod668993977, &mod842879579, &mod1061961721, &mod1337987929,
-            &mod1685759167, &mod2123923447, &mod2675975881, &mod3371518343, &mod4247846927,
-            &mod5351951779, &mod6743036717, &mod8495693897, &mod10703903591, &mod13486073473,
-            &mod16991387857, &mod21407807219, &mod26972146961, &mod33982775741, &mod42815614441,
-            &mod53944293929, &mod67965551447, &mod85631228929, &mod107888587883, &mod135931102921,
-            &mod171262457903, &mod215777175787, &mod271862205833, &mod342524915839,
-            &mod431554351609, &mod543724411781, &mod685049831731, &mod863108703229,
-            &mod1087448823553, &mod1370099663459, &mod1726217406467, &mod2174897647073,
-            &mod2740199326961, &mod3452434812973, &mod4349795294267, &mod5480398654009,
-            &mod6904869625999, &mod8699590588571, &mod10960797308051, &mod13809739252051,
-            &mod17399181177241, &mod21921594616111, &mod27619478504183, &mod34798362354533,
-            &mod43843189232363, &mod55238957008387, &mod69596724709081, &mod87686378464759,
-            &mod110477914016779, &mod139193449418173, &mod175372756929481, &mod220955828033581,
-            &mod278386898836457, &mod350745513859007, &mod441911656067171, &mod556773797672909,
-            &mod701491027718027, &mod883823312134381, &mod1113547595345903, &mod1402982055436147,
-            &mod1767646624268779, &mod2227095190691797, &mod2805964110872297, &mod3535293248537579,
-            &mod4454190381383713, &mod5611928221744609, &mod7070586497075177, &mod8908380762767489,
-            &mod11223856443489329, &mod14141172994150357, &mod17816761525534927,
-            &mod22447712886978529, &mod28282345988300791, &mod35633523051069991,
-            &mod44895425773957261, &mod56564691976601587, &mod71267046102139967,
-            &mod89790851547914507, &mod113129383953203213, &mod142534092204280003,
-            &mod179581703095829107, &mod226258767906406483, &mod285068184408560057,
-            &mod359163406191658253, &mod452517535812813007, &mod570136368817120201,
-            &mod718326812383316683, &mod905035071625626043, &mod1140272737634240411,
-            &mod1436653624766633509, &mod1810070143251252131, &mod2280545475268481167,
-            &mod2873307249533267101, &mod3620140286502504283, &mod4561090950536962147,
-            &mod5746614499066534157, &mod7240280573005008577, &mod9122181901073924329,
-            &mod11493228998133068689, &mod14480561146010017169, &mod18446744073709551557
-        };
-        const uint64_t * found = std::lower_bound(std::begin(prime_list), std::end(prime_list) - 1, size);
-        size = *found;
-        return mod_functions[1 + found - prime_list];
-    }
-    void commit(mod_function new_mod_function)
-    {
-        current_mod_function = new_mod_function;
-    }
-    void reset()
-    {
-        current_mod_function = &mod0;
-    }
+  mod_function next_size_over(uint64_t& size) const {
+    // prime numbers generated by the following method:
+    // 1. start with a prime p = 2
+    // 2. go to wolfram alpha and get p = NextPrime(2 * p)
+    // 3. repeat 2. until you overflow 64 bits
+    // you now have large gaps which you would hit if somebody called reserve()
+    // with an unlucky number.
+    // 4. to fill the gaps for every prime p go to wolfram alpha and get
+    // ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in
+    // the gaps
+    // 5. get PrevPrime(2^64) and put it at the end
+    static constexpr const uint64_t prime_list[] = {
+        2llu,
+        3llu,
+        5llu,
+        7llu,
+        11llu,
+        13llu,
+        17llu,
+        23llu,
+        29llu,
+        37llu,
+        47llu,
+        59llu,
+        73llu,
+        97llu,
+        127llu,
+        151llu,
+        197llu,
+        251llu,
+        313llu,
+        397llu,
+        499llu,
+        631llu,
+        797llu,
+        1009llu,
+        1259llu,
+        1597llu,
+        2011llu,
+        2539llu,
+        3203llu,
+        4027llu,
+        5087llu,
+        6421llu,
+        8089llu,
+        10193llu,
+        12853llu,
+        16193llu,
+        20399llu,
+        25717llu,
+        32401llu,
+        40823llu,
+        51437llu,
+        64811llu,
+        81649llu,
+        102877llu,
+        129607llu,
+        163307llu,
+        205759llu,
+        259229llu,
+        326617llu,
+        411527llu,
+        518509llu,
+        653267llu,
+        823117llu,
+        1037059llu,
+        1306601llu,
+        1646237llu,
+        2074129llu,
+        2613229llu,
+        3292489llu,
+        4148279llu,
+        5226491llu,
+        6584983llu,
+        8296553llu,
+        10453007llu,
+        13169977llu,
+        16593127llu,
+        20906033llu,
+        26339969llu,
+        33186281llu,
+        41812097llu,
+        52679969llu,
+        66372617llu,
+        83624237llu,
+        105359939llu,
+        132745199llu,
+        167248483llu,
+        210719881llu,
+        265490441llu,
+        334496971llu,
+        421439783llu,
+        530980861llu,
+        668993977llu,
+        842879579llu,
+        1061961721llu,
+        1337987929llu,
+        1685759167llu,
+        2123923447llu,
+        2675975881llu,
+        3371518343llu,
+        4247846927llu,
+        5351951779llu,
+        6743036717llu,
+        8495693897llu,
+        10703903591llu,
+        13486073473llu,
+        16991387857llu,
+        21407807219llu,
+        26972146961llu,
+        33982775741llu,
+        42815614441llu,
+        53944293929llu,
+        67965551447llu,
+        85631228929llu,
+        107888587883llu,
+        135931102921llu,
+        171262457903llu,
+        215777175787llu,
+        271862205833llu,
+        342524915839llu,
+        431554351609llu,
+        543724411781llu,
+        685049831731llu,
+        863108703229llu,
+        1087448823553llu,
+        1370099663459llu,
+        1726217406467llu,
+        2174897647073llu,
+        2740199326961llu,
+        3452434812973llu,
+        4349795294267llu,
+        5480398654009llu,
+        6904869625999llu,
+        8699590588571llu,
+        10960797308051llu,
+        13809739252051llu,
+        17399181177241llu,
+        21921594616111llu,
+        27619478504183llu,
+        34798362354533llu,
+        43843189232363llu,
+        55238957008387llu,
+        69596724709081llu,
+        87686378464759llu,
+        110477914016779llu,
+        139193449418173llu,
+        175372756929481llu,
+        220955828033581llu,
+        278386898836457llu,
+        350745513859007llu,
+        441911656067171llu,
+        556773797672909llu,
+        701491027718027llu,
+        883823312134381llu,
+        1113547595345903llu,
+        1402982055436147llu,
+        1767646624268779llu,
+        2227095190691797llu,
+        2805964110872297llu,
+        3535293248537579llu,
+        4454190381383713llu,
+        5611928221744609llu,
+        7070586497075177llu,
+        8908380762767489llu,
+        11223856443489329llu,
+        14141172994150357llu,
+        17816761525534927llu,
+        22447712886978529llu,
+        28282345988300791llu,
+        35633523051069991llu,
+        44895425773957261llu,
+        56564691976601587llu,
+        71267046102139967llu,
+        89790851547914507llu,
+        113129383953203213llu,
+        142534092204280003llu,
+        179581703095829107llu,
+        226258767906406483llu,
+        285068184408560057llu,
+        359163406191658253llu,
+        452517535812813007llu,
+        570136368817120201llu,
+        718326812383316683llu,
+        905035071625626043llu,
+        1140272737634240411llu,
+        1436653624766633509llu,
+        1810070143251252131llu,
+        2280545475268481167llu,
+        2873307249533267101llu,
+        3620140286502504283llu,
+        4561090950536962147llu,
+        5746614499066534157llu,
+        7240280573005008577llu,
+        9122181901073924329llu,
+        11493228998133068689llu,
+        14480561146010017169llu,
+        18446744073709551557llu};
+    static constexpr uint64_t (*const mod_functions[])(uint64_t) = {
+        &mod0,
+        &mod2,
+        &mod3,
+        &mod5,
+        &mod7,
+        &mod11,
+        &mod13,
+        &mod17,
+        &mod23,
+        &mod29,
+        &mod37,
+        &mod47,
+        &mod59,
+        &mod73,
+        &mod97,
+        &mod127,
+        &mod151,
+        &mod197,
+        &mod251,
+        &mod313,
+        &mod397,
+        &mod499,
+        &mod631,
+        &mod797,
+        &mod1009,
+        &mod1259,
+        &mod1597,
+        &mod2011,
+        &mod2539,
+        &mod3203,
+        &mod4027,
+        &mod5087,
+        &mod6421,
+        &mod8089,
+        &mod10193,
+        &mod12853,
+        &mod16193,
+        &mod20399,
+        &mod25717,
+        &mod32401,
+        &mod40823,
+        &mod51437,
+        &mod64811,
+        &mod81649,
+        &mod102877,
+        &mod129607,
+        &mod163307,
+        &mod205759,
+        &mod259229,
+        &mod326617,
+        &mod411527,
+        &mod518509,
+        &mod653267,
+        &mod823117,
+        &mod1037059,
+        &mod1306601,
+        &mod1646237,
+        &mod2074129,
+        &mod2613229,
+        &mod3292489,
+        &mod4148279,
+        &mod5226491,
+        &mod6584983,
+        &mod8296553,
+        &mod10453007,
+        &mod13169977,
+        &mod16593127,
+        &mod20906033,
+        &mod26339969,
+        &mod33186281,
+        &mod41812097,
+        &mod52679969,
+        &mod66372617,
+        &mod83624237,
+        &mod105359939,
+        &mod132745199,
+        &mod167248483,
+        &mod210719881,
+        &mod265490441,
+        &mod334496971,
+        &mod421439783,
+        &mod530980861,
+        &mod668993977,
+        &mod842879579,
+        &mod1061961721,
+        &mod1337987929,
+        &mod1685759167,
+        &mod2123923447,
+        &mod2675975881,
+        &mod3371518343,
+        &mod4247846927,
+        &mod5351951779,
+        &mod6743036717,
+        &mod8495693897,
+        &mod10703903591,
+        &mod13486073473,
+        &mod16991387857,
+        &mod21407807219,
+        &mod26972146961,
+        &mod33982775741,
+        &mod42815614441,
+        &mod53944293929,
+        &mod67965551447,
+        &mod85631228929,
+        &mod107888587883,
+        &mod135931102921,
+        &mod171262457903,
+        &mod215777175787,
+        &mod271862205833,
+        &mod342524915839,
+        &mod431554351609,
+        &mod543724411781,
+        &mod685049831731,
+        &mod863108703229,
+        &mod1087448823553,
+        &mod1370099663459,
+        &mod1726217406467,
+        &mod2174897647073,
+        &mod2740199326961,
+        &mod3452434812973,
+        &mod4349795294267,
+        &mod5480398654009,
+        &mod6904869625999,
+        &mod8699590588571,
+        &mod10960797308051,
+        &mod13809739252051,
+        &mod17399181177241,
+        &mod21921594616111,
+        &mod27619478504183,
+        &mod34798362354533,
+        &mod43843189232363,
+        &mod55238957008387,
+        &mod69596724709081,
+        &mod87686378464759,
+        &mod110477914016779,
+        &mod139193449418173,
+        &mod175372756929481,
+        &mod220955828033581,
+        &mod278386898836457,
+        &mod350745513859007,
+        &mod441911656067171,
+        &mod556773797672909,
+        &mod701491027718027,
+        &mod883823312134381,
+        &mod1113547595345903,
+        &mod1402982055436147,
+        &mod1767646624268779,
+        &mod2227095190691797,
+        &mod2805964110872297,
+        &mod3535293248537579,
+        &mod4454190381383713,
+        &mod5611928221744609,
+        &mod7070586497075177,
+        &mod8908380762767489,
+        &mod11223856443489329,
+        &mod14141172994150357,
+        &mod17816761525534927,
+        &mod22447712886978529,
+        &mod28282345988300791,
+        &mod35633523051069991,
+        &mod44895425773957261,
+        &mod56564691976601587,
+        &mod71267046102139967,
+        &mod89790851547914507,
+        &mod113129383953203213,
+        &mod142534092204280003,
+        &mod179581703095829107,
+        &mod226258767906406483,
+        &mod285068184408560057,
+        &mod359163406191658253,
+        &mod452517535812813007,
+        &mod570136368817120201,
+        &mod718326812383316683,
+        &mod905035071625626043,
+        &mod1140272737634240411,
+        &mod1436653624766633509,
+        &mod1810070143251252131,
+        &mod2280545475268481167,
+        &mod2873307249533267101,
+        &mod3620140286502504283,
+        &mod4561090950536962147,
+        &mod5746614499066534157,
+        &mod7240280573005008577,
+        &mod9122181901073924329,
+        &mod11493228998133068689,
+        &mod14480561146010017169,
+        &mod18446744073709551557};
+    const uint64_t* found = std::lower_bound(
+        std::begin(prime_list), std::end(prime_list) - 1, size);
+    size = *found;
+    return mod_functions[1 + found - prime_list];
+  }
+  void commit(mod_function new_mod_function) {
+    current_mod_function = new_mod_function;
+  }
+  void reset() {
+    current_mod_function = &mod0;
+  }
 
-    uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const
-    {
-        return current_mod_function(hash);
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index > num_slots_minus_one ? current_mod_function(index) : index;
-    }
+  uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/)
+      const {
+    return current_mod_function(hash);
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index > num_slots_minus_one ? current_mod_function(index) : index;
+  }
 
-private:
-    mod_function current_mod_function = &mod0;
+ private:
+  mod_function current_mod_function = &mod0;
 };
 
-struct power_of_two_hash_policy
-{
-    uint64_t index_for_hash(uint64_t hash, uint64_t num_slots_minus_one) const
-    {
-        return hash & num_slots_minus_one;
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index_for_hash(index, num_slots_minus_one);
-    }
-    int8_t next_size_over(uint64_t & size) const
-    {
-        size = detailv3::next_power_of_two(size);
-        return 0;
-    }
-    void commit(int8_t)
-    {
-    }
-    void reset()
-    {
-    }
-
+struct power_of_two_hash_policy {
+  uint64_t index_for_hash(uint64_t hash, uint64_t num_slots_minus_one) const {
+    return hash & num_slots_minus_one;
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index_for_hash(index, num_slots_minus_one);
+  }
+  int8_t next_size_over(uint64_t& size) const {
+    size = detailv3::next_power_of_two(size);
+    return 0;
+  }
+  void commit(int8_t) {}
+  void reset() {}
 };
 
-struct fibonacci_hash_policy
-{
-    uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const
-    {
-        return (11400714819323198485ull * hash) >> shift;
-    }
-    uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const
-    {
-        return index & num_slots_minus_one;
-    }
+struct fibonacci_hash_policy {
+  uint64_t index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/)
+      const {
+    return (11400714819323198485ull * hash) >> shift;
+  }
+  uint64_t keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const {
+    return index & num_slots_minus_one;
+  }
 
-    int8_t next_size_over(uint64_t & size) const
-    {
-        size = std::max(uint64_t(2), detailv3::next_power_of_two(size));
-        return 64 - detailv3::log2(size);
-    }
-    void commit(int8_t shift)
-    {
-        this->shift = shift;
-    }
-    void reset()
-    {
-        shift = 63;
-    }
+  int8_t next_size_over(uint64_t& size) const {
+    size = std::max(uint64_t(2), detailv3::next_power_of_two(size));
+    return 64 - detailv3::log2(size);
+  }
+  void commit(int8_t shift) {
+    this->shift = shift;
+  }
+  void reset() {
+    shift = 63;
+  }
 
-private:
-    int8_t shift = 63;
+ private:
+  int8_t shift = 63;
 };
 
-template<typename K, typename V, typename H = std::hash<K>, typename E = std::equal_to<K>, typename A = std::allocator<std::pair<K, V> > >
+template <
+    typename K,
+    typename V,
+    typename H = std::hash<K>,
+    typename E = std::equal_to<K>,
+    typename A = std::allocator<std::pair<K, V>>>
 class order_preserving_flat_hash_map
-        : public detailv3::sherwood_v3_table
-        <
-            std::pair<K, V>,
-            K,
-            H,
-            detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
-            E,
-            detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
-            A,
-            typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<std::pair<K, V>>>
-        >
-{
-    using Table = detailv3::sherwood_v3_table
-    <
-        std::pair<K, V>,
-        K,
-        H,
-        detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
-        E,
-        detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
-        A,
-        typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<std::pair<K, V>>>
-    >;
-public:
+    : public detailv3::sherwood_v3_table<
+          std::pair<K, V>,
+          K,
+          H,
+          detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
+          E,
+          detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
+          A,
+          typename std::allocator_traits<A>::template rebind_alloc<
+              detailv3::sherwood_v3_entry<std::pair<K, V>>>> {
+  using Table = detailv3::sherwood_v3_table<
+      std::pair<K, V>,
+      K,
+      H,
+      detailv3::KeyOrValueHasher<K, std::pair<K, V>, H>,
+      E,
+      detailv3::KeyOrValueEquality<K, std::pair<K, V>, E>,
+      A,
+      typename std::allocator_traits<A>::template rebind_alloc<
+          detailv3::sherwood_v3_entry<std::pair<K, V>>>>;
 
-    using key_type = K;
-    using mapped_type = V;
+ public:
+  using key_type = K;
+  using mapped_type = V;
 
-    using Table::Table;
-    order_preserving_flat_hash_map()
-    {
-    }
+  using Table::Table;
+  order_preserving_flat_hash_map() {}
 
-    inline V & operator[](const K & key)
-    {
-        return emplace(key, convertible_to_value()).first->second;
-    }
-    inline V & operator[](K && key)
-    {
-        return emplace(std::move(key), convertible_to_value()).first->second;
-    }
-    V & at(const K & key)
-    {
-        auto found = this->find(key);
-        if (found == this->end())
-            throw std::out_of_range("Argument passed to at() was not in the map.");
-        return found->second;
-    }
-    const V & at(const K & key) const
-    {
-        auto found = this->find(key);
-        if (found == this->end())
-            throw std::out_of_range("Argument passed to at() was not in the map.");
-        return found->second;
-    }
+  inline V& operator[](const K& key) {
+    return emplace(key, convertible_to_value()).first->second;
+  }
+  inline V& operator[](K&& key) {
+    return emplace(std::move(key), convertible_to_value()).first->second;
+  }
+  V& at(const K& key) {
+    auto found = this->find(key);
+    if (found == this->end())
+      throw std::out_of_range("Argument passed to at() was not in the map.");
+    return found->second;
+  }
+  const V& at(const K& key) const {
+    auto found = this->find(key);
+    if (found == this->end())
+      throw std::out_of_range("Argument passed to at() was not in the map.");
+    return found->second;
+  }
 
-    using Table::emplace;
-    std::pair<typename Table::iterator, bool> emplace()
-    {
-        return emplace(key_type(), convertible_to_value());
-    }
-    template<typename M>
-    std::pair<typename Table::iterator, bool> insert_or_assign(const key_type & key, M && m)
-    {
-        auto emplace_result = emplace(key, std::forward<M>(m));
-        if (!emplace_result.second)
-            emplace_result.first->second = std::forward<M>(m);
-        return emplace_result;
-    }
-    template<typename M>
-    std::pair<typename Table::iterator, bool> insert_or_assign(key_type && key, M && m)
-    {
-        auto emplace_result = emplace(std::move(key), std::forward<M>(m));
-        if (!emplace_result.second)
-            emplace_result.first->second = std::forward<M>(m);
-        return emplace_result;
-    }
-    template<typename M>
-    typename Table::iterator insert_or_assign(typename Table::const_iterator, const key_type & key, M && m)
-    {
-        return insert_or_assign(key, std::forward<M>(m)).first;
-    }
-    template<typename M>
-    typename Table::iterator insert_or_assign(typename Table::const_iterator, key_type && key, M && m)
-    {
-        return insert_or_assign(std::move(key), std::forward<M>(m)).first;
-    }
+  using Table::emplace;
+  std::pair<typename Table::iterator, bool> emplace() {
+    return emplace(key_type(), convertible_to_value());
+  }
+  template <typename M>
+  std::pair<typename Table::iterator, bool> insert_or_assign(
+      const key_type& key,
+      M&& m) {
+    auto emplace_result = emplace(key, std::forward<M>(m));
+    if (!emplace_result.second)
+      emplace_result.first->second = std::forward<M>(m);
+    return emplace_result;
+  }
+  template <typename M>
+  std::pair<typename Table::iterator, bool> insert_or_assign(
+      key_type&& key,
+      M&& m) {
+    auto emplace_result = emplace(std::move(key), std::forward<M>(m));
+    if (!emplace_result.second)
+      emplace_result.first->second = std::forward<M>(m);
+    return emplace_result;
+  }
+  template <typename M>
+  typename Table::iterator insert_or_assign(
+      typename Table::const_iterator,
+      const key_type& key,
+      M&& m) {
+    return insert_or_assign(key, std::forward<M>(m)).first;
+  }
+  template <typename M>
+  typename Table::iterator insert_or_assign(
+      typename Table::const_iterator,
+      key_type&& key,
+      M&& m) {
+    return insert_or_assign(std::move(key), std::forward<M>(m)).first;
+  }
 
-    friend bool operator==(const order_preserving_flat_hash_map & lhs, const order_preserving_flat_hash_map & rhs)
-    {
-        if (lhs.size() != rhs.size())
-            return false;
-        for (const typename Table::value_type & value : lhs)
-        {
-            auto found = rhs.find(value.first);
-            if (found == rhs.end())
-                return false;
-            else if (value.second != found->second)
-                return false;
-        }
-        return true;
-    }
-    friend bool operator!=(const order_preserving_flat_hash_map & lhs, const order_preserving_flat_hash_map & rhs)
-    {
-        return !(lhs == rhs);
+  friend bool operator==(
+      const order_preserving_flat_hash_map& lhs,
+      const order_preserving_flat_hash_map& rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    for (const typename Table::value_type& value : lhs) {
+      auto found = rhs.find(value.first);
+      if (found == rhs.end())
+        return false;
+      else if (value.second != found->second)
+        return false;
     }
+    return true;
+  }
+  friend bool operator!=(
+      const order_preserving_flat_hash_map& lhs,
+      const order_preserving_flat_hash_map& rhs) {
+    return !(lhs == rhs);
+  }
 
-private:
-    struct convertible_to_value
-    {
-        operator V() const
-        {
-            return V();
-        }
-    };
+ private:
+  struct convertible_to_value {
+    operator V() const {
+      return V();
+    }
+  };
 };
 
-template<typename T, typename H = std::hash<T>, typename E = std::equal_to<T>, typename A = std::allocator<T> >
+template <
+    typename T,
+    typename H = std::hash<T>,
+    typename E = std::equal_to<T>,
+    typename A = std::allocator<T>>
 class flat_hash_set
-        : public detailv3::sherwood_v3_table
-        <
-            T,
-            T,
-            H,
-            detailv3::functor_storage<uint64_t, H>,
-            E,
-            detailv3::functor_storage<bool, E>,
-            A,
-            typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<T>>
-        >
-{
-    using Table = detailv3::sherwood_v3_table
-    <
-        T,
-        T,
-        H,
-        detailv3::functor_storage<uint64_t, H>,
-        E,
-        detailv3::functor_storage<bool, E>,
-        A,
-        typename std::allocator_traits<A>::template rebind_alloc<detailv3::sherwood_v3_entry<T>>
-    >;
-public:
+    : public detailv3::sherwood_v3_table<
+          T,
+          T,
+          H,
+          detailv3::functor_storage<uint64_t, H>,
+          E,
+          detailv3::functor_storage<bool, E>,
+          A,
+          typename std::allocator_traits<A>::template rebind_alloc<
+              detailv3::sherwood_v3_entry<T>>> {
+  using Table = detailv3::sherwood_v3_table<
+      T,
+      T,
+      H,
+      detailv3::functor_storage<uint64_t, H>,
+      E,
+      detailv3::functor_storage<bool, E>,
+      A,
+      typename std::allocator_traits<A>::template rebind_alloc<
+          detailv3::sherwood_v3_entry<T>>>;
 
-    using key_type = T;
+ public:
+  using key_type = T;
 
-    using Table::Table;
-    flat_hash_set()
-    {
-    }
+  using Table::Table;
+  flat_hash_set() {}
 
-    template<typename... Args>
-    std::pair<typename Table::iterator, bool> emplace(Args &&... args)
-    {
-        return Table::emplace(T(std::forward<Args>(args)...));
-    }
-    std::pair<typename Table::iterator, bool> emplace(const key_type & arg)
-    {
-        return Table::emplace(arg);
-    }
-    std::pair<typename Table::iterator, bool> emplace(key_type & arg)
-    {
-        return Table::emplace(arg);
-    }
-    std::pair<typename Table::iterator, bool> emplace(const key_type && arg)
-    {
-        return Table::emplace(std::move(arg));
-    }
-    std::pair<typename Table::iterator, bool> emplace(key_type && arg)
-    {
-        return Table::emplace(std::move(arg));
-    }
+  template <typename... Args>
+  std::pair<typename Table::iterator, bool> emplace(Args&&... args) {
+    return Table::emplace(T(std::forward<Args>(args)...));
+  }
+  std::pair<typename Table::iterator, bool> emplace(const key_type& arg) {
+    return Table::emplace(arg);
+  }
+  std::pair<typename Table::iterator, bool> emplace(key_type& arg) {
+    return Table::emplace(arg);
+  }
+  std::pair<typename Table::iterator, bool> emplace(const key_type&& arg) {
+    return Table::emplace(std::move(arg));
+  }
+  std::pair<typename Table::iterator, bool> emplace(key_type&& arg) {
+    return Table::emplace(std::move(arg));
+  }
 
-    friend bool operator==(const flat_hash_set & lhs, const flat_hash_set & rhs)
-    {
-        if (lhs.size() != rhs.size())
-            return false;
-        for (const T & value : lhs)
-        {
-            if (rhs.find(value) == rhs.end())
-                return false;
-        }
-        return true;
-    }
-    friend bool operator!=(const flat_hash_set & lhs, const flat_hash_set & rhs)
-    {
-        return !(lhs == rhs);
+  friend bool operator==(const flat_hash_set& lhs, const flat_hash_set& rhs) {
+    if (lhs.size() != rhs.size())
+      return false;
+    for (const T& value : lhs) {
+      if (rhs.find(value) == rhs.end())
+        return false;
     }
+    return true;
+  }
+  friend bool operator!=(const flat_hash_set& lhs, const flat_hash_set& rhs) {
+    return !(lhs == rhs);
+  }
 };
 
-
-template<typename T>
-struct power_of_two_std_hash : std::hash<T>
-{
-    typedef ska_ordered::power_of_two_hash_policy hash_policy;
+template <typename T>
+struct power_of_two_std_hash : std::hash<T> {
+  typedef ska_ordered::power_of_two_hash_policy hash_policy;
 };
 
-} // end namespace ska
+} // namespace ska_ordered
 
 #ifndef _MSC_VER
 #pragma GCC diagnostic pop
diff --git a/c10/util/overloaded.h b/c10/util/overloaded.h
index fb6bf19ec23..f8883a3dd79 100644
--- a/c10/util/overloaded.h
+++ b/c10/util/overloaded.h
@@ -3,28 +3,28 @@
 namespace c10 {
 namespace detail {
 
-template<class...Ts>
+template <class... Ts>
 struct overloaded_t {};
 
-template<class T0>
-struct overloaded_t<T0>:T0 {
+template <class T0>
+struct overloaded_t<T0> : T0 {
   using T0::operator();
-  overloaded_t(T0 t0):T0(std::move(t0)) {}
+  overloaded_t(T0 t0) : T0(std::move(t0)) {}
 };
-template<class T0, class...Ts>
-struct overloaded_t<T0, Ts...>:T0, overloaded_t<Ts...> {
+template <class T0, class... Ts>
+struct overloaded_t<T0, Ts...> : T0, overloaded_t<Ts...> {
   using T0::operator();
   using overloaded_t<Ts...>::operator();
-  overloaded_t(T0 t0, Ts... ts):
-    T0(std::move(t0)),
-    overloaded_t<Ts...>(std::move(ts)...)
-  {}
+  overloaded_t(T0 t0, Ts... ts)
+      : T0(std::move(t0)), overloaded_t<Ts...>(std::move(ts)...) {}
 };
 
-}  // namespace detail
+} // namespace detail
 
 // Construct an overloaded callable combining multiple callables, e.g. lambdas
-template<class...Ts>
-detail::overloaded_t<Ts...> overloaded(Ts...ts){ return {std::move(ts)...}; }
+template <class... Ts>
+detail::overloaded_t<Ts...> overloaded(Ts... ts) {
+  return {std::move(ts)...};
+}
 
-}  // namespace c10
+} // namespace c10
diff --git a/c10/util/quint4x2.h b/c10/util/quint4x2.h
index c2502b56140..0b792b36867 100644
--- a/c10/util/quint4x2.h
+++ b/c10/util/quint4x2.h
@@ -6,7 +6,8 @@
 namespace c10 {
 
 /**
- * quint4x2 is for un-signed 4 bit quantized Tensors that are packed to byte boundary.
+ * quint4x2 is for un-signed 4 bit quantized Tensors that are packed to byte
+ * boundary.
  */
 struct alignas(1) quint4x2 {
   using underlying = uint8_t;
diff --git a/c10/util/reverse_iterator.h b/c10/util/reverse_iterator.h
index 03b38918203..70dbe5a8bee 100644
--- a/c10/util/reverse_iterator.h
+++ b/c10/util/reverse_iterator.h
@@ -86,8 +86,7 @@ class reverse_iterator
   constexpr reverse_iterator(const reverse_iterator& __x)
       : current(__x.current) {}
 
-  constexpr reverse_iterator& operator=(
-      const reverse_iterator& rhs) noexcept {
+  constexpr reverse_iterator& operator=(const reverse_iterator& rhs) noexcept {
     current = rhs.current;
     return current;
   }
diff --git a/c10/util/sparse_bitset.h b/c10/util/sparse_bitset.h
index e8ef80e797e..c307bb6c5df 100644
--- a/c10/util/sparse_bitset.h
+++ b/c10/util/sparse_bitset.h
@@ -1,894 +1,891 @@
 //===- llvm/ADT/SparseBitVector.h - Efficient Sparse BitVector --*- C++ -*-===//
- //
- // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
- // See https://llvm.org/LICENSE.txt for license information.
- // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- //
- //===----------------------------------------------------------------------===//
- //
- // This file defines the SparseBitVector class.  See the doxygen comment for
- // SparseBitVector for more details on the algorithm used.
- //
- //===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the SparseBitVector class.  See the doxygen comment for
+// SparseBitVector for more details on the algorithm used.
+//
+//===----------------------------------------------------------------------===//
 
 #pragma once
- #include <cassert>
- #include <climits>
- #include <cstring>
- #include <iterator>
- #include <list>
- #include <c10/util/llvmMathExtras.h>
+#include <c10/util/llvmMathExtras.h>
+#include <cassert>
+#include <climits>
+#include <cstring>
+#include <iterator>
+#include <list>
 
- namespace c10 {
+namespace c10 {
 
- /// SparseBitVector is an implementation of a bitvector that is sparse by only
- /// storing the elements that have non-zero bits set.  In order to make this
- /// fast for the most common cases, SparseBitVector is implemented as a linked
- /// list of SparseBitVectorElements.  We maintain a pointer to the last
- /// SparseBitVectorElement accessed (in the form of a list iterator), in order
- /// to make multiple in-order test/set constant time after the first one is
- /// executed.  Note that using vectors to store SparseBitVectorElement's does
- /// not work out very well because it causes insertion in the middle to take
- /// enormous amounts of time with a large amount of bits.  Other structures that
- /// have better worst cases for insertion in the middle (various balanced trees,
- /// etc) do not perform as well in practice as a linked list with this iterator
- /// kept up to date.  They are also significantly more memory intensive.
+/// SparseBitVector is an implementation of a bitvector that is sparse by only
+/// storing the elements that have non-zero bits set.  In order to make this
+/// fast for the most common cases, SparseBitVector is implemented as a linked
+/// list of SparseBitVectorElements.  We maintain a pointer to the last
+/// SparseBitVectorElement accessed (in the form of a list iterator), in order
+/// to make multiple in-order test/set constant time after the first one is
+/// executed.  Note that using vectors to store SparseBitVectorElement's does
+/// not work out very well because it causes insertion in the middle to take
+/// enormous amounts of time with a large amount of bits.  Other structures that
+/// have better worst cases for insertion in the middle (various balanced trees,
+/// etc) do not perform as well in practice as a linked list with this iterator
+/// kept up to date.  They are also significantly more memory intensive.
 
- template <unsigned ElementSize = 128> struct SparseBitVectorElement {
+template <unsigned ElementSize = 128>
+struct SparseBitVectorElement {
  public:
-   using BitWord = unsigned long;
-   using size_type = unsigned;
-   enum {
-     BITWORD_SIZE = sizeof(BitWord) * CHAR_BIT,
-     BITWORDS_PER_ELEMENT = (ElementSize + BITWORD_SIZE - 1) / BITWORD_SIZE,
-     BITS_PER_ELEMENT = ElementSize
-   };
+  using BitWord = unsigned long;
+  using size_type = unsigned;
+  enum {
+    BITWORD_SIZE = sizeof(BitWord) * CHAR_BIT,
+    BITWORDS_PER_ELEMENT = (ElementSize + BITWORD_SIZE - 1) / BITWORD_SIZE,
+    BITS_PER_ELEMENT = ElementSize
+  };
 
  private:
-   // Index of Element in terms of where first bit starts.
-   unsigned ElementIndex;
-   BitWord Bits[BITWORDS_PER_ELEMENT];
+  // Index of Element in terms of where first bit starts.
+  unsigned ElementIndex;
+  BitWord Bits[BITWORDS_PER_ELEMENT];
 
-   SparseBitVectorElement() {
-     ElementIndex = ~0U;
-     memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
-   }
+  SparseBitVectorElement() {
+    ElementIndex = ~0U;
+    memset(&Bits[0], 0, sizeof(BitWord) * BITWORDS_PER_ELEMENT);
+  }
 
  public:
-   explicit SparseBitVectorElement(unsigned Idx) {
-     ElementIndex = Idx;
-     memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
-   }
+  explicit SparseBitVectorElement(unsigned Idx) {
+    ElementIndex = Idx;
+    memset(&Bits[0], 0, sizeof(BitWord) * BITWORDS_PER_ELEMENT);
+  }
 
-   // Comparison.
-   bool operator==(const SparseBitVectorElement &RHS) const {
-     if (ElementIndex != RHS.ElementIndex)
-       return false;
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
-       if (Bits[i] != RHS.Bits[i])
-         return false;
-     return true;
-   }
+  // Comparison.
+  bool operator==(const SparseBitVectorElement& RHS) const {
+    if (ElementIndex != RHS.ElementIndex)
+      return false;
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
+      if (Bits[i] != RHS.Bits[i])
+        return false;
+    return true;
+  }
 
-   bool operator!=(const SparseBitVectorElement &RHS) const {
-     return !(*this == RHS);
-   }
+  bool operator!=(const SparseBitVectorElement& RHS) const {
+    return !(*this == RHS);
+  }
 
-   // Return the bits that make up word Idx in our element.
-   BitWord word(unsigned Idx) const {
-     assert(Idx < BITWORDS_PER_ELEMENT);
-     return Bits[Idx];
-   }
+  // Return the bits that make up word Idx in our element.
+  BitWord word(unsigned Idx) const {
+    assert(Idx < BITWORDS_PER_ELEMENT);
+    return Bits[Idx];
+  }
 
-   unsigned index() const {
-     return ElementIndex;
-   }
+  unsigned index() const {
+    return ElementIndex;
+  }
 
-   bool empty() const {
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
-       if (Bits[i])
-         return false;
-     return true;
-   }
+  bool empty() const {
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
+      if (Bits[i])
+        return false;
+    return true;
+  }
 
-   void set(unsigned Idx) {
-     Bits[Idx / BITWORD_SIZE] |= 1L << (Idx % BITWORD_SIZE);
-   }
+  void set(unsigned Idx) {
+    Bits[Idx / BITWORD_SIZE] |= 1L << (Idx % BITWORD_SIZE);
+  }
 
-   bool test_and_set(unsigned Idx) {
-     bool old = test(Idx);
-     if (!old) {
-       set(Idx);
-       return true;
-     }
-     return false;
-   }
+  bool test_and_set(unsigned Idx) {
+    bool old = test(Idx);
+    if (!old) {
+      set(Idx);
+      return true;
+    }
+    return false;
+  }
 
-   void reset(unsigned Idx) {
-     Bits[Idx / BITWORD_SIZE] &= ~(1L << (Idx % BITWORD_SIZE));
-   }
+  void reset(unsigned Idx) {
+    Bits[Idx / BITWORD_SIZE] &= ~(1L << (Idx % BITWORD_SIZE));
+  }
 
-   bool test(unsigned Idx) const {
-     return Bits[Idx / BITWORD_SIZE] & (1L << (Idx % BITWORD_SIZE));
-   }
+  bool test(unsigned Idx) const {
+    return Bits[Idx / BITWORD_SIZE] & (1L << (Idx % BITWORD_SIZE));
+  }
 
-   size_type count() const {
-     unsigned NumBits = 0;
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
-       NumBits += llvm::countPopulation(Bits[i]);
-     return NumBits;
-   }
+  size_type count() const {
+    unsigned NumBits = 0;
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
+      NumBits += llvm::countPopulation(Bits[i]);
+    return NumBits;
+  }
 
-   /// find_first - Returns the index of the first set bit.
-   int find_first() const {
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
-       if (Bits[i] != 0)
-         return i * BITWORD_SIZE + llvm::countTrailingZeros(Bits[i]);
-      throw std::runtime_error("Illegal empty element");
-   }
+  /// find_first - Returns the index of the first set bit.
+  int find_first() const {
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
+      if (Bits[i] != 0)
+        return i * BITWORD_SIZE + llvm::countTrailingZeros(Bits[i]);
+    throw std::runtime_error("Illegal empty element");
+  }
 
-   /// find_last - Returns the index of the last set bit.
-   int find_last() const {
-     for (unsigned I = 0; I < BITWORDS_PER_ELEMENT; ++I) {
-       unsigned Idx = BITWORDS_PER_ELEMENT - I - 1;
-       if (Bits[Idx] != 0)
-         return Idx * BITWORD_SIZE + BITWORD_SIZE -
-                 llvm::countLeadingZeros(Bits[Idx]);
-     }
-      throw std::runtime_error("Illegal empty element");
-   }
+  /// find_last - Returns the index of the last set bit.
+  int find_last() const {
+    for (unsigned I = 0; I < BITWORDS_PER_ELEMENT; ++I) {
+      unsigned Idx = BITWORDS_PER_ELEMENT - I - 1;
+      if (Bits[Idx] != 0)
+        return Idx * BITWORD_SIZE + BITWORD_SIZE -
+            llvm::countLeadingZeros(Bits[Idx]);
+    }
+    throw std::runtime_error("Illegal empty element");
+  }
 
-   /// find_next - Returns the index of the next set bit starting from the
-   /// "Curr" bit. Returns -1 if the next set bit is not found.
-   int find_next(unsigned Curr) const {
-     if (Curr >= BITS_PER_ELEMENT)
-       return -1;
+  /// find_next - Returns the index of the next set bit starting from the
+  /// "Curr" bit. Returns -1 if the next set bit is not found.
+  int find_next(unsigned Curr) const {
+    if (Curr >= BITS_PER_ELEMENT)
+      return -1;
 
-     unsigned WordPos = Curr / BITWORD_SIZE;
-     unsigned BitPos = Curr % BITWORD_SIZE;
-     BitWord Copy = Bits[WordPos];
-     assert(WordPos <= BITWORDS_PER_ELEMENT
-            && "Word Position outside of element");
+    unsigned WordPos = Curr / BITWORD_SIZE;
+    unsigned BitPos = Curr % BITWORD_SIZE;
+    BitWord Copy = Bits[WordPos];
+    assert(
+        WordPos <= BITWORDS_PER_ELEMENT && "Word Position outside of element");
 
-     // Mask off previous bits.
-     Copy &= ~0UL << BitPos;
+    // Mask off previous bits.
+    Copy &= ~0UL << BitPos;
 
-     if (Copy != 0)
-       return WordPos * BITWORD_SIZE + llvm::countTrailingZeros(Copy);
+    if (Copy != 0)
+      return WordPos * BITWORD_SIZE + llvm::countTrailingZeros(Copy);
 
-     // Check subsequent words.
-     for (unsigned i = WordPos+1; i < BITWORDS_PER_ELEMENT; ++i)
-       if (Bits[i] != 0)
-         return i * BITWORD_SIZE + llvm::countTrailingZeros(Bits[i]);
-     return -1;
-   }
+    // Check subsequent words.
+    for (unsigned i = WordPos + 1; i < BITWORDS_PER_ELEMENT; ++i)
+      if (Bits[i] != 0)
+        return i * BITWORD_SIZE + llvm::countTrailingZeros(Bits[i]);
+    return -1;
+  }
 
-   // Union this element with RHS and return true if this one changed.
-   bool unionWith(const SparseBitVectorElement &RHS) {
-     bool changed = false;
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
-       BitWord old = changed ? 0 : Bits[i];
+  // Union this element with RHS and return true if this one changed.
+  bool unionWith(const SparseBitVectorElement& RHS) {
+    bool changed = false;
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
+      BitWord old = changed ? 0 : Bits[i];
 
-       Bits[i] |= RHS.Bits[i];
-       if (!changed && old != Bits[i])
-         changed = true;
-     }
-     return changed;
-   }
+      Bits[i] |= RHS.Bits[i];
+      if (!changed && old != Bits[i])
+        changed = true;
+    }
+    return changed;
+  }
 
-   // Return true if we have any bits in common with RHS
-   bool intersects(const SparseBitVectorElement &RHS) const {
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
-       if (RHS.Bits[i] & Bits[i])
-         return true;
-     }
-     return false;
-   }
+  // Return true if we have any bits in common with RHS
+  bool intersects(const SparseBitVectorElement& RHS) const {
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
+      if (RHS.Bits[i] & Bits[i])
+        return true;
+    }
+    return false;
+  }
 
-   // Intersect this Element with RHS and return true if this one changed.
-   // BecameZero is set to true if this element became all-zero bits.
-   bool intersectWith(const SparseBitVectorElement &RHS,
-                      bool &BecameZero) {
-     bool changed = false;
-     bool allzero = true;
+  // Intersect this Element with RHS and return true if this one changed.
+  // BecameZero is set to true if this element became all-zero bits.
+  bool intersectWith(const SparseBitVectorElement& RHS, bool& BecameZero) {
+    bool changed = false;
+    bool allzero = true;
 
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
-       BitWord old = changed ? 0 : Bits[i];
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
+      BitWord old = changed ? 0 : Bits[i];
 
-       Bits[i] &= RHS.Bits[i];
-       if (Bits[i] != 0)
-         allzero = false;
+      Bits[i] &= RHS.Bits[i];
+      if (Bits[i] != 0)
+        allzero = false;
 
-       if (!changed && old != Bits[i])
-         changed = true;
-     }
-     BecameZero = allzero;
-     return changed;
-   }
+      if (!changed && old != Bits[i])
+        changed = true;
+    }
+    BecameZero = allzero;
+    return changed;
+  }
 
-   // Intersect this Element with the complement of RHS and return true if this
-   // one changed.  BecameZero is set to true if this element became all-zero
-   // bits.
-   bool intersectWithComplement(const SparseBitVectorElement &RHS,
-                                bool &BecameZero) {
-     bool changed = false;
-     bool allzero = true;
+  // Intersect this Element with the complement of RHS and return true if this
+  // one changed.  BecameZero is set to true if this element became all-zero
+  // bits.
+  bool intersectWithComplement(
+      const SparseBitVectorElement& RHS,
+      bool& BecameZero) {
+    bool changed = false;
+    bool allzero = true;
 
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
-       BitWord old = changed ? 0 : Bits[i];
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
+      BitWord old = changed ? 0 : Bits[i];
 
-       Bits[i] &= ~RHS.Bits[i];
-       if (Bits[i] != 0)
-         allzero = false;
+      Bits[i] &= ~RHS.Bits[i];
+      if (Bits[i] != 0)
+        allzero = false;
 
-       if (!changed && old != Bits[i])
-         changed = true;
-     }
-     BecameZero = allzero;
-     return changed;
-   }
+      if (!changed && old != Bits[i])
+        changed = true;
+    }
+    BecameZero = allzero;
+    return changed;
+  }
 
-   // Three argument version of intersectWithComplement that intersects
-   // RHS1 & ~RHS2 into this element
-   void intersectWithComplement(const SparseBitVectorElement &RHS1,
-                                const SparseBitVectorElement &RHS2,
-                                bool &BecameZero) {
-     bool allzero = true;
+  // Three argument version of intersectWithComplement that intersects
+  // RHS1 & ~RHS2 into this element
+  void intersectWithComplement(
+      const SparseBitVectorElement& RHS1,
+      const SparseBitVectorElement& RHS2,
+      bool& BecameZero) {
+    bool allzero = true;
 
-     for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
-       Bits[i] = RHS1.Bits[i] & ~RHS2.Bits[i];
-       if (Bits[i] != 0)
-         allzero = false;
-     }
-     BecameZero = allzero;
-   }
- };
+    for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
+      Bits[i] = RHS1.Bits[i] & ~RHS2.Bits[i];
+      if (Bits[i] != 0)
+        allzero = false;
+    }
+    BecameZero = allzero;
+  }
+};
 
- template <unsigned ElementSize = 128>
- class SparseBitVector {
-   using ElementList = std::list<SparseBitVectorElement<ElementSize>>;
-   using ElementListIter = typename ElementList::iterator;
-   using ElementListConstIter = typename ElementList::const_iterator;
-   enum {
-     BITWORD_SIZE = SparseBitVectorElement<ElementSize>::BITWORD_SIZE
-   };
+template <unsigned ElementSize = 128>
+class SparseBitVector {
+  using ElementList = std::list<SparseBitVectorElement<ElementSize>>;
+  using ElementListIter = typename ElementList::iterator;
+  using ElementListConstIter = typename ElementList::const_iterator;
+  enum { BITWORD_SIZE = SparseBitVectorElement<ElementSize>::BITWORD_SIZE };
 
-   ElementList Elements;
-   // Pointer to our current Element. This has no visible effect on the external
-   // state of a SparseBitVector, it's just used to improve performance in the
-   // common case of testing/modifying bits with similar indices.
-   mutable ElementListIter CurrElementIter;
+  ElementList Elements;
+  // Pointer to our current Element. This has no visible effect on the external
+  // state of a SparseBitVector, it's just used to improve performance in the
+  // common case of testing/modifying bits with similar indices.
+  mutable ElementListIter CurrElementIter;
 
-   // This is like std::lower_bound, except we do linear searching from the
-   // current position.
-   ElementListIter FindLowerBoundImpl(unsigned ElementIndex) const {
+  // This is like std::lower_bound, except we do linear searching from the
+  // current position.
+  ElementListIter FindLowerBoundImpl(unsigned ElementIndex) const {
+    // We cache a non-const iterator so we're forced to resort to const_cast to
+    // get the begin/end in the case where 'this' is const. To avoid duplication
+    // of code with the only difference being whether the const cast is present
+    // 'this' is always const in this particular function and we sort out the
+    // difference in FindLowerBound and FindLowerBoundConst.
+    ElementListIter Begin =
+        const_cast<SparseBitVector<ElementSize>*>(this)->Elements.begin();
+    ElementListIter End =
+        const_cast<SparseBitVector<ElementSize>*>(this)->Elements.end();
 
-     // We cache a non-const iterator so we're forced to resort to const_cast to
-     // get the begin/end in the case where 'this' is const. To avoid duplication
-     // of code with the only difference being whether the const cast is present
-     // 'this' is always const in this particular function and we sort out the
-     // difference in FindLowerBound and FindLowerBoundConst.
-     ElementListIter Begin =
-         const_cast<SparseBitVector<ElementSize> *>(this)->Elements.begin();
-     ElementListIter End =
-         const_cast<SparseBitVector<ElementSize> *>(this)->Elements.end();
+    if (Elements.empty()) {
+      CurrElementIter = Begin;
+      return CurrElementIter;
+    }
 
-     if (Elements.empty()) {
-       CurrElementIter = Begin;
-       return CurrElementIter;
-     }
+    // Make sure our current iterator is valid.
+    if (CurrElementIter == End)
+      --CurrElementIter;
 
-     // Make sure our current iterator is valid.
-     if (CurrElementIter == End)
-       --CurrElementIter;
+    // Search from our current iterator, either backwards or forwards,
+    // depending on what element we are looking for.
+    ElementListIter ElementIter = CurrElementIter;
+    if (CurrElementIter->index() == ElementIndex) {
+      return ElementIter;
+    } else if (CurrElementIter->index() > ElementIndex) {
+      while (ElementIter != Begin && ElementIter->index() > ElementIndex)
+        --ElementIter;
+    } else {
+      while (ElementIter != End && ElementIter->index() < ElementIndex)
+        ++ElementIter;
+    }
+    CurrElementIter = ElementIter;
+    return ElementIter;
+  }
+  ElementListConstIter FindLowerBoundConst(unsigned ElementIndex) const {
+    return FindLowerBoundImpl(ElementIndex);
+  }
+  ElementListIter FindLowerBound(unsigned ElementIndex) {
+    return FindLowerBoundImpl(ElementIndex);
+  }
 
-     // Search from our current iterator, either backwards or forwards,
-     // depending on what element we are looking for.
-     ElementListIter ElementIter = CurrElementIter;
-     if (CurrElementIter->index() == ElementIndex) {
-       return ElementIter;
-     } else if (CurrElementIter->index() > ElementIndex) {
-       while (ElementIter != Begin
-              && ElementIter->index() > ElementIndex)
-         --ElementIter;
-     } else {
-       while (ElementIter != End &&
-              ElementIter->index() < ElementIndex)
-         ++ElementIter;
-     }
-     CurrElementIter = ElementIter;
-     return ElementIter;
-   }
-   ElementListConstIter FindLowerBoundConst(unsigned ElementIndex) const {
-     return FindLowerBoundImpl(ElementIndex);
-   }
-   ElementListIter FindLowerBound(unsigned ElementIndex) {
-     return FindLowerBoundImpl(ElementIndex);
-   }
-
-   // Iterator to walk set bits in the bitmap.  This iterator is a lot uglier
-   // than it would be, in order to be efficient.
-   class SparseBitVectorIterator {
+  // Iterator to walk set bits in the bitmap.  This iterator is a lot uglier
+  // than it would be, in order to be efficient.
+  class SparseBitVectorIterator {
    private:
-     bool AtEnd;
+    bool AtEnd;
 
-     const SparseBitVector<ElementSize> *BitVector = nullptr;
+    const SparseBitVector<ElementSize>* BitVector = nullptr;
 
-     // Current element inside of bitmap.
-     ElementListConstIter Iter;
+    // Current element inside of bitmap.
+    ElementListConstIter Iter;
 
-     // Current bit number inside of our bitmap.
-     unsigned BitNumber;
+    // Current bit number inside of our bitmap.
+    unsigned BitNumber;
 
-     // Current word number inside of our element.
-     unsigned WordNumber;
+    // Current word number inside of our element.
+    unsigned WordNumber;
 
-     // Current bits from the element.
-     typename SparseBitVectorElement<ElementSize>::BitWord Bits;
+    // Current bits from the element.
+    typename SparseBitVectorElement<ElementSize>::BitWord Bits;
 
-     // Move our iterator to the first non-zero bit in the bitmap.
-     void AdvanceToFirstNonZero() {
-       if (AtEnd)
-         return;
-       if (BitVector->Elements.empty()) {
-         AtEnd = true;
-         return;
-       }
-       Iter = BitVector->Elements.begin();
-       BitNumber = Iter->index() * ElementSize;
-       unsigned BitPos = Iter->find_first();
-       BitNumber += BitPos;
-       WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
-       Bits = Iter->word(WordNumber);
-       Bits >>= BitPos % BITWORD_SIZE;
-     }
+    // Move our iterator to the first non-zero bit in the bitmap.
+    void AdvanceToFirstNonZero() {
+      if (AtEnd)
+        return;
+      if (BitVector->Elements.empty()) {
+        AtEnd = true;
+        return;
+      }
+      Iter = BitVector->Elements.begin();
+      BitNumber = Iter->index() * ElementSize;
+      unsigned BitPos = Iter->find_first();
+      BitNumber += BitPos;
+      WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
+      Bits = Iter->word(WordNumber);
+      Bits >>= BitPos % BITWORD_SIZE;
+    }
 
-     // Move our iterator to the next non-zero bit.
-     void AdvanceToNextNonZero() {
-       if (AtEnd)
-         return;
+    // Move our iterator to the next non-zero bit.
+    void AdvanceToNextNonZero() {
+      if (AtEnd)
+        return;
 
-       while (Bits && !(Bits & 1)) {
-         Bits >>= 1;
-         BitNumber += 1;
-       }
+      while (Bits && !(Bits & 1)) {
+        Bits >>= 1;
+        BitNumber += 1;
+      }
 
-       // See if we ran out of Bits in this word.
-       if (!Bits) {
-         int NextSetBitNumber = Iter->find_next(BitNumber % ElementSize) ;
-         // If we ran out of set bits in this element, move to next element.
-         if (NextSetBitNumber == -1 || (BitNumber % ElementSize == 0)) {
-           ++Iter;
-           WordNumber = 0;
+      // See if we ran out of Bits in this word.
+      if (!Bits) {
+        int NextSetBitNumber = Iter->find_next(BitNumber % ElementSize);
+        // If we ran out of set bits in this element, move to next element.
+        if (NextSetBitNumber == -1 || (BitNumber % ElementSize == 0)) {
+          ++Iter;
+          WordNumber = 0;
 
-           // We may run out of elements in the bitmap.
-           if (Iter == BitVector->Elements.end()) {
-             AtEnd = true;
-             return;
-           }
-           // Set up for next non-zero word in bitmap.
-           BitNumber = Iter->index() * ElementSize;
-           NextSetBitNumber = Iter->find_first();
-           BitNumber += NextSetBitNumber;
-           WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
-           Bits = Iter->word(WordNumber);
-           Bits >>= NextSetBitNumber % BITWORD_SIZE;
-         } else {
-           WordNumber = (NextSetBitNumber % ElementSize) / BITWORD_SIZE;
-           Bits = Iter->word(WordNumber);
-           Bits >>= NextSetBitNumber % BITWORD_SIZE;
-           BitNumber = Iter->index() * ElementSize;
-           BitNumber += NextSetBitNumber;
-         }
-       }
-     }
+          // We may run out of elements in the bitmap.
+          if (Iter == BitVector->Elements.end()) {
+            AtEnd = true;
+            return;
+          }
+          // Set up for next non-zero word in bitmap.
+          BitNumber = Iter->index() * ElementSize;
+          NextSetBitNumber = Iter->find_first();
+          BitNumber += NextSetBitNumber;
+          WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
+          Bits = Iter->word(WordNumber);
+          Bits >>= NextSetBitNumber % BITWORD_SIZE;
+        } else {
+          WordNumber = (NextSetBitNumber % ElementSize) / BITWORD_SIZE;
+          Bits = Iter->word(WordNumber);
+          Bits >>= NextSetBitNumber % BITWORD_SIZE;
+          BitNumber = Iter->index() * ElementSize;
+          BitNumber += NextSetBitNumber;
+        }
+      }
+    }
 
    public:
-     SparseBitVectorIterator() = default;
+    SparseBitVectorIterator() = default;
 
-     SparseBitVectorIterator(const SparseBitVector<ElementSize> *RHS,
-                             bool end = false):BitVector(RHS) {
-       Iter = BitVector->Elements.begin();
-       BitNumber = 0;
-       Bits = 0;
-       WordNumber = ~0;
-       AtEnd = end;
-       AdvanceToFirstNonZero();
-     }
+    SparseBitVectorIterator(
+        const SparseBitVector<ElementSize>* RHS,
+        bool end = false)
+        : BitVector(RHS) {
+      Iter = BitVector->Elements.begin();
+      BitNumber = 0;
+      Bits = 0;
+      WordNumber = ~0;
+      AtEnd = end;
+      AdvanceToFirstNonZero();
+    }
 
-     // Preincrement.
-     inline SparseBitVectorIterator& operator++() {
-       ++BitNumber;
-       Bits >>= 1;
-       AdvanceToNextNonZero();
-       return *this;
-     }
+    // Preincrement.
+    inline SparseBitVectorIterator& operator++() {
+      ++BitNumber;
+      Bits >>= 1;
+      AdvanceToNextNonZero();
+      return *this;
+    }
 
-     // Postincrement.
-     inline SparseBitVectorIterator operator++(int) {
-       SparseBitVectorIterator tmp = *this;
-       ++*this;
-       return tmp;
-     }
+    // Postincrement.
+    inline SparseBitVectorIterator operator++(int) {
+      SparseBitVectorIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
 
-     // Return the current set bit number.
-     unsigned operator*() const {
-       return BitNumber;
-     }
+    // Return the current set bit number.
+    unsigned operator*() const {
+      return BitNumber;
+    }
 
-     bool operator==(const SparseBitVectorIterator &RHS) const {
-       // If they are both at the end, ignore the rest of the fields.
-       if (AtEnd && RHS.AtEnd)
-         return true;
-       // Otherwise they are the same if they have the same bit number and
-       // bitmap.
-       return AtEnd == RHS.AtEnd && RHS.BitNumber == BitNumber;
-     }
+    bool operator==(const SparseBitVectorIterator& RHS) const {
+      // If they are both at the end, ignore the rest of the fields.
+      if (AtEnd && RHS.AtEnd)
+        return true;
+      // Otherwise they are the same if they have the same bit number and
+      // bitmap.
+      return AtEnd == RHS.AtEnd && RHS.BitNumber == BitNumber;
+    }
 
-     bool operator!=(const SparseBitVectorIterator &RHS) const {
-       return !(*this == RHS);
-     }
-   };
+    bool operator!=(const SparseBitVectorIterator& RHS) const {
+      return !(*this == RHS);
+    }
+  };
 
  public:
-   using iterator = SparseBitVectorIterator;
-
-   SparseBitVector() : Elements(), CurrElementIter(Elements.begin()) {}
-
-   SparseBitVector(const SparseBitVector &RHS)
-       : Elements(RHS.Elements), CurrElementIter(Elements.begin()) {}
-   SparseBitVector(SparseBitVector &&RHS)
-       : Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
-
-   // Clear.
-   void clear() {
-     Elements.clear();
-   }
-
-   // Assignment
-   SparseBitVector& operator=(const SparseBitVector& RHS) {
-     if (this == &RHS)
-       return *this;
-
-     Elements = RHS.Elements;
-     CurrElementIter = Elements.begin();
-     return *this;
-   }
-   SparseBitVector &operator=(SparseBitVector &&RHS) {
-     Elements = std::move(RHS.Elements);
-     CurrElementIter = Elements.begin();
-     return *this;
-   }
-
-   // Test, Reset, and Set a bit in the bitmap.
-   bool test(unsigned Idx) const {
-     if (Elements.empty())
-       return false;
-
-     unsigned ElementIndex = Idx / ElementSize;
-     ElementListConstIter ElementIter = FindLowerBoundConst(ElementIndex);
-
-     // If we can't find an element that is supposed to contain this bit, there
-     // is nothing more to do.
-     if (ElementIter == Elements.end() ||
-         ElementIter->index() != ElementIndex)
-       return false;
-     return ElementIter->test(Idx % ElementSize);
-   }
-
-   void reset(unsigned Idx) {
-     if (Elements.empty())
-       return;
-
-     unsigned ElementIndex = Idx / ElementSize;
-     ElementListIter ElementIter = FindLowerBound(ElementIndex);
-
-     // If we can't find an element that is supposed to contain this bit, there
-     // is nothing more to do.
-     if (ElementIter == Elements.end() ||
-         ElementIter->index() != ElementIndex)
-       return;
-     ElementIter->reset(Idx % ElementSize);
-
-     // When the element is zeroed out, delete it.
-     if (ElementIter->empty()) {
-       ++CurrElementIter;
-       Elements.erase(ElementIter);
-     }
-   }
-
-   void set(unsigned Idx) {
-     unsigned ElementIndex = Idx / ElementSize;
-     ElementListIter ElementIter;
-     if (Elements.empty()) {
-       ElementIter = Elements.emplace(Elements.end(), ElementIndex);
-     } else {
-       ElementIter = FindLowerBound(ElementIndex);
-
-       if (ElementIter == Elements.end() ||
-           ElementIter->index() != ElementIndex) {
-         // We may have hit the beginning of our SparseBitVector, in which case,
-         // we may need to insert right after this element, which requires moving
-         // the current iterator forward one, because insert does insert before.
-         if (ElementIter != Elements.end() &&
-             ElementIter->index() < ElementIndex)
-           ++ElementIter;
-         ElementIter = Elements.emplace(ElementIter, ElementIndex);
-       }
-     }
-     CurrElementIter = ElementIter;
-
-     ElementIter->set(Idx % ElementSize);
-   }
-
-   bool test_and_set(unsigned Idx) {
-     bool old = test(Idx);
-     if (!old) {
-       set(Idx);
-       return true;
-     }
-     return false;
-   }
-
-   bool operator!=(const SparseBitVector &RHS) const {
-     return !(*this == RHS);
-   }
-
-   bool operator==(const SparseBitVector &RHS) const {
-     ElementListConstIter Iter1 = Elements.begin();
-     ElementListConstIter Iter2 = RHS.Elements.begin();
-
-     for (; Iter1 != Elements.end() && Iter2 != RHS.Elements.end();
-          ++Iter1, ++Iter2) {
-       if (*Iter1 != *Iter2)
-         return false;
-     }
-     return Iter1 == Elements.end() && Iter2 == RHS.Elements.end();
-   }
-
-   // Union our bitmap with the RHS and return true if we changed.
-   bool operator|=(const SparseBitVector &RHS) {
-     if (this == &RHS)
-       return false;
-
-     bool changed = false;
-     ElementListIter Iter1 = Elements.begin();
-     ElementListConstIter Iter2 = RHS.Elements.begin();
-
-     // If RHS is empty, we are done
-     if (RHS.Elements.empty())
-       return false;
-
-     while (Iter2 != RHS.Elements.end()) {
-       if (Iter1 == Elements.end() || Iter1->index() > Iter2->index()) {
-         Elements.insert(Iter1, *Iter2);
-         ++Iter2;
-         changed = true;
-       } else if (Iter1->index() == Iter2->index()) {
-         changed |= Iter1->unionWith(*Iter2);
-         ++Iter1;
-         ++Iter2;
-       } else {
-         ++Iter1;
-       }
-     }
-     CurrElementIter = Elements.begin();
-     return changed;
-   }
-
-   // Intersect our bitmap with the RHS and return true if ours changed.
-   bool operator-=(const SparseBitVector &RHS) {
-     return intersectWithComplement(RHS);
-   }
-
-   // Intersect our bitmap with the RHS and return true if ours changed.
-   bool operator&=(const SparseBitVector &RHS) {
-     if (this == &RHS)
-       return false;
-
-     bool changed = false;
-     ElementListIter Iter1 = Elements.begin();
-     ElementListConstIter Iter2 = RHS.Elements.begin();
-
-     // Check if both bitmaps are empty.
-     if (Elements.empty() && RHS.Elements.empty())
-       return false;
-
-     // Loop through, intersecting as we go, erasing elements when necessary.
-     while (Iter2 != RHS.Elements.end()) {
-       if (Iter1 == Elements.end()) {
-         CurrElementIter = Elements.begin();
-         return changed;
-       }
-
-       if (Iter1->index() > Iter2->index()) {
-         ++Iter2;
-       } else if (Iter1->index() == Iter2->index()) {
-         bool BecameZero;
-         changed |= Iter1->intersectWith(*Iter2, BecameZero);
-         if (BecameZero) {
-           ElementListIter IterTmp = Iter1;
-           ++Iter1;
-           Elements.erase(IterTmp);
-         } else {
-           ++Iter1;
-         }
-         ++Iter2;
-       } else {
-         ElementListIter IterTmp = Iter1;
-         ++Iter1;
-         Elements.erase(IterTmp);
-         changed = true;
-       }
-     }
-     if (Iter1 != Elements.end()) {
-       Elements.erase(Iter1, Elements.end());
-       changed = true;
-     }
-     CurrElementIter = Elements.begin();
-     return changed;
-   }
-
-   // Intersect our bitmap with the complement of the RHS and return true
-   // if ours changed.
-   bool intersectWithComplement(const SparseBitVector &RHS) {
-     if (this == &RHS) {
-       if (!empty()) {
-         clear();
-         return true;
-       }
-       return false;
-     }
-
-     bool changed = false;
-     ElementListIter Iter1 = Elements.begin();
-     ElementListConstIter Iter2 = RHS.Elements.begin();
-
-     // If either our bitmap or RHS is empty, we are done
-     if (Elements.empty() || RHS.Elements.empty())
-       return false;
-
-     // Loop through, intersecting as we go, erasing elements when necessary.
-     while (Iter2 != RHS.Elements.end()) {
-       if (Iter1 == Elements.end()) {
-         CurrElementIter = Elements.begin();
-         return changed;
-       }
-
-       if (Iter1->index() > Iter2->index()) {
-         ++Iter2;
-       } else if (Iter1->index() == Iter2->index()) {
-         bool BecameZero;
-         changed |= Iter1->intersectWithComplement(*Iter2, BecameZero);
-         if (BecameZero) {
-           ElementListIter IterTmp = Iter1;
-           ++Iter1;
-           Elements.erase(IterTmp);
-         } else {
-           ++Iter1;
-         }
-         ++Iter2;
-       } else {
-         ++Iter1;
-       }
-     }
-     CurrElementIter = Elements.begin();
-     return changed;
-   }
-
-   bool intersectWithComplement(const SparseBitVector<ElementSize> *RHS) const {
-     return intersectWithComplement(*RHS);
-   }
-
-   //  Three argument version of intersectWithComplement.
-   //  Result of RHS1 & ~RHS2 is stored into this bitmap.
-   void intersectWithComplement(const SparseBitVector<ElementSize> &RHS1,
-                                const SparseBitVector<ElementSize> &RHS2)
-   {
-     if (this == &RHS1) {
-       intersectWithComplement(RHS2);
-       return;
-     } else if (this == &RHS2) {
-       SparseBitVector RHS2Copy(RHS2);
-       intersectWithComplement(RHS1, RHS2Copy);
-       return;
-     }
-
-     Elements.clear();
-     CurrElementIter = Elements.begin();
-     ElementListConstIter Iter1 = RHS1.Elements.begin();
-     ElementListConstIter Iter2 = RHS2.Elements.begin();
-
-     // If RHS1 is empty, we are done
-     // If RHS2 is empty, we still have to copy RHS1
-     if (RHS1.Elements.empty())
-       return;
-
-     // Loop through, intersecting as we go, erasing elements when necessary.
-     while (Iter2 != RHS2.Elements.end()) {
-       if (Iter1 == RHS1.Elements.end())
-         return;
-
-       if (Iter1->index() > Iter2->index()) {
-         ++Iter2;
-       } else if (Iter1->index() == Iter2->index()) {
-         bool BecameZero = false;
-         Elements.emplace_back(Iter1->index());
-         Elements.back().intersectWithComplement(*Iter1, *Iter2, BecameZero);
-         if (BecameZero)
-           Elements.pop_back();
-         ++Iter1;
-         ++Iter2;
-       } else {
-         Elements.push_back(*Iter1++);
-       }
-     }
-
-     // copy the remaining elements
-     std::copy(Iter1, RHS1.Elements.end(), std::back_inserter(Elements));
-   }
-
-   void intersectWithComplement(const SparseBitVector<ElementSize> *RHS1,
-                                const SparseBitVector<ElementSize> *RHS2) {
-     intersectWithComplement(*RHS1, *RHS2);
-   }
-
-   bool intersects(const SparseBitVector<ElementSize> *RHS) const {
-     return intersects(*RHS);
-   }
-
-   // Return true if we share any bits in common with RHS
-   bool intersects(const SparseBitVector<ElementSize> &RHS) const {
-     ElementListConstIter Iter1 = Elements.begin();
-     ElementListConstIter Iter2 = RHS.Elements.begin();
-
-     // Check if both bitmaps are empty.
-     if (Elements.empty() && RHS.Elements.empty())
-       return false;
-
-     // Loop through, intersecting stopping when we hit bits in common.
-     while (Iter2 != RHS.Elements.end()) {
-       if (Iter1 == Elements.end())
-         return false;
-
-       if (Iter1->index() > Iter2->index()) {
-         ++Iter2;
-       } else if (Iter1->index() == Iter2->index()) {
-         if (Iter1->intersects(*Iter2))
-           return true;
-         ++Iter1;
-         ++Iter2;
-       } else {
-         ++Iter1;
-       }
-     }
-     return false;
-   }
-
-   // Return true iff all bits set in this SparseBitVector are
-   // also set in RHS.
-   bool contains(const SparseBitVector<ElementSize> &RHS) const {
-     SparseBitVector<ElementSize> Result(*this);
-     Result &= RHS;
-     return (Result == RHS);
-   }
-
-   // Return the first set bit in the bitmap.  Return -1 if no bits are set.
-   int find_first() const {
-     if (Elements.empty())
-       return -1;
-     const SparseBitVectorElement<ElementSize> &First = *(Elements.begin());
-     return (First.index() * ElementSize) + First.find_first();
-   }
-
-   // Return the last set bit in the bitmap.  Return -1 if no bits are set.
-   int find_last() const {
-     if (Elements.empty())
-       return -1;
-     const SparseBitVectorElement<ElementSize> &Last = *(Elements.rbegin());
-     return (Last.index() * ElementSize) + Last.find_last();
-   }
-
-   // Return true if the SparseBitVector is empty
-   bool empty() const {
-     return Elements.empty();
-   }
-
-   unsigned count() const {
-     unsigned BitCount = 0;
-     for (ElementListConstIter Iter = Elements.begin();
-          Iter != Elements.end();
-          ++Iter)
-       BitCount += Iter->count();
-
-     return BitCount;
-   }
-
-   iterator begin() const {
-     return iterator(this);
-   }
-
-   iterator end() const {
-     return iterator(this, true);
-   }
- };
-
- // Convenience functions to allow Or and And without dereferencing in the user
- // code.
-
- template <unsigned ElementSize>
- inline bool operator |=(SparseBitVector<ElementSize> &LHS,
-                         const SparseBitVector<ElementSize> *RHS) {
-   return LHS |= *RHS;
- }
-
- template <unsigned ElementSize>
- inline bool operator |=(SparseBitVector<ElementSize> *LHS,
-                         const SparseBitVector<ElementSize> &RHS) {
-   return LHS->operator|=(RHS);
- }
-
- template <unsigned ElementSize>
- inline bool operator &=(SparseBitVector<ElementSize> *LHS,
-                         const SparseBitVector<ElementSize> &RHS) {
-   return LHS->operator&=(RHS);
- }
-
- template <unsigned ElementSize>
- inline bool operator &=(SparseBitVector<ElementSize> &LHS,
-                         const SparseBitVector<ElementSize> *RHS) {
-   return LHS &= *RHS;
- }
-
- // Convenience functions for infix union, intersection, difference operators.
-
- template <unsigned ElementSize>
- inline SparseBitVector<ElementSize>
- operator|(const SparseBitVector<ElementSize> &LHS,
-           const SparseBitVector<ElementSize> &RHS) {
-   SparseBitVector<ElementSize> Result(LHS);
-   Result |= RHS;
-   return Result;
- }
-
- template <unsigned ElementSize>
- inline SparseBitVector<ElementSize>
- operator&(const SparseBitVector<ElementSize> &LHS,
-           const SparseBitVector<ElementSize> &RHS) {
-   SparseBitVector<ElementSize> Result(LHS);
-   Result &= RHS;
-   return Result;
- }
-
- template <unsigned ElementSize>
- inline SparseBitVector<ElementSize>
- operator-(const SparseBitVector<ElementSize> &LHS,
-           const SparseBitVector<ElementSize> &RHS) {
-   SparseBitVector<ElementSize> Result;
-   Result.intersectWithComplement(LHS, RHS);
-   return Result;
- }
-
- template <unsigned ElementSize>
- std::ostream& operator<<(std::ostream& stream, const SparseBitVector<ElementSize>& vec) {
-
-   bool first = true;
-   stream << "{";
-   for (auto el : vec)
-   {
-     if (first)
-     {
-       first = false;
-     }
-     else
-     {
-       stream << ", ";
-     }
-     stream << el;
-   }
-   stream << "}";
-   return stream;
- }
-
+  using iterator = SparseBitVectorIterator;
+
+  SparseBitVector() : Elements(), CurrElementIter(Elements.begin()) {}
+
+  SparseBitVector(const SparseBitVector& RHS)
+      : Elements(RHS.Elements), CurrElementIter(Elements.begin()) {}
+  SparseBitVector(SparseBitVector&& RHS)
+      : Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
+
+  // Clear.
+  void clear() {
+    Elements.clear();
+  }
+
+  // Assignment
+  SparseBitVector& operator=(const SparseBitVector& RHS) {
+    if (this == &RHS)
+      return *this;
+
+    Elements = RHS.Elements;
+    CurrElementIter = Elements.begin();
+    return *this;
+  }
+  SparseBitVector& operator=(SparseBitVector&& RHS) {
+    Elements = std::move(RHS.Elements);
+    CurrElementIter = Elements.begin();
+    return *this;
+  }
+
+  // Test, Reset, and Set a bit in the bitmap.
+  bool test(unsigned Idx) const {
+    if (Elements.empty())
+      return false;
+
+    unsigned ElementIndex = Idx / ElementSize;
+    ElementListConstIter ElementIter = FindLowerBoundConst(ElementIndex);
+
+    // If we can't find an element that is supposed to contain this bit, there
+    // is nothing more to do.
+    if (ElementIter == Elements.end() || ElementIter->index() != ElementIndex)
+      return false;
+    return ElementIter->test(Idx % ElementSize);
+  }
+
+  void reset(unsigned Idx) {
+    if (Elements.empty())
+      return;
+
+    unsigned ElementIndex = Idx / ElementSize;
+    ElementListIter ElementIter = FindLowerBound(ElementIndex);
+
+    // If we can't find an element that is supposed to contain this bit, there
+    // is nothing more to do.
+    if (ElementIter == Elements.end() || ElementIter->index() != ElementIndex)
+      return;
+    ElementIter->reset(Idx % ElementSize);
+
+    // When the element is zeroed out, delete it.
+    if (ElementIter->empty()) {
+      ++CurrElementIter;
+      Elements.erase(ElementIter);
+    }
+  }
+
+  void set(unsigned Idx) {
+    unsigned ElementIndex = Idx / ElementSize;
+    ElementListIter ElementIter;
+    if (Elements.empty()) {
+      ElementIter = Elements.emplace(Elements.end(), ElementIndex);
+    } else {
+      ElementIter = FindLowerBound(ElementIndex);
+
+      if (ElementIter == Elements.end() ||
+          ElementIter->index() != ElementIndex) {
+        // We may have hit the beginning of our SparseBitVector, in which case,
+        // we may need to insert right after this element, which requires moving
+        // the current iterator forward one, because insert does insert before.
+        if (ElementIter != Elements.end() &&
+            ElementIter->index() < ElementIndex)
+          ++ElementIter;
+        ElementIter = Elements.emplace(ElementIter, ElementIndex);
+      }
+    }
+    CurrElementIter = ElementIter;
+
+    ElementIter->set(Idx % ElementSize);
+  }
+
+  bool test_and_set(unsigned Idx) {
+    bool old = test(Idx);
+    if (!old) {
+      set(Idx);
+      return true;
+    }
+    return false;
+  }
+
+  bool operator!=(const SparseBitVector& RHS) const {
+    return !(*this == RHS);
+  }
+
+  bool operator==(const SparseBitVector& RHS) const {
+    ElementListConstIter Iter1 = Elements.begin();
+    ElementListConstIter Iter2 = RHS.Elements.begin();
+
+    for (; Iter1 != Elements.end() && Iter2 != RHS.Elements.end();
+         ++Iter1, ++Iter2) {
+      if (*Iter1 != *Iter2)
+        return false;
+    }
+    return Iter1 == Elements.end() && Iter2 == RHS.Elements.end();
+  }
+
+  // Union our bitmap with the RHS and return true if we changed.
+  bool operator|=(const SparseBitVector& RHS) {
+    if (this == &RHS)
+      return false;
+
+    bool changed = false;
+    ElementListIter Iter1 = Elements.begin();
+    ElementListConstIter Iter2 = RHS.Elements.begin();
+
+    // If RHS is empty, we are done
+    if (RHS.Elements.empty())
+      return false;
+
+    while (Iter2 != RHS.Elements.end()) {
+      if (Iter1 == Elements.end() || Iter1->index() > Iter2->index()) {
+        Elements.insert(Iter1, *Iter2);
+        ++Iter2;
+        changed = true;
+      } else if (Iter1->index() == Iter2->index()) {
+        changed |= Iter1->unionWith(*Iter2);
+        ++Iter1;
+        ++Iter2;
+      } else {
+        ++Iter1;
+      }
+    }
+    CurrElementIter = Elements.begin();
+    return changed;
+  }
+
+  // Intersect our bitmap with the RHS and return true if ours changed.
+  bool operator-=(const SparseBitVector& RHS) {
+    return intersectWithComplement(RHS);
+  }
+
+  // Intersect our bitmap with the RHS and return true if ours changed.
+  bool operator&=(const SparseBitVector& RHS) {
+    if (this == &RHS)
+      return false;
+
+    bool changed = false;
+    ElementListIter Iter1 = Elements.begin();
+    ElementListConstIter Iter2 = RHS.Elements.begin();
+
+    // Check if both bitmaps are empty.
+    if (Elements.empty() && RHS.Elements.empty())
+      return false;
+
+    // Loop through, intersecting as we go, erasing elements when necessary.
+    while (Iter2 != RHS.Elements.end()) {
+      if (Iter1 == Elements.end()) {
+        CurrElementIter = Elements.begin();
+        return changed;
+      }
+
+      if (Iter1->index() > Iter2->index()) {
+        ++Iter2;
+      } else if (Iter1->index() == Iter2->index()) {
+        bool BecameZero;
+        changed |= Iter1->intersectWith(*Iter2, BecameZero);
+        if (BecameZero) {
+          ElementListIter IterTmp = Iter1;
+          ++Iter1;
+          Elements.erase(IterTmp);
+        } else {
+          ++Iter1;
+        }
+        ++Iter2;
+      } else {
+        ElementListIter IterTmp = Iter1;
+        ++Iter1;
+        Elements.erase(IterTmp);
+        changed = true;
+      }
+    }
+    if (Iter1 != Elements.end()) {
+      Elements.erase(Iter1, Elements.end());
+      changed = true;
+    }
+    CurrElementIter = Elements.begin();
+    return changed;
+  }
+
+  // Intersect our bitmap with the complement of the RHS and return true
+  // if ours changed.
+  bool intersectWithComplement(const SparseBitVector& RHS) {
+    if (this == &RHS) {
+      if (!empty()) {
+        clear();
+        return true;
+      }
+      return false;
+    }
+
+    bool changed = false;
+    ElementListIter Iter1 = Elements.begin();
+    ElementListConstIter Iter2 = RHS.Elements.begin();
+
+    // If either our bitmap or RHS is empty, we are done
+    if (Elements.empty() || RHS.Elements.empty())
+      return false;
+
+    // Loop through, intersecting as we go, erasing elements when necessary.
+    while (Iter2 != RHS.Elements.end()) {
+      if (Iter1 == Elements.end()) {
+        CurrElementIter = Elements.begin();
+        return changed;
+      }
+
+      if (Iter1->index() > Iter2->index()) {
+        ++Iter2;
+      } else if (Iter1->index() == Iter2->index()) {
+        bool BecameZero;
+        changed |= Iter1->intersectWithComplement(*Iter2, BecameZero);
+        if (BecameZero) {
+          ElementListIter IterTmp = Iter1;
+          ++Iter1;
+          Elements.erase(IterTmp);
+        } else {
+          ++Iter1;
+        }
+        ++Iter2;
+      } else {
+        ++Iter1;
+      }
+    }
+    CurrElementIter = Elements.begin();
+    return changed;
+  }
+
+  bool intersectWithComplement(const SparseBitVector<ElementSize>* RHS) const {
+    return intersectWithComplement(*RHS);
+  }
+
+  //  Three argument version of intersectWithComplement.
+  //  Result of RHS1 & ~RHS2 is stored into this bitmap.
+  void intersectWithComplement(
+      const SparseBitVector<ElementSize>& RHS1,
+      const SparseBitVector<ElementSize>& RHS2) {
+    if (this == &RHS1) {
+      intersectWithComplement(RHS2);
+      return;
+    } else if (this == &RHS2) {
+      SparseBitVector RHS2Copy(RHS2);
+      intersectWithComplement(RHS1, RHS2Copy);
+      return;
+    }
+
+    Elements.clear();
+    CurrElementIter = Elements.begin();
+    ElementListConstIter Iter1 = RHS1.Elements.begin();
+    ElementListConstIter Iter2 = RHS2.Elements.begin();
+
+    // If RHS1 is empty, we are done
+    // If RHS2 is empty, we still have to copy RHS1
+    if (RHS1.Elements.empty())
+      return;
+
+    // Loop through, intersecting as we go, erasing elements when necessary.
+    while (Iter2 != RHS2.Elements.end()) {
+      if (Iter1 == RHS1.Elements.end())
+        return;
+
+      if (Iter1->index() > Iter2->index()) {
+        ++Iter2;
+      } else if (Iter1->index() == Iter2->index()) {
+        bool BecameZero = false;
+        Elements.emplace_back(Iter1->index());
+        Elements.back().intersectWithComplement(*Iter1, *Iter2, BecameZero);
+        if (BecameZero)
+          Elements.pop_back();
+        ++Iter1;
+        ++Iter2;
+      } else {
+        Elements.push_back(*Iter1++);
+      }
+    }
+
+    // copy the remaining elements
+    std::copy(Iter1, RHS1.Elements.end(), std::back_inserter(Elements));
+  }
+
+  void intersectWithComplement(
+      const SparseBitVector<ElementSize>* RHS1,
+      const SparseBitVector<ElementSize>* RHS2) {
+    intersectWithComplement(*RHS1, *RHS2);
+  }
+
+  bool intersects(const SparseBitVector<ElementSize>* RHS) const {
+    return intersects(*RHS);
+  }
+
+  // Return true if we share any bits in common with RHS
+  bool intersects(const SparseBitVector<ElementSize>& RHS) const {
+    ElementListConstIter Iter1 = Elements.begin();
+    ElementListConstIter Iter2 = RHS.Elements.begin();
+
+    // Check if both bitmaps are empty.
+    if (Elements.empty() && RHS.Elements.empty())
+      return false;
+
+    // Loop through, intersecting stopping when we hit bits in common.
+    while (Iter2 != RHS.Elements.end()) {
+      if (Iter1 == Elements.end())
+        return false;
+
+      if (Iter1->index() > Iter2->index()) {
+        ++Iter2;
+      } else if (Iter1->index() == Iter2->index()) {
+        if (Iter1->intersects(*Iter2))
+          return true;
+        ++Iter1;
+        ++Iter2;
+      } else {
+        ++Iter1;
+      }
+    }
+    return false;
+  }
+
+  // Return true iff all bits set in this SparseBitVector are
+  // also set in RHS.
+  bool contains(const SparseBitVector<ElementSize>& RHS) const {
+    SparseBitVector<ElementSize> Result(*this);
+    Result &= RHS;
+    return (Result == RHS);
+  }
+
+  // Return the first set bit in the bitmap.  Return -1 if no bits are set.
+  int find_first() const {
+    if (Elements.empty())
+      return -1;
+    const SparseBitVectorElement<ElementSize>& First = *(Elements.begin());
+    return (First.index() * ElementSize) + First.find_first();
+  }
+
+  // Return the last set bit in the bitmap.  Return -1 if no bits are set.
+  int find_last() const {
+    if (Elements.empty())
+      return -1;
+    const SparseBitVectorElement<ElementSize>& Last = *(Elements.rbegin());
+    return (Last.index() * ElementSize) + Last.find_last();
+  }
+
+  // Return true if the SparseBitVector is empty
+  bool empty() const {
+    return Elements.empty();
+  }
+
+  unsigned count() const {
+    unsigned BitCount = 0;
+    for (ElementListConstIter Iter = Elements.begin(); Iter != Elements.end();
+         ++Iter)
+      BitCount += Iter->count();
+
+    return BitCount;
+  }
+
+  iterator begin() const {
+    return iterator(this);
+  }
+
+  iterator end() const {
+    return iterator(this, true);
+  }
+};
+
+// Convenience functions to allow Or and And without dereferencing in the user
+// code.
+
+template <unsigned ElementSize>
+inline bool operator|=(
+    SparseBitVector<ElementSize>& LHS,
+    const SparseBitVector<ElementSize>* RHS) {
+  return LHS |= *RHS;
+}
+
+template <unsigned ElementSize>
+inline bool operator|=(
+    SparseBitVector<ElementSize>* LHS,
+    const SparseBitVector<ElementSize>& RHS) {
+  return LHS->operator|=(RHS);
+}
+
+template <unsigned ElementSize>
+inline bool operator&=(
+    SparseBitVector<ElementSize>* LHS,
+    const SparseBitVector<ElementSize>& RHS) {
+  return LHS->operator&=(RHS);
+}
+
+template <unsigned ElementSize>
+inline bool operator&=(
+    SparseBitVector<ElementSize>& LHS,
+    const SparseBitVector<ElementSize>* RHS) {
+  return LHS &= *RHS;
+}
+
+// Convenience functions for infix union, intersection, difference operators.
+
+template <unsigned ElementSize>
+inline SparseBitVector<ElementSize> operator|(
+    const SparseBitVector<ElementSize>& LHS,
+    const SparseBitVector<ElementSize>& RHS) {
+  SparseBitVector<ElementSize> Result(LHS);
+  Result |= RHS;
+  return Result;
+}
+
+template <unsigned ElementSize>
+inline SparseBitVector<ElementSize> operator&(
+    const SparseBitVector<ElementSize>& LHS,
+    const SparseBitVector<ElementSize>& RHS) {
+  SparseBitVector<ElementSize> Result(LHS);
+  Result &= RHS;
+  return Result;
+}
+
+template <unsigned ElementSize>
+inline SparseBitVector<ElementSize> operator-(
+    const SparseBitVector<ElementSize>& LHS,
+    const SparseBitVector<ElementSize>& RHS) {
+  SparseBitVector<ElementSize> Result;
+  Result.intersectWithComplement(LHS, RHS);
+  return Result;
+}
+
+template <unsigned ElementSize>
+std::ostream& operator<<(
+    std::ostream& stream,
+    const SparseBitVector<ElementSize>& vec) {
+  bool first = true;
+  stream << "{";
+  for (auto el : vec) {
+    if (first) {
+      first = false;
+    } else {
+      stream << ", ";
+    }
+    stream << el;
+  }
+  stream << "}";
+  return stream;
+}
 
 } // end namespace c10
diff --git a/c10/util/string_utils.h b/c10/util/string_utils.h
index 8e4d2b42349..e6a9685bf89 100644
--- a/c10/util/string_utils.h
+++ b/c10/util/string_utils.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <sstream>
-#include <string>
 #include <stdexcept>
+#include <string>
 
 namespace c10 {
 
@@ -125,8 +125,8 @@ inline long long stoll(const std::string& str, size_t pos, int base) {
 #define CAFFE2_TESTONLY_WE_ARE_USING_CUSTOM_STRING_FUNCTIONS 0
 using std::stod;
 using std::stoi;
-using std::stoull;
 using std::stoll;
+using std::stoull;
 using std::to_string;
 #endif // defined(__ANDROID__) || defined(CAFFE2_FORCE_STD_STRING_FALLBACK_TEST)
 
@@ -137,6 +137,6 @@ using std::to_string;
 // std::strtoll isn't available on Android NDK platform < 21 when building
 // with libstdc++, so bring the global version into std.
 namespace std {
-  using ::strtoll;
+using ::strtoll;
 }
 #endif
diff --git a/c10/util/string_view.h b/c10/util/string_view.h
index 140521553e3..9824002929d 100644
--- a/c10/util/string_view.h
+++ b/c10/util/string_view.h
@@ -3,11 +3,11 @@
 #include <c10/macros/Macros.h>
 #include <c10/util/C++17.h>
 #include <c10/util/reverse_iterator.h>
+#include <algorithm>
 #include <cstring>
 #include <limits>
 #include <stdexcept>
 #include <string>
-#include <algorithm>
 
 namespace c10 {
 
@@ -112,7 +112,8 @@ class basic_string_view final {
     return C10_UNLIKELY(pos >= size_)
         ? (throw std::out_of_range(
                "string_view::operator[] or string_view::at() out of range. Index: " +
-               c10::guts::to_string(pos) + ", size: " + c10::guts::to_string(size())),
+               c10::guts::to_string(pos) +
+               ", size: " + c10::guts::to_string(size())),
            at_(0))
         : at_(pos);
 #else
@@ -194,7 +195,8 @@ class basic_string_view final {
     return (pos > size_)
         ? (throw std::out_of_range(
                "basic_string_view::substr parameter out of bounds. Index: " +
-               c10::guts::to_string(pos) + ", size: " + c10::guts::to_string(size())),
+               c10::guts::to_string(pos) +
+               ", size: " + c10::guts::to_string(size())),
            substr_())
         : substr_(pos, count);
 #else
@@ -222,13 +224,11 @@ class basic_string_view final {
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
     return (size() == 0 && rhs.size() == 0) ? 0
-                                            : (size() == 0) ? -1
-                                                            : (rhs.size() == 0)
-                ? 1
-                : (front() < rhs.front()) ? -1
-                                          : (front() > rhs.front())
-                        ? 1
-                        : substr_(1).compare(rhs.substr_(1));
+        : (size() == 0)                     ? -1
+        : (rhs.size() == 0)                 ? 1
+        : (front() < rhs.front())           ? -1
+        : (front() > rhs.front())           ? 1
+                                  : substr_(1).compare(rhs.substr_(1));
 #endif
   }
 
@@ -326,8 +326,8 @@ class basic_string_view final {
     return ends_with(basic_string_view(suffix));
   }
 
-  constexpr size_type find(basic_string_view v, size_type pos = 0) const
-      noexcept {
+  constexpr size_type find(basic_string_view v, size_type pos = 0)
+      const noexcept {
 #if __cpp_constexpr >= 201304
     // if we are in C++14, write it iteratively. This is faster.
     if (v.size() == 0) {
@@ -346,13 +346,12 @@ class basic_string_view final {
 #else
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
-    return (v.size() == 0) ? (pos <= size() ? pos : npos)
-                           : (pos + v.size() > size())
-            ? npos
-            : (v.at_(0) == at_(pos) &&
-               v.substr_(1).equals_(substr_(pos + 1, v.size() - 1)))
-                ? pos
-                : find(v, pos + 1);
+    return (v.size() == 0)          ? (pos <= size() ? pos : npos)
+        : (pos + v.size() > size()) ? npos
+        : (v.at_(0) == at_(pos) &&
+           v.substr_(1).equals_(substr_(pos + 1, v.size() - 1)))
+        ? pos
+        : find(v, pos + 1);
 #endif
   }
 
@@ -369,8 +368,8 @@ class basic_string_view final {
     return find(basic_string_view(s), pos);
   }
 
-  constexpr size_type rfind(basic_string_view v, size_type pos = npos) const
-      noexcept {
+  constexpr size_type rfind(basic_string_view v, size_type pos = npos)
+      const noexcept {
 #if __cpp_constexpr >= 201304
     // if we are in C++14, write it iteratively. This is faster.
     if (v.size() == 0) {
@@ -390,14 +389,14 @@ class basic_string_view final {
 #else
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
-    return (v.size() == 0) ? (pos <= size() ? pos : size())
-                           : (v.size() > size()) ? npos
-                                                 : (size() - v.size() < pos)
-                ? rfind(v, size() - v.size())
-                : (v.at_(0) == at_(pos) &&
-                   v.substr_(1).equals_(substr_(pos + 1, v.size() - 1)))
-                    ? pos
-                    : (pos == 0) ? npos : rfind(v, pos - 1);
+    return (v.size() == 0)          ? (pos <= size() ? pos : size())
+        : (v.size() > size())       ? npos
+        : (size() - v.size() < pos) ? rfind(v, size() - v.size())
+        : (v.at_(0) == at_(pos) &&
+           v.substr_(1).equals_(substr_(pos + 1, v.size() - 1)))
+        ? pos
+        : (pos == 0) ? npos
+                     : rfind(v, pos - 1);
 #endif
   }
 
@@ -419,8 +418,8 @@ class basic_string_view final {
     return find_first_if_(pos, stringViewContainsChar_{v});
   }
 
-  constexpr size_type find_first_of(CharT ch, size_type pos = 0) const
-      noexcept {
+  constexpr size_type find_first_of(CharT ch, size_type pos = 0)
+      const noexcept {
     return find_first_if_(pos, charIsEqual_{ch});
   }
 
@@ -440,8 +439,8 @@ class basic_string_view final {
     return find_last_if_(pos, stringViewContainsChar_{v});
   }
 
-  constexpr size_type find_last_of(CharT ch, size_type pos = npos) const
-      noexcept {
+  constexpr size_type find_last_of(CharT ch, size_type pos = npos)
+      const noexcept {
     return find_last_if_(pos, charIsEqual_{ch});
   }
 
@@ -462,8 +461,8 @@ class basic_string_view final {
     return find_first_if_(pos, stringViewDoesNotContainChar_{v});
   }
 
-  constexpr size_type find_first_not_of(CharT ch, size_type pos = 0) const
-      noexcept {
+  constexpr size_type find_first_not_of(CharT ch, size_type pos = 0)
+      const noexcept {
     return find_first_if_(pos, charIsNotEqual_{ch});
   }
 
@@ -485,8 +484,8 @@ class basic_string_view final {
     return find_last_if_(pos, stringViewDoesNotContainChar_{v});
   }
 
-  constexpr size_type find_last_not_of(CharT ch, size_type pos = npos) const
-      noexcept {
+  constexpr size_type find_last_not_of(CharT ch, size_type pos = npos)
+      const noexcept {
     return find_last_if_(pos, charIsNotEqual_{ch});
   }
 
@@ -528,8 +527,8 @@ class basic_string_view final {
   }
 
   template <class Condition>
-  constexpr size_type find_first_if_(size_type pos, Condition&& condition) const
-      noexcept {
+  constexpr size_type find_first_if_(size_type pos, Condition&& condition)
+      const noexcept {
 #if __cpp_constexpr >= 201304
     // if we are in C++14, write it iteratively. This is faster.
     if (pos + 1 <= size()) {
@@ -544,15 +543,15 @@ class basic_string_view final {
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
     return (pos + 1 > size()) ? npos
-                              : condition(at_(pos))
-            ? pos
-            : find_first_if_(pos + 1, std::forward<Condition>(condition));
+        : condition(at_(pos))
+        ? pos
+        : find_first_if_(pos + 1, std::forward<Condition>(condition));
 #endif
   }
 
   template <class Condition>
-  constexpr size_type find_last_if_(size_type pos, Condition&& condition) const
-      noexcept {
+  constexpr size_type find_last_if_(size_type pos, Condition&& condition)
+      const noexcept {
 #if __cpp_constexpr >= 201304
     // if we are in C++14, write it iteratively. This is faster.
     if (size() > 0) {
@@ -568,23 +567,24 @@ class basic_string_view final {
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
     return (size() == 0) ? npos
-                         : (pos >= size())
-            ? find_last_if_(size() - 1, std::forward<Condition>(condition))
-            : condition(at_(pos))
-                ? pos
-                : (pos == 0) ? npos
-                             : find_last_if_(
-                                   pos - 1, std::forward<Condition>(condition));
+        : (pos >= size())
+        ? find_last_if_(size() - 1, std::forward<Condition>(condition))
+        : condition(at_(pos)) ? pos
+        : (pos == 0)
+        ? npos
+        : find_last_if_(pos - 1, std::forward<Condition>(condition));
 #endif
   }
 
   constexpr bool equals_(basic_string_view rhs) const {
-    // We don't use string_view::compare() here but implement it manually because
-    // only looking at equality allows for more optimized code.
+    // We don't use string_view::compare() here but implement it manually
+    // because only looking at equality allows for more optimized code.
 #if defined(__GNUC__) && !defined(__CUDACC__)
-    return size() == rhs.size() && 0 == __builtin_memcmp(data(), rhs.data(), size());
+    return size() == rhs.size() &&
+        0 == __builtin_memcmp(data(), rhs.data(), size());
 #elif __cpp_constexpr >= 201304
-    // if we are in C++14, write it iteratively. This is faster than the recursive C++11 implementation below.
+    // if we are in C++14, write it iteratively. This is faster than the
+    // recursive C++11 implementation below.
     if (size() != rhs.size()) {
       return false;
     }
@@ -602,11 +602,10 @@ class basic_string_view final {
 #else
     // if we are in C++11, we need to do it recursively because of constexpr
     // restrictions.
-    return (size() != rhs.size()) ? false
-                                  : (size() == 0)
-            ? true
-            : (front() != rhs.front()) ? false
-                                       : (substr_(1).equals_(rhs.substr_(1)));
+    return (size() != rhs.size())  ? false
+        : (size() == 0)            ? true
+        : (front() != rhs.front()) ? false
+                                   : (substr_(1).equals_(rhs.substr_(1)));
 #endif
   }
 
@@ -643,7 +642,8 @@ class basic_string_view final {
 };
 
 template <class CharT>
-const typename basic_string_view<CharT>::size_type basic_string_view<CharT>::npos;
+const typename basic_string_view<CharT>::size_type
+    basic_string_view<CharT>::npos;
 
 template <class CharT>
 inline std::basic_ostream<CharT>& operator<<(
diff --git a/c10/util/tempfile.h b/c10/util/tempfile.h
index b083f2bb0e3..3e6b1628266 100644
--- a/c10/util/tempfile.h
+++ b/c10/util/tempfile.h
@@ -16,7 +16,7 @@
 #else // defined(_WIN32)
 #include <Windows.h>
 #include <fileapi.h>
-#endif  // defined(_WIN32)
+#endif // defined(_WIN32)
 
 namespace c10 {
 namespace detail {
@@ -61,7 +61,8 @@ struct TempFile {
   TempFile() : fd(-1) {}
   TempFile(std::string name, int fd) : fd(fd), name(std::move(name)) {}
   TempFile(const TempFile&) = delete;
-  TempFile(TempFile&& other) noexcept : fd(other.fd), name(std::move(other.name)) {
+  TempFile(TempFile&& other) noexcept
+      : fd(other.fd), name(std::move(other.name)) {
     other.fd = -1;
     other.name.clear();
   }
@@ -109,13 +110,13 @@ struct TempDir {
       rmdir(name.c_str());
     }
   }
-#else   // defined(_WIN32)
+#else // defined(_WIN32)
   ~TempDir() {
     if (!name.empty()) {
       RemoveDirectoryA(name.c_str());
     }
   }
-#endif  // defined(_WIN32)
+#endif // defined(_WIN32)
 
   std::string name;
 };
@@ -159,8 +160,8 @@ inline TempFile make_tempfile(std::string name_prefix = "torch-file-") {
 /// occurred.
 ///
 /// The directory returned follows the pattern
-/// `<tmp-dir>/<name-prefix><random-pattern>/`, where `<tmp-dir>` is the value of
-/// the `"TMPDIR"`, `"TMP"`, `"TEMP"` or
+/// `<tmp-dir>/<name-prefix><random-pattern>/`, where `<tmp-dir>` is the value
+/// of the `"TMPDIR"`, `"TMP"`, `"TEMP"` or
 /// `"TEMPDIR"` environment variable if any is set, or otherwise `/tmp`;
 /// `<name-prefix>` is the value supplied to this function, and
 /// `<random-pattern>` is a random sequence of numbers.
@@ -191,12 +192,13 @@ inline c10::optional<TempDir> try_make_tempdir(
 #endif // defined(_WIN32)
 }
 
-/// Like `try_make_tempdir`, but throws an exception if a temporary directory could
-/// not be returned.
+/// Like `try_make_tempdir`, but throws an exception if a temporary directory
+/// could not be returned.
 inline TempDir make_tempdir(std::string name_prefix = "torch-dir-") {
   if (auto tempdir = try_make_tempdir(std::move(name_prefix))) {
     return std::move(*tempdir);
   }
-  TORCH_CHECK(false, "Error generating temporary directory: ", std::strerror(errno));
+  TORCH_CHECK(
+      false, "Error generating temporary directory: ", std::strerror(errno));
 }
 } // namespace c10
diff --git a/c10/util/typeid.cpp b/c10/util/typeid.cpp
index 645f23ee795..2520ef9f0f1 100644
--- a/c10/util/typeid.cpp
+++ b/c10/util/typeid.cpp
@@ -1,5 +1,5 @@
-#include <c10/util/typeid.h>
 #include <c10/util/Exception.h>
+#include <c10/util/typeid.h>
 
 #include <atomic>
 
@@ -19,7 +19,11 @@ C10_EXPORT void _ThrowRuntimeTypeLogicError(const string& msg) {
 } // namespace detail
 
 [[noreturn]] void TypeMeta::error_unsupported_typemeta(caffe2::TypeMeta dtype) {
-  TORCH_CHECK(false, "Unsupported TypeMeta in ATen: ", dtype, " (please report this error)");
+  TORCH_CHECK(
+      false,
+      "Unsupported TypeMeta in ATen: ",
+      dtype,
+      " (please report this error)");
 }
 
 // see TypeMeta::addTypeMetaData
@@ -30,22 +34,22 @@ std::atomic<uint16_t> TypeMeta::nextTypeIndex(NumScalarTypes);
 detail::TypeMetaData* TypeMeta::typeMetaDatas() {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
   static detail::TypeMetaData instances[MaxTypeIndex + 1] = {
-#define SCALAR_TYPE_META(T, name)         \
-    /* ScalarType::name */                \
-    detail::TypeMetaData(                 \
-      sizeof(T),                          \
-      detail::_PickNew<T>(),              \
-      detail::_PickPlacementNew<T>(),     \
-      detail::_PickCopy<T>(),             \
-      detail::_PickPlacementDelete<T>(),  \
-      detail::_PickDelete<T>(),           \
-      TypeIdentifier::Get<T>(),           \
+#define SCALAR_TYPE_META(T, name)        \
+  /* ScalarType::name */                 \
+  detail::TypeMetaData(                  \
+      sizeof(T),                         \
+      detail::_PickNew<T>(),             \
+      detail::_PickPlacementNew<T>(),    \
+      detail::_PickCopy<T>(),            \
+      detail::_PickPlacementDelete<T>(), \
+      detail::_PickDelete<T>(),          \
+      TypeIdentifier::Get<T>(),          \
       c10::util::get_fully_qualified_type_name<T>()),
-AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SCALAR_TYPE_META)
+      AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SCALAR_TYPE_META)
 #undef SCALAR_TYPE_META
-    // The remainder of the array is padded with TypeMetaData blanks.
-    // The first of these is the entry for ScalarType::Undefined.
-    // The rest are consumed by CAFFE_KNOWN_TYPE entries.
+      // The remainder of the array is padded with TypeMetaData blanks.
+      // The first of these is the entry for ScalarType::Undefined.
+      // The rest are consumed by CAFFE_KNOWN_TYPE entries.
   };
   return instances;
 }
diff --git a/c10/util/typeid.h b/c10/util/typeid.h
index 2a7e8b0a4b9..4378550ac72 100644
--- a/c10/util/typeid.h
+++ b/c10/util/typeid.h
@@ -23,8 +23,8 @@
 #include <c10/util/Exception.h>
 #include <c10/util/IdWrapper.h>
 #include <c10/util/Type.h>
-#include <c10/util/TypeTraits.h>
 #include <c10/util/TypeIndex.h>
+#include <c10/util/TypeTraits.h>
 #include <c10/util/flat_hash_map.h>
 
 #include <c10/core/ScalarType.h>
@@ -63,7 +63,7 @@ namespace caffe2 {
  */
 class C10_API TypeIdentifier final
     : public at::IdWrapper<TypeIdentifier, c10::util::type_index> {
-public:
+ public:
   friend std::ostream& operator<<(std::ostream& stream, TypeIdentifier typeId);
   friend constexpr bool operator<(TypeIdentifier lhs, TypeIdentifier rhs);
 
@@ -83,7 +83,7 @@ public:
     return TypeIdentifier(c10::util::type_index{0});
   }
 
-private:
+ private:
   constexpr explicit TypeIdentifier(c10::util::type_index id) : IdWrapper(id) {}
 };
 
@@ -122,14 +122,14 @@ struct TypeMetaData final {
   using Delete = void(void*);
 
   constexpr TypeMetaData() noexcept
-  : itemsize_(0),
-    new_(nullptr),
-    placementNew_(nullptr),
-    copy_(nullptr),
-    placementDelete_(nullptr),
-    delete_(nullptr),
-    id_(TypeIdentifier::uninitialized()),
-    name_("nullptr (uninitialized)") {}
+      : itemsize_(0),
+        new_(nullptr),
+        placementNew_(nullptr),
+        copy_(nullptr),
+        placementDelete_(nullptr),
+        delete_(nullptr),
+        id_(TypeIdentifier::uninitialized()),
+        name_("nullptr (uninitialized)") {}
 
   constexpr TypeMetaData(
       size_t itemsize,
@@ -140,14 +140,14 @@ struct TypeMetaData final {
       Delete* deleteFn,
       TypeIdentifier id,
       c10::string_view name) noexcept
-  : itemsize_(itemsize),
-    new_(newFn),
-    placementNew_(placementNew),
-    copy_(copy),
-    placementDelete_(placementDelete),
-    delete_(deleteFn),
-    id_(id),
-    name_(name) {}
+      : itemsize_(itemsize),
+        new_(newFn),
+        placementNew_(placementNew),
+        copy_(copy),
+        placementDelete_(placementDelete),
+        delete_(deleteFn),
+        id_(id),
+        name_(name) {}
 
   size_t itemsize_;
   New* new_;
@@ -311,9 +311,9 @@ class _Uninitialized final {};
 // item sizes for TypeMeta::itemsize() fast path
 static constexpr uint8_t scalarTypeItemSizes[NumScalarTypes] = {
 #define SCALAR_TYPE_SIZE(T, name) sizeof(T),
-  AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SCALAR_TYPE_SIZE)
+    AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(SCALAR_TYPE_SIZE)
 #undef SCALAR_TYPE_SIZE
-    0, // Undefined
+        0, // Undefined
 };
 
 /**
@@ -352,12 +352,10 @@ class C10_API TypeMeta final {
     return *this;
   }
 
-private:
+ private:
   // TypeMeta can only be created by Make, making sure that we do not
   // create incorrectly mixed up TypeMeta objects.
-  explicit TypeMeta(const uint16_t index) noexcept
-  : index_(index) {
-  }
+  explicit TypeMeta(const uint16_t index) noexcept : index_(index) {}
 
  public:
   /**
@@ -421,9 +419,7 @@ private:
     return data().name_;
   }
 
-  friend bool operator==(
-      const TypeMeta lhs,
-      const TypeMeta rhs) noexcept;
+  friend bool operator==(const TypeMeta lhs, const TypeMeta rhs) noexcept;
 
   template <typename T>
   bool Match() const noexcept {
@@ -470,13 +466,15 @@ private:
   }
 
   /**
-  * convert ScalarType enum values to TypeMeta handles
-  */
+   * convert ScalarType enum values to TypeMeta handles
+   */
   static inline caffe2::TypeMeta fromScalarType(ScalarType scalar_type) {
     const size_t index = static_cast<uint16_t>(scalar_type);
     TORCH_INTERNAL_ASSERT_DEBUG_ONLY(
-      index < NumScalarTypes,
-      "Unrecognized Scalartype ", scalar_type, " (please report this error)");
+        index < NumScalarTypes,
+        "Unrecognized Scalartype ",
+        scalar_type,
+        " (please report this error)");
     return TypeMeta(index);
   }
 
@@ -490,24 +488,24 @@ private:
     error_unsupported_typemeta(*this);
   }
 
-private:
+ private:
   [[noreturn]] static void error_unsupported_typemeta(caffe2::TypeMeta dtype);
 
   // hard limit number of registered types
-  // note: constexpr provokes Windows compilation error "member may not be initialized"
-  // static constexpr size_t MaxTypeIndex = 32;
+  // note: constexpr provokes Windows compilation error "member may not be
+  // initialized" static constexpr size_t MaxTypeIndex = 32;
   //
 #if defined C10_MOBILE
-  // The reason for this to be 32 and not UINT8_MAX is that the array initialization
-  // takes space which is proportional to the size of the array. The compiler seems to
-  // add code (or data padding) to initialize the array with empty elements. In
-  // practice, this array doesn't hold more than 18 elements (on mobile), so 32 should
-  // be plenty for now. Please see https://github.com/pytorch/pytorch/pull/51881
-  // for details.
-  //
-  #define MaxTypeIndex 32
+// The reason for this to be 32 and not UINT8_MAX is that the array
+// initialization takes space which is proportional to the size of the array.
+// The compiler seems to add code (or data padding) to initialize the array with
+// empty elements. In practice, this array doesn't hold more than 18 elements
+// (on mobile), so 32 should be plenty for now. Please see
+// https://github.com/pytorch/pytorch/pull/51881 for details.
+//
+#define MaxTypeIndex 32
 #else
-  #define MaxTypeIndex UINT8_MAX
+#define MaxTypeIndex UINT8_MAX
 #endif
 
   static std::atomic<uint16_t> nextTypeIndex;
@@ -517,18 +515,19 @@ private:
   template <class T>
   static uint16_t addTypeMetaData() {
     const uint16_t index = nextTypeIndex++;
-    TORCH_CHECK(index <= MaxTypeIndex,
-      "Maximum number of CAFFE_KNOWN_TYPE declarations has been exceeded. ",
-      "Please report this issue.");
+    TORCH_CHECK(
+        index <= MaxTypeIndex,
+        "Maximum number of CAFFE_KNOWN_TYPE declarations has been exceeded. ",
+        "Please report this issue.");
     typeMetaDatas()[index] = detail::TypeMetaData{
-      sizeof(T),
-      detail::_PickNew<T>(),
-      detail::_PickPlacementNew<T>(),
-      detail::_PickCopy<T>(),
-      detail::_PickPlacementDelete<T>(),
-      detail::_PickDelete<T>(),
-      TypeIdentifier::Get<T>(),
-      c10::util::get_fully_qualified_type_name<T>()};
+        sizeof(T),
+        detail::_PickNew<T>(),
+        detail::_PickPlacementNew<T>(),
+        detail::_PickCopy<T>(),
+        detail::_PickPlacementDelete<T>(),
+        detail::_PickDelete<T>(),
+        TypeIdentifier::Get<T>(),
+        c10::util::get_fully_qualified_type_name<T>()};
     return index;
   }
 
@@ -549,31 +548,27 @@ private:
 
 // specializations of TypeMeta::_typeMetaData for ScalarType types
 
-#define DEFINE_SCALAR_METADATA_INSTANCE(T, name)              \
-  template <>                                                 \
-  constexpr uint16_t TypeMeta::_typeMetaData<T>() noexcept {  \
-    return static_cast<uint16_t>(ScalarType::name);           \
+#define DEFINE_SCALAR_METADATA_INSTANCE(T, name)             \
+  template <>                                                \
+  constexpr uint16_t TypeMeta::_typeMetaData<T>() noexcept { \
+    return static_cast<uint16_t>(ScalarType::name);          \
   }
 AT_FORALL_SCALAR_TYPES_WITH_COMPLEX_AND_QINTS(DEFINE_SCALAR_METADATA_INSTANCE)
 #undef DEFINE_SCALAR_METADATA_INSTANCE
 
 template <>
-C10_EXPORT constexpr uint16_t TypeMeta::_typeMetaData<detail::_Uninitialized>() noexcept {
+C10_EXPORT constexpr uint16_t TypeMeta::_typeMetaData<
+    detail::_Uninitialized>() noexcept {
   return static_cast<uint16_t>(ScalarType::Undefined);
 }
 
 inline TypeMeta::TypeMeta() noexcept
-  : index_(_typeMetaData<detail::_Uninitialized>()) {
-}
+    : index_(_typeMetaData<detail::_Uninitialized>()) {}
 
-inline bool operator==(
-    const TypeMeta lhs,
-    const TypeMeta rhs) noexcept {
+inline bool operator==(const TypeMeta lhs, const TypeMeta rhs) noexcept {
   return (lhs.index_ == rhs.index_);
 }
-inline bool operator!=(
-    const TypeMeta lhs,
-    const TypeMeta rhs) noexcept {
+inline bool operator!=(const TypeMeta lhs, const TypeMeta rhs) noexcept {
   return !operator==(lhs, rhs);
 }
 
@@ -608,11 +603,11 @@ inline std::ostream& operator<<(
 #define EXPORT_IF_NOT_GCC
 #endif
 
-#define CAFFE_KNOWN_TYPE(T)                                           \
-  template <>                                                         \
-  EXPORT_IF_NOT_GCC uint16_t TypeMeta::_typeMetaData<T>() noexcept {  \
-    static const uint16_t index = addTypeMetaData<T>();               \
-    return index;                                                     \
+#define CAFFE_KNOWN_TYPE(T)                                          \
+  template <>                                                        \
+  EXPORT_IF_NOT_GCC uint16_t TypeMeta::_typeMetaData<T>() noexcept { \
+    static const uint16_t index = addTypeMetaData<T>();              \
+    return index;                                                    \
   }
 
 } // namespace caffe2
diff --git a/c10/util/variant.h b/c10/util/variant.h
index e8066d77bd8..8f571e62c08 100644
--- a/c10/util/variant.h
+++ b/c10/util/variant.h
@@ -3,7 +3,8 @@
 // Copyright Michael Park, 2015-2017
 //
 // Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+// (See accompanying file LICENSE.md or copy at
+// http://boost.org/LICENSE_1_0.txt)
 //
 // From https://github.com/mpark/variant
 //
@@ -231,7 +232,8 @@ namespace std {
 // Copyright Michael Park, 2015-2017
 //
 // Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+// (See accompanying file LICENSE.md or copy at
+// http://boost.org/LICENSE_1_0.txt)
 
 #ifndef MPARK_CONFIG_HPP
 #define MPARK_CONFIG_HPP
@@ -316,19 +318,20 @@ namespace std {
 #define MPARK_VARIABLE_TEMPLATES
 #endif
 
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
+#if !defined(__GLIBCXX__) || __has_include(<codecvt>) // >= libstdc++-5
 #define MPARK_TRIVIALITY_TYPE_TRAITS
 #define MPARK_INCOMPLETE_TYPE_TRAITS
 #endif
 
-#endif  // MPARK_CONFIG_HPP
+#endif // MPARK_CONFIG_HPP
 
 // MPark.Variant
 //
 // Copyright Michael Park, 2015-2017
 //
 // Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+// (See accompanying file LICENSE.md or copy at
+// http://boost.org/LICENSE_1_0.txt)
 
 #ifndef MPARK_IN_PLACE_HPP
 #define MPARK_IN_PLACE_HPP
@@ -337,929 +340,955 @@ namespace std {
 
 #include <cstddef>
 
-
 namespace c10 {
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
+template <std::size_t I>
+constexpr in_place_index_t<I> in_place_index{};
 
-  template <typename T> constexpr in_place_type_t<T> in_place_type{};
+template <typename T>
+constexpr in_place_type_t<T> in_place_type{};
 #endif
 
-}  // namespace c10
+} // namespace c10
 
-#endif  // MPARK_IN_PLACE_HPP
+#endif // MPARK_IN_PLACE_HPP
 
 // MPark.Variant
 //
 // Copyright Michael Park, 2015-2017
 //
 // Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+// (See accompanying file LICENSE.md or copy at
+// http://boost.org/LICENSE_1_0.txt)
 
 #ifndef MPARK_LIB_HPP
 #define MPARK_LIB_HPP
 
-#include <memory>
 #include <functional>
+#include <memory>
 #include <type_traits>
 #include <utility>
 
-
-#define MPARK_RETURN(...) \
-  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
+#define MPARK_RETURN(...)                                  \
+  noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
+    return __VA_ARGS__;                                    \
+  }
 
 namespace c10 {
-  namespace lib {
-    template <typename T>
-    struct identity { using type = T; };
+namespace lib {
+template <typename T>
+struct identity {
+  using type = T;
+};
 
-    inline namespace cpp14 {
-      template <typename T, std::size_t N>
-      struct array {
-        constexpr const T &operator[](std::size_t index) const {
-          return data[index];
-        }
+inline namespace cpp14 {
+template <typename T, std::size_t N>
+struct array {
+  constexpr const T& operator[](std::size_t index) const {
+    return data[index];
+  }
 
-        T data[N == 0 ? 1 : N];
-      };
+  T data[N == 0 ? 1 : N];
+};
 
-      template <typename T>
-      using add_pointer_t = typename std::add_pointer<T>::type;
+template <typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
 
-      template <typename... Ts>
-      using common_type_t = typename std::common_type<Ts...>::type;
+template <typename... Ts>
+using common_type_t = typename std::common_type<Ts...>::type;
 
-      template <typename T>
-      using decay_t = typename std::decay<T>::type;
+template <typename T>
+using decay_t = typename std::decay<T>::type;
 
-      template <bool B, typename T = void>
-      using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
 
-      template <typename T>
-      using remove_const_t = typename std::remove_const<T>::type;
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
 
-      template <typename T>
-      using remove_reference_t = typename std::remove_reference<T>::type;
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
 
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
-        return static_cast<T &&>(t);
-      }
+template <typename T>
+inline constexpr T&& forward(remove_reference_t<T>& t) noexcept {
+  return static_cast<T&&>(t);
+}
 
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
-        static_assert(!std::is_lvalue_reference<T>::value,
-                      "can not forward an rvalue as an lvalue");
-        return static_cast<T &&>(t);
-      }
+template <typename T>
+inline constexpr T&& forward(remove_reference_t<T>&& t) noexcept {
+  static_assert(
+      !std::is_lvalue_reference<T>::value,
+      "can not forward an rvalue as an lvalue");
+  return static_cast<T&&>(t);
+}
 
-      template <typename T>
-      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
-        return static_cast<remove_reference_t<T> &&>(t);
-      }
+template <typename T>
+inline constexpr remove_reference_t<T>&& move(T&& t) noexcept {
+  return static_cast<remove_reference_t<T>&&>(t);
+}
 
 #ifdef MPARK_INTEGER_SEQUENCE
-      using std::integer_sequence;
-      using std::index_sequence;
-      using std::make_index_sequence;
-      using std::index_sequence_for;
+using std::index_sequence;
+using std::index_sequence_for;
+using std::integer_sequence;
+using std::make_index_sequence;
 #else
-      template <typename T, T... Is>
-      struct integer_sequence {
-        using value_type = T;
-        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-      };
+template <typename T, T... Is>
+struct integer_sequence {
+  using value_type = T;
+  static constexpr std::size_t size() noexcept {
+    return sizeof...(Is);
+  }
+};
 
-      template <std::size_t... Is>
-      using index_sequence = integer_sequence<std::size_t, Is...>;
+template <std::size_t... Is>
+using index_sequence = integer_sequence<std::size_t, Is...>;
 
-      template <typename Lhs, typename Rhs>
-      struct make_index_sequence_concat;
+template <typename Lhs, typename Rhs>
+struct make_index_sequence_concat;
 
-      template <std::size_t... Lhs, std::size_t... Rhs>
-      struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                        index_sequence<Rhs...>>
-          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
+template <std::size_t... Lhs, std::size_t... Rhs>
+struct make_index_sequence_concat<
+    index_sequence<Lhs...>,
+    index_sequence<Rhs...>>
+    : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
 
-      template <std::size_t N>
-      struct make_index_sequence_impl;
+template <std::size_t N>
+struct make_index_sequence_impl;
 
-      template <std::size_t N>
-      using make_index_sequence = typename make_index_sequence_impl<N>::type;
+template <std::size_t N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
 
-      template <std::size_t N>
-      struct make_index_sequence_impl
-          : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                       make_index_sequence<N - (N / 2)>> {};
+template <std::size_t N>
+struct make_index_sequence_impl : make_index_sequence_concat<
+                                      make_index_sequence<N / 2>,
+                                      make_index_sequence<N - (N / 2)>> {};
 
-      template <>
-      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
+template <>
+struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
 
-      template <>
-      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
+template <>
+struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
 
-      template <typename... Ts>
-      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 #endif
 
-      // <functional>
+// <functional>
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using equal_to = std::equal_to<>;
+using equal_to = std::equal_to<>;
 #else
-      struct equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-      };
+struct equal_to {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using not_equal_to = std::not_equal_to<>;
+using not_equal_to = std::not_equal_to<>;
 #else
-      struct not_equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-      };
+struct not_equal_to {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using less = std::less<>;
+using less = std::less<>;
 #else
-      struct less {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-      };
+struct less {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater = std::greater<>;
+using greater = std::greater<>;
 #else
-      struct greater {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-      };
+struct greater {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using less_equal = std::less_equal<>;
+using less_equal = std::less_equal<>;
 #else
-      struct less_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-      };
+struct less_equal {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
+};
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater_equal = std::greater_equal<>;
+using greater_equal = std::greater_equal<>;
 #else
-      struct greater_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-      };
+struct greater_equal {
+  template <typename Lhs, typename Rhs>
+  inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const
+      MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
+};
 #endif
-    }  // namespace cpp14
+} // namespace cpp14
 
-    inline namespace cpp17 {
+inline namespace cpp17 {
 
-      // <type_traits>
-      template <bool B>
-      using bool_constant = std::integral_constant<bool, B>;
+// <type_traits>
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
 
-      template <typename...>
-      struct voider : identity<void> {};
+template <typename...>
+struct voider : identity<void> {};
 
-      template <typename... Ts>
-      using void_t = typename voider<Ts...>::type;
+template <typename... Ts>
+using void_t = typename voider<Ts...>::type;
 
-      namespace detail_ {
-        namespace swappable {
+namespace detail_ {
+namespace swappable {
 
-          using std::swap;
+using std::swap;
 
-          template <typename T>
-          struct is_swappable {
-            private:
-            template <typename U,
-                      typename = decltype(swap(std::declval<U &>(),
-                                               std::declval<U &>()))>
-            inline static std::true_type test(int);
+template <typename T>
+struct is_swappable {
+ private:
+  template <
+      typename U,
+      typename = decltype(swap(std::declval<U&>(), std::declval<U&>()))>
+  inline static std::true_type test(int);
 
-            template <typename U>
-            inline static std::false_type test(...);
+  template <typename U>
+  inline static std::false_type test(...);
 
-            public:
-            static constexpr bool value = decltype(test<T>(0))::value;
-          };
+ public:
+  static constexpr bool value = decltype(test<T>(0))::value;
+};
 
-          template <bool IsSwappable, typename T>
-          struct is_nothrow_swappable {
-            static constexpr bool value =
-                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-          };
+template <bool IsSwappable, typename T>
+struct is_nothrow_swappable {
+  static constexpr bool value =
+      noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+};
 
-          template <typename T>
-          struct is_nothrow_swappable<false, T> : std::false_type {};
+template <typename T>
+struct is_nothrow_swappable<false, T> : std::false_type {};
 
-        }  // namespace swappable
-      }  // namespace detail_
+} // namespace swappable
+} // namespace detail_
 
-      using detail_::swappable::is_swappable;
+using detail_::swappable::is_swappable;
 
-      template <typename T>
-      using is_nothrow_swappable =
-          detail_::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
+template <typename T>
+using is_nothrow_swappable =
+    detail_::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
 
-      // <functional>
-      namespace detail_ {
+// <functional>
+namespace detail_ {
 
-        template <typename T>
-        struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper : std::false_type {};
 
-        template <typename T>
-        struct is_reference_wrapper<std::reference_wrapper<T>>
-            : std::true_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
-        template <bool, int>
-        struct Invoke;
+template <bool, int>
+struct Invoke;
 
-        template <>
-        struct Invoke<true /* pmf */, 0 /* is_base_of */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
-        };
+template <>
+struct Invoke<true /* pmf */, 0 /* is_base_of */> {
+  template <typename R, typename T, typename Arg, typename... Args>
+  inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args)
+      MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
-        };
+template <>
+struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
+  template <typename R, typename T, typename Arg, typename... Args>
+  inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args)
+      MPARK_RETURN(
+          (lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<true /* pmf */, 2 /* otherwise */> {
-          template <typename R, typename T, typename Arg, typename... Args>
-          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
-            MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
-        };
+template <>
+struct Invoke<true /* pmf */, 2 /* otherwise */> {
+  template <typename R, typename T, typename Arg, typename... Args>
+  inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args)
+      MPARK_RETURN(
+          ((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 0 /* is_base_of */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-            MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
-        };
+template <>
+struct Invoke<false /* pmo */, 0 /* is_base_of */> {
+  template <typename R, typename T, typename Arg>
+  inline static constexpr auto invoke(R T::*pmo, Arg&& arg)
+      MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-            MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
-        };
+template <>
+struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
+  template <typename R, typename T, typename Arg>
+  inline static constexpr auto invoke(R T::*pmo, Arg&& arg)
+      MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
+};
 
-        template <>
-        struct Invoke<false /* pmo */, 2 /* otherwise */> {
-          template <typename R, typename T, typename Arg>
-          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-              MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
-        };
+template <>
+struct Invoke<false /* pmo */, 2 /* otherwise */> {
+  template <typename R, typename T, typename Arg>
+  inline static constexpr auto invoke(R T::*pmo, Arg&& arg)
+      MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
+};
 
-        template <typename R, typename T, typename Arg, typename... Args>
-        inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args)
-          MPARK_RETURN(
-              Invoke<std::is_function<R>::value,
-                     (std::is_base_of<T, lib::decay_t<Arg>>::value
-                          ? 0
-                          : is_reference_wrapper<lib::decay_t<Arg>>::value
-                                ? 1
-                                : 2)>::invoke(f,
-                                              lib::forward<Arg>(arg),
-                                              lib::forward<Args>(args)...))
+template <typename R, typename T, typename Arg, typename... Args>
+inline constexpr auto invoke(R T::*f, Arg&& arg, Args&&... args) MPARK_RETURN(
+    Invoke<
+        std::is_function<R>::value,
+        (std::is_base_of<T, lib::decay_t<Arg>>::value         ? 0
+             : is_reference_wrapper<lib::decay_t<Arg>>::value ? 1
+                                                              : 2)>::
+        invoke(f, lib::forward<Arg>(arg), lib::forward<Args>(args)...))
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-        template <typename F, typename... Args>
-        inline constexpr auto invoke(F &&f, Args &&... args)
-          MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
+    template <typename F, typename... Args>
+    inline constexpr auto invoke(F&& f, Args&&... args)
+        MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-      }  // namespace detail_
+} // namespace detail_
 
-      template <typename F, typename... Args>
-      inline constexpr auto invoke(F &&f, Args &&... args)
-        MPARK_RETURN(detail_::invoke(lib::forward<F>(f),
-                                    lib::forward<Args>(args)...))
+template <typename F, typename... Args>
+inline constexpr auto invoke(F&& f, Args&&... args) MPARK_RETURN(
+    detail_::invoke(lib::forward<F>(f), lib::forward<Args>(args)...))
 
-      namespace detail_ {
+    namespace detail_ {
+  template <typename Void, typename, typename...>
+  struct invoke_result {};
 
-        template <typename Void, typename, typename...>
-        struct invoke_result {};
+  template <typename F, typename... Args>
+  struct invoke_result<
+      void_t<decltype(lib::invoke(std::declval<F>(), std::declval<Args>()...))>,
+      F,
+      Args...>
+      : identity<decltype(
+            lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
 
-        template <typename F, typename... Args>
-        struct invoke_result<void_t<decltype(lib::invoke(
-                                 std::declval<F>(), std::declval<Args>()...))>,
-                             F,
-                             Args...>
-            : identity<decltype(
-                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
+} // namespace detail_
 
-      }  // namespace detail_
+template <typename F, typename... Args>
+using invoke_result = detail_::invoke_result<void, F, Args...>;
 
-      template <typename F, typename... Args>
-      using invoke_result = detail_::invoke_result<void, F, Args...>;
+template <typename F, typename... Args>
+using invoke_result_t = typename invoke_result<F, Args...>::type;
 
-      template <typename F, typename... Args>
-      using invoke_result_t = typename invoke_result<F, Args...>::type;
+namespace detail_ {
 
-      namespace detail_ {
+template <typename Void, typename, typename...>
+struct is_invocable : std::false_type {};
 
-        template <typename Void, typename, typename...>
-        struct is_invocable : std::false_type {};
+template <typename F, typename... Args>
+struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
+    : std::true_type {};
 
-        template <typename F, typename... Args>
-        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-            : std::true_type {};
+template <typename Void, typename, typename, typename...>
+struct is_invocable_r : std::false_type {};
 
-        template <typename Void, typename, typename, typename...>
-        struct is_invocable_r : std::false_type {};
+template <typename R, typename F, typename... Args>
+struct is_invocable_r<void_t<invoke_result_t<F, Args...>>, R, F, Args...>
+    : std::is_convertible<invoke_result_t<F, Args...>, R> {};
 
-        template <typename R, typename F, typename... Args>
-        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
-                              R,
-                              F,
-                              Args...>
-            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
+} // namespace detail_
 
-      }  // namespace detail_
+template <typename F, typename... Args>
+using is_invocable = detail_::is_invocable<void, F, Args...>;
 
-      template <typename F, typename... Args>
-      using is_invocable = detail_::is_invocable<void, F, Args...>;
+template <typename R, typename F, typename... Args>
+using is_invocable_r = detail_::is_invocable_r<void, R, F, Args...>;
 
-      template <typename R, typename F, typename... Args>
-      using is_invocable_r = detail_::is_invocable_r<void, R, F, Args...>;
+namespace detail_ {
 
-      namespace detail_ {
+template <bool Invocable, typename F, typename... Args>
+struct is_nothrow_invocable {
+  static constexpr bool value =
+      noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
+};
 
-        template <bool Invocable, typename F, typename... Args>
-        struct is_nothrow_invocable {
-          static constexpr bool value =
-              noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
-        };
+template <typename F, typename... Args>
+struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
 
-        template <typename F, typename... Args>
-        struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
+template <bool Invocable, typename R, typename F, typename... Args>
+struct is_nothrow_invocable_r {
+ private:
+  inline static R impl() {
+    return lib::invoke(std::declval<F>(), std::declval<Args>()...);
+  }
 
-        template <bool Invocable, typename R, typename F, typename... Args>
-        struct is_nothrow_invocable_r {
-          private:
-          inline static R impl() {
-            return lib::invoke(std::declval<F>(), std::declval<Args>()...);
-          }
+ public:
+  static constexpr bool value = noexcept(impl());
+};
 
-          public:
-          static constexpr bool value = noexcept(impl());
-        };
+template <typename R, typename F, typename... Args>
+struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
 
-        template <typename R, typename F, typename... Args>
-        struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
+} // namespace detail_
 
-      }  // namespace detail_
+template <typename F, typename... Args>
+using is_nothrow_invocable =
+    detail_::is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
 
-      template <typename F, typename... Args>
-      using is_nothrow_invocable = detail_::
-          is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
+template <typename R, typename F, typename... Args>
+using is_nothrow_invocable_r = detail_::
+    is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value, R, F, Args...>;
 
-      template <typename R, typename F, typename... Args>
-      using is_nothrow_invocable_r =
-          detail_::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value,
-                                         R,
-                                         F,
-                                         Args...>;
-
-      // <memory>
+// <memory>
 #ifdef MPARK_BUILTIN_ADDRESSOF
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return __builtin_addressof(arg);
-      }
+template <typename T>
+inline constexpr T* addressof(T& arg) noexcept {
+  return __builtin_addressof(arg);
+}
 #else
-      namespace detail_ {
+namespace detail_ {
 
-        namespace has_addressof_impl {
+namespace has_addressof_impl {
 
-          struct fail;
+struct fail;
 
-          template <typename T>
-          inline fail operator&(T &&);
+template <typename T>
+inline fail operator&(T&&);
 
-          template <typename T>
-          inline static constexpr bool impl() {
-            return (std::is_class<T>::value || std::is_union<T>::value) &&
-                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-          }
+template <typename T>
+inline static constexpr bool impl() {
+  return (std::is_class<T>::value || std::is_union<T>::value) &&
+      !std::is_same<decltype(&std::declval<T&>()), fail>::value;
+}
 
-        }  // namespace has_addressof_impl
+} // namespace has_addressof_impl
 
-        template <typename T>
-        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
+template <typename T>
+using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
 
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::true_type) noexcept {
-          return std::addressof(arg);
-        }
+template <typename T>
+inline constexpr T* addressof(T& arg, std::true_type) noexcept {
+  return std::addressof(arg);
+}
 
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::false_type) noexcept {
-          return &arg;
-        }
+template <typename T>
+inline constexpr T* addressof(T& arg, std::false_type) noexcept {
+  return &arg;
+}
 
-      }  // namespace detail_
+} // namespace detail_
 
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return detail_::addressof(arg, detail_::has_addressof<T>{});
-      }
+template <typename T>
+inline constexpr T* addressof(T& arg) noexcept {
+  return detail_::addressof(arg, detail_::has_addressof<T>{});
+}
 #endif
 
-      template <typename T>
-      inline constexpr T *addressof(const T &&) = delete;
+template <typename T>
+inline constexpr T* addressof(const T&&) = delete;
 
-    }  // namespace cpp17
+} // namespace cpp17
 
-    template <typename T>
-    struct remove_all_extents : identity<T> {};
+template <typename T>
+struct remove_all_extents : identity<T> {};
 
-    template <typename T, std::size_t N>
-    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
+template <typename T, std::size_t N>
+struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
 
-    template <typename T>
-    using remove_all_extents_t = typename remove_all_extents<T>::type;
+template <typename T>
+using remove_all_extents_t = typename remove_all_extents<T>::type;
 
-    template <std::size_t N>
-    using size_constant = std::integral_constant<std::size_t, N>;
+template <std::size_t N>
+using size_constant = std::integral_constant<std::size_t, N>;
 
-    template <std::size_t I, typename T>
-    struct indexed_type : size_constant<I> { using type = T; };
+template <std::size_t I, typename T>
+struct indexed_type : size_constant<I> {
+  using type = T;
+};
 
-    template <bool... Bs>
-    using all = std::is_same<integer_sequence<bool, true, Bs...>,
-                             integer_sequence<bool, Bs..., true>>;
+template <bool... Bs>
+using all = std::is_same<
+    integer_sequence<bool, true, Bs...>,
+    integer_sequence<bool, Bs..., true>>;
 
 #ifdef MPARK_TYPE_PACK_ELEMENT
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = __type_pack_element<I, Ts...>;
+template <std::size_t I, typename... Ts>
+using type_pack_element_t = __type_pack_element<I, Ts...>;
 #else
-    template <std::size_t I, typename... Ts>
-    struct type_pack_element_impl {
-      private:
-      template <typename>
-      struct set;
+template <std::size_t I, typename... Ts>
+struct type_pack_element_impl {
+ private:
+  template <typename>
+  struct set;
 
-      template <std::size_t... Is>
-      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
+  template <std::size_t... Is>
+  struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
 
-      template <typename T>
-      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
+  template <typename T>
+  inline static std::enable_if<true, T> impl(indexed_type<I, T>);
 
-      inline static std::enable_if<false> impl(...);
+  inline static std::enable_if<false> impl(...);
 
-      public:
-      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-    };
+ public:
+  using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
+};
 
-    template <std::size_t I, typename... Ts>
-    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
+template <std::size_t I, typename... Ts>
+using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
 
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
+template <std::size_t I, typename... Ts>
+using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
 #endif
 
 #ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-    using std::is_trivially_copy_constructible;
-    using std::is_trivially_move_constructible;
-    using std::is_trivially_copy_assignable;
-    using std::is_trivially_move_assignable;
+using std::is_trivially_copy_assignable;
+using std::is_trivially_copy_constructible;
+using std::is_trivially_move_assignable;
+using std::is_trivially_move_constructible;
 #else
-    template <typename T>
-    struct is_trivially_copy_constructible
-        : bool_constant<
-              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
+template <typename T>
+struct is_trivially_copy_constructible
+    : bool_constant<std::is_copy_constructible<T>::value&& __has_trivial_copy(
+          T)> {};
 
-    template <typename T>
-    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
+template <typename T>
+struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
 
-    template <typename T>
-    struct is_trivially_copy_assignable
-        : bool_constant<
-              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
+template <typename T>
+struct is_trivially_copy_assignable
+    : bool_constant<std::is_copy_assignable<T>::value&& __has_trivial_assign(
+          T)> {};
 
-    template <typename T>
-    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
+template <typename T>
+struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
 #endif
 
-    template <typename T, bool>
-    struct dependent_type : T {};
+template <typename T, bool>
+struct dependent_type : T {};
 
-    template <typename Is, std::size_t J>
-    struct push_back;
+template <typename Is, std::size_t J>
+struct push_back;
 
-    template <typename Is, std::size_t J>
-    using push_back_t = typename push_back<Is, J>::type;
+template <typename Is, std::size_t J>
+using push_back_t = typename push_back<Is, J>::type;
 
-    template <std::size_t... Is, std::size_t J>
-    struct push_back<index_sequence<Is...>, J> {
-      using type = index_sequence<Is..., J>;
-    };
+template <std::size_t... Is, std::size_t J>
+struct push_back<index_sequence<Is...>, J> {
+  using type = index_sequence<Is..., J>;
+};
 
-  }  // namespace lib
-}  // namespace c10
+} // namespace lib
+} // namespace c10
 
 #undef MPARK_RETURN
 
-#endif  // MPARK_LIB_HPP
-
+#endif // MPARK_LIB_HPP
 
 namespace c10 {
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
 
 #define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
+#define AUTO_RETURN(...) \
+  { return __VA_ARGS__; }
 
-#define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
+#define AUTO_REFREF auto&&
+#define AUTO_REFREF_RETURN(...) \
+  { return __VA_ARGS__; }
 
 #define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
+#define DECLTYPE_AUTO_RETURN(...) \
+  { return __VA_ARGS__; }
 
 #else
 
 #define AUTO auto
-#define AUTO_RETURN(...) \
-  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
+#define AUTO_RETURN(...)                  \
+  ->lib::decay_t<decltype(__VA_ARGS__)> { \
+    return __VA_ARGS__;                   \
+  }
 
 #define AUTO_REFREF auto
 #define AUTO_REFREF_RETURN(...)                                           \
-  -> decltype((__VA_ARGS__)) {                                            \
+  ->decltype((__VA_ARGS__)) {                                             \
     static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
     return __VA_ARGS__;                                                   \
   }
 
 #define DECLTYPE_AUTO auto
 #define DECLTYPE_AUTO_RETURN(...) \
-  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-#endif
-
-  class bad_variant_access : public std::exception {
-    public:
-    virtual const char *what() const noexcept override { return "bad_variant_access"; }
-  };
-
-  [[noreturn]] inline void throw_bad_variant_access() {
-#ifdef MPARK_EXCEPTIONS
-    throw bad_variant_access{};
-#else
-    std::terminate();
-    MPARK_BUILTIN_UNREACHABLE;
-#endif
+  ->decltype(__VA_ARGS__) {       \
+    return __VA_ARGS__;           \
   }
 
-  template <typename... Ts>
-  class variant;
+#endif
 
-  template <typename T>
-  struct variant_size;
+class bad_variant_access : public std::exception {
+ public:
+  virtual const char* what() const noexcept override {
+    return "bad_variant_access";
+  }
+};
+
+[[noreturn]] inline void throw_bad_variant_access() {
+#ifdef MPARK_EXCEPTIONS
+  throw bad_variant_access{};
+#else
+  std::terminate();
+  MPARK_BUILTIN_UNREACHABLE;
+#endif
+}
+
+template <typename... Ts>
+class variant;
+
+template <typename T>
+struct variant_size;
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-  template <typename T>
-  constexpr std::size_t variant_size_v = variant_size<T>::value;
+template <typename T>
+constexpr std::size_t variant_size_v = variant_size<T>::value;
 #endif
 
-  template <typename T>
-  struct variant_size<const T> : variant_size<T> {};
+template <typename T>
+struct variant_size<const T> : variant_size<T> {};
 
-  template <typename T>
-  struct variant_size<volatile T> : variant_size<T> {};
+template <typename T>
+struct variant_size<volatile T> : variant_size<T> {};
 
-  template <typename T>
-  struct variant_size<const volatile T> : variant_size<T> {};
+template <typename T>
+struct variant_size<const volatile T> : variant_size<T> {};
 
-  template <typename... Ts>
-  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
+template <typename... Ts>
+struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative;
+template <std::size_t I, typename T>
+struct variant_alternative;
 
-  template <std::size_t I, typename T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
+template <std::size_t I, typename T>
+using variant_alternative_t = typename variant_alternative<I, T>::type;
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const T>
-      : std::add_const<variant_alternative_t<I, T>> {};
+template <std::size_t I, typename T>
+struct variant_alternative<I, const T>
+    : std::add_const<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, volatile T>
-      : std::add_volatile<variant_alternative_t<I, T>> {};
+template <std::size_t I, typename T>
+struct variant_alternative<I, volatile T>
+    : std::add_volatile<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const volatile T>
-      : std::add_cv<variant_alternative_t<I, T>> {};
+template <std::size_t I, typename T>
+struct variant_alternative<I, const volatile T>
+    : std::add_cv<variant_alternative_t<I, T>> {};
 
-  template <std::size_t I, typename... Ts>
-  struct variant_alternative<I, variant<Ts...>> {
-    static_assert(I < sizeof...(Ts),
-                  "index out of bounds in `std::variant_alternative<>`");
-    using type = lib::type_pack_element_t<I, Ts...>;
+template <std::size_t I, typename... Ts>
+struct variant_alternative<I, variant<Ts...>> {
+  static_assert(
+      I < sizeof...(Ts),
+      "index out of bounds in `std::variant_alternative<>`");
+  using type = lib::type_pack_element_t<I, Ts...>;
+};
+
+constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
+
+namespace detail_ {
+
+constexpr std::size_t not_found = static_cast<std::size_t>(-1);
+constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
+
+#ifdef MPARK_CPP14_CONSTEXPR
+template <typename T, typename... Ts>
+inline constexpr std::size_t find_index() {
+  constexpr lib::array<bool, sizeof...(Ts)> matches = {
+      {std::is_same<T, Ts>::value...}};
+  std::size_t result = not_found;
+  for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
+    if (matches[i]) {
+      if (result != not_found) {
+        return ambiguous;
+      }
+      result = i;
+    }
+  }
+  return result;
+}
+#else
+inline constexpr std::size_t find_index_impl(std::size_t result, std::size_t) {
+  return result;
+}
+
+template <typename... Bs>
+inline constexpr std::size_t find_index_impl(
+    std::size_t result,
+    std::size_t idx,
+    bool b,
+    Bs... bs) {
+  return b
+      ? (result != not_found ? ambiguous : find_index_impl(idx, idx + 1, bs...))
+      : find_index_impl(result, idx + 1, bs...);
+}
+
+template <typename T, typename... Ts>
+inline constexpr std::size_t find_index() {
+  return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
+}
+#endif
+
+template <std::size_t I>
+using find_index_sfinae_impl =
+    lib::enable_if_t<I != not_found && I != ambiguous, lib::size_constant<I>>;
+
+template <typename T, typename... Ts>
+using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
+
+template <std::size_t I>
+struct find_index_checked_impl : lib::size_constant<I> {
+  static_assert(I != not_found, "the specified type is not found.");
+  static_assert(I != ambiguous, "the specified type is ambiguous.");
+};
+
+template <typename T, typename... Ts>
+using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
+
+struct valueless_t {};
+
+enum class Trait { TriviallyAvailable, Available, Unavailable };
+
+template <
+    typename T,
+    template <typename>
+    class IsTriviallyAvailable,
+    template <typename>
+    class IsAvailable>
+inline constexpr Trait trait() {
+  return IsTriviallyAvailable<T>::value ? Trait::TriviallyAvailable
+      : IsAvailable<T>::value           ? Trait::Available
+                                        : Trait::Unavailable;
+}
+
+#ifdef MPARK_CPP14_CONSTEXPR
+template <typename... Traits>
+inline constexpr Trait common_trait(Traits... traits_) {
+  Trait result = Trait::TriviallyAvailable;
+  lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
+  for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
+    Trait t = traits[i];
+    if (static_cast<int>(t) > static_cast<int>(result)) {
+      result = t;
+    }
+  }
+  return result;
+}
+#else
+inline constexpr Trait common_trait_impl(Trait result) {
+  return result;
+}
+
+template <typename... Traits>
+inline constexpr Trait common_trait_impl(Trait result, Trait t, Traits... ts) {
+  return static_cast<int>(t) > static_cast<int>(result)
+      ? common_trait_impl(t, ts...)
+      : common_trait_impl(result, ts...);
+}
+
+template <typename... Traits>
+inline constexpr Trait common_trait(Traits... ts) {
+  return common_trait_impl(Trait::TriviallyAvailable, ts...);
+}
+#endif
+
+template <typename... Ts>
+struct traits {
+  static constexpr Trait copy_constructible_trait =
+      common_trait(trait<
+                   Ts,
+                   lib::is_trivially_copy_constructible,
+                   std::is_copy_constructible>()...);
+
+  static constexpr Trait move_constructible_trait =
+      common_trait(trait<
+                   Ts,
+                   lib::is_trivially_move_constructible,
+                   std::is_move_constructible>()...);
+
+  static constexpr Trait copy_assignable_trait = common_trait(
+      copy_constructible_trait,
+      trait<
+          Ts,
+          lib::is_trivially_copy_assignable,
+          std::is_copy_assignable>()...);
+
+  static constexpr Trait move_assignable_trait = common_trait(
+      move_constructible_trait,
+      trait<
+          Ts,
+          lib::is_trivially_move_assignable,
+          std::is_move_assignable>()...);
+
+  static constexpr Trait destructible_trait = common_trait(
+      trait<Ts, std::is_trivially_destructible, std::is_destructible>()...);
+};
+
+namespace access {
+
+struct recursive_union {
+#ifdef MPARK_RETURN_TYPE_DEDUCTION
+  template <typename V>
+  inline static constexpr auto&& get_alt(V&& v, in_place_index_t<0>) {
+    return lib::forward<V>(v).head_;
+  }
+
+  template <typename V, std::size_t I>
+  inline static constexpr auto&& get_alt(V&& v, in_place_index_t<I>) {
+    return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
+  }
+#else
+  template <std::size_t I, bool Dummy = true>
+  struct get_alt_impl {
+    template <typename V>
+    inline constexpr AUTO_REFREF operator()(V&& v) const
+        AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
   };
 
-  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
+  template <bool Dummy>
+  struct get_alt_impl<0, Dummy> {
+    template <typename V>
+    inline constexpr AUTO_REFREF operator()(V&& v) const
+        AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
+  };
 
-  namespace detail_ {
-
-    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      constexpr lib::array<bool, sizeof...(Ts)> matches = {
-          {std::is_same<T, Ts>::value...}
-      };
-      std::size_t result = not_found;
-      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
-        if (matches[i]) {
-          if (result != not_found) {
-            return ambiguous;
-          }
-          result = i;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t) {
-      return result;
-    }
-
-    template <typename... Bs>
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t idx,
-                                                 bool b,
-                                                 Bs... bs) {
-      return b ? (result != not_found ? ambiguous
-                                      : find_index_impl(idx, idx + 1, bs...))
-               : find_index_impl(result, idx + 1, bs...);
-    }
-
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-    }
+  template <typename V, std::size_t I>
+  inline static constexpr AUTO_REFREF get_alt(V&& v, in_place_index_t<I>)
+      AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
 #endif
+};
 
-    template <std::size_t I>
-    using find_index_sfinae_impl =
-        lib::enable_if_t<I != not_found && I != ambiguous,
-                         lib::size_constant<I>>;
-
-    template <typename T, typename... Ts>
-    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
-
-    template <std::size_t I>
-    struct find_index_checked_impl : lib::size_constant<I> {
-      static_assert(I != not_found, "the specified type is not found.");
-      static_assert(I != ambiguous, "the specified type is ambiguous.");
-    };
-
-    template <typename T, typename... Ts>
-    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
-
-    struct valueless_t {};
-
-    enum class Trait { TriviallyAvailable, Available, Unavailable };
-
-    template <typename T,
-              template <typename> class IsTriviallyAvailable,
-              template <typename> class IsAvailable>
-    inline constexpr Trait trait() {
-      return IsTriviallyAvailable<T>::value
-                 ? Trait::TriviallyAvailable
-                 : IsAvailable<T>::value ? Trait::Available
-                                         : Trait::Unavailable;
-    }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... traits_) {
-      Trait result = Trait::TriviallyAvailable;
-      lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
-      for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
-        Trait t = traits[i];
-        if (static_cast<int>(t) > static_cast<int>(result)) {
-          result = t;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr Trait common_trait_impl(Trait result) { return result; }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait_impl(Trait result,
-                                             Trait t,
-                                             Traits... ts) {
-      return static_cast<int>(t) > static_cast<int>(result)
-                 ? common_trait_impl(t, ts...)
-                 : common_trait_impl(result, ts...);
-    }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... ts) {
-      return common_trait_impl(Trait::TriviallyAvailable, ts...);
-    }
-#endif
-
-    template <typename... Ts>
-    struct traits {
-      static constexpr Trait copy_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_copy_constructible,
-                             std::is_copy_constructible>()...);
-
-      static constexpr Trait move_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_move_constructible,
-                             std::is_move_constructible>()...);
-
-      static constexpr Trait copy_assignable_trait =
-          common_trait(copy_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_copy_assignable,
-                             std::is_copy_assignable>()...);
-
-      static constexpr Trait move_assignable_trait =
-          common_trait(move_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_move_assignable,
-                             std::is_move_assignable>()...);
-
-      static constexpr Trait destructible_trait =
-          common_trait(trait<Ts,
-                             std::is_trivially_destructible,
-                             std::is_destructible>()...);
-    };
-
-    namespace access {
-
-      struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename V>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
-          return lib::forward<V>(v).head_;
-        }
-
-        template <typename V, std::size_t I>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
-          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-        }
-#else
-        template <std::size_t I, bool Dummy = true>
-        struct get_alt_impl {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-        };
-
-        template <bool Dummy>
-        struct get_alt_impl<0, Dummy> {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-        };
-
-        template <typename V, std::size_t I>
-        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
-#endif
-      };
-
-      struct base {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
+struct base {
+  template <std::size_t I, typename V>
+  inline static constexpr AUTO_REFREF get_alt(V&& v)
 #ifdef _MSC_VER
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              lib::forward<V>(v).data_, in_place_index_t<I>{}))
+      AUTO_REFREF_RETURN(recursive_union::get_alt(
+          lib::forward<V>(v).data_,
+          in_place_index_t<I>{}))
 #else
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              data(lib::forward<V>(v)), in_place_index_t<I>{}))
+      AUTO_REFREF_RETURN(recursive_union::get_alt(
+          data(lib::forward<V>(v)),
+          in_place_index_t<I>{}))
 #endif
-      };
+};
 
-      struct variant {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-      };
+struct variant {
+  template <std::size_t I, typename V>
+  inline static constexpr AUTO_REFREF get_alt(V&& v)
+      AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
+};
 
-    }  // namespace access
+} // namespace access
 
-    namespace visitation {
+namespace visitation {
 
 #if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER)
 #define MPARK_VARIANT_SWITCH_VISIT
 #endif
 
-      struct base {
-        template <typename Visitor, typename... Vs>
-        using dispatch_result_t = decltype(
-            lib::invoke(std::declval<Visitor>(),
-                        access::base::get_alt<0>(std::declval<Vs>())...));
+struct base {
+  template <typename Visitor, typename... Vs>
+  using dispatch_result_t = decltype(lib::invoke(
+      std::declval<Visitor>(),
+      access::base::get_alt<0>(std::declval<Vs>())...));
 
-        template <typename Expected>
-        struct expected {
-          template <typename Actual>
-          inline static constexpr bool but_got() {
-            return std::is_same<Expected, Actual>::value;
-          }
-        };
+  template <typename Expected>
+  struct expected {
+    template <typename Actual>
+    inline static constexpr bool but_got() {
+      return std::is_same<Expected, Actual>::value;
+    }
+  };
 
-        template <typename Expected, typename Actual>
-        struct visit_return_type_check {
-          static_assert(
-              expected<Expected>::template but_got<Actual>(),
-              "`visit` requires the visitor to have a single return type");
+  template <typename Expected, typename Actual>
+  struct visit_return_type_check {
+    static_assert(
+        expected<Expected>::template but_got<Actual>(),
+        "`visit` requires the visitor to have a single return type");
 
-          template <typename Visitor, typename... Alts>
-          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                       Alts &&... alts)
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Alts>(alts)...))
-        };
+    template <typename Visitor, typename... Alts>
+    inline static constexpr DECLTYPE_AUTO invoke(
+        Visitor&& visitor,
+        Alts&&... alts)
+        DECLTYPE_AUTO_RETURN(lib::invoke(
+            lib::forward<Visitor>(visitor),
+            lib::forward<Alts>(alts)...))
+  };
 
 #ifdef MPARK_VARIANT_SWITCH_VISIT
-        template <bool B, typename R, typename... ITs>
-        struct dispatcher;
+  template <bool B, typename R, typename... ITs>
+  struct dispatcher;
 
-        template <typename R, typename... ITs>
-        struct dispatcher<false, R, ITs...> {
-          template <std::size_t B, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&, typename ITs::type &&..., Vs &&...) {
-            MPARK_BUILTIN_UNREACHABLE;
-          }
+  template <typename R, typename... ITs>
+  struct dispatcher<false, R, ITs...> {
+    template <std::size_t B, typename F, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch(
+        F&&,
+        typename ITs::type&&...,
+        Vs&&...) {
+      MPARK_BUILTIN_UNREACHABLE;
+    }
 
-          template <std::size_t I, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) {
-            MPARK_BUILTIN_UNREACHABLE;
-          }
+    template <std::size_t I, typename F, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F&&, Vs&&...) {
+      MPARK_BUILTIN_UNREACHABLE;
+    }
 
-          template <std::size_t B, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t,
-                                                             F &&,
-                                                             Vs &&...) {
-            MPARK_BUILTIN_UNREACHABLE;
-          }
-        };
+    template <std::size_t B, typename F, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch_at(
+        std::size_t,
+        F&&,
+        Vs&&...) {
+      MPARK_BUILTIN_UNREACHABLE;
+    }
+  };
 
-        template <typename R, typename... ITs>
-        struct dispatcher<true, R, ITs...> {
-          template <std::size_t B, typename F>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&f, typename ITs::type &&... visited_vs) {
-            using Expected = R;
-            using Actual = decltype(lib::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<ITs::value>(
-                    lib::forward<typename ITs::type>(visited_vs))...));
-            return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<ITs::value>(
-                    lib::forward<typename ITs::type>(visited_vs))...);
-          }
+  template <typename R, typename... ITs>
+  struct dispatcher<true, R, ITs...> {
+    template <std::size_t B, typename F>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch(
+        F&& f,
+        typename ITs::type&&... visited_vs) {
+      using Expected = R;
+      using Actual = decltype(lib::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<ITs::value>(
+              lib::forward<typename ITs::type>(visited_vs))...));
+      return visit_return_type_check<Expected, Actual>::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<ITs::value>(
+              lib::forward<typename ITs::type>(visited_vs))...);
+    }
 
-          template <std::size_t B, typename F, typename V, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch(
-              F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) {
-#define MPARK_DISPATCH(I)                                                   \
-  dispatcher<(I < lib::decay_t<V>::size()),                                 \
-             R,                                                             \
-             ITs...,                                                        \
-             lib::indexed_type<I, V>>::                                     \
-      template dispatch<0>(lib::forward<F>(f),                              \
-                           lib::forward<typename ITs::type>(visited_vs)..., \
-                           lib::forward<V>(v),                              \
-                           lib::forward<Vs>(vs)...)
+    template <std::size_t B, typename F, typename V, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch(
+        F&& f,
+        typename ITs::type&&... visited_vs,
+        V&& v,
+        Vs&&... vs) {
+#define MPARK_DISPATCH(I)                                  \
+  dispatcher<                                              \
+      (I < lib::decay_t<V>::size()),                       \
+      R,                                                   \
+      ITs...,                                              \
+      lib::indexed_type<I, V>>::                           \
+      template dispatch<0>(                                \
+          lib::forward<F>(f),                              \
+          lib::forward<typename ITs::type>(visited_vs)..., \
+          lib::forward<V>(v),                              \
+          lib::forward<Vs>(vs)...)
 
 #define MPARK_DEFAULT(I)                                                      \
   dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>( \
@@ -1268,66 +1297,100 @@ namespace c10 {
       lib::forward<V>(v),                                                     \
       lib::forward<Vs>(vs)...)
 
-            switch (v.index()) {
-              case B + 0: return MPARK_DISPATCH(B + 0);
-              case B + 1: return MPARK_DISPATCH(B + 1);
-              case B + 2: return MPARK_DISPATCH(B + 2);
-              case B + 3: return MPARK_DISPATCH(B + 3);
-              case B + 4: return MPARK_DISPATCH(B + 4);
-              case B + 5: return MPARK_DISPATCH(B + 5);
-              case B + 6: return MPARK_DISPATCH(B + 6);
-              case B + 7: return MPARK_DISPATCH(B + 7);
-              case B + 8: return MPARK_DISPATCH(B + 8);
-              case B + 9: return MPARK_DISPATCH(B + 9);
-              case B + 10: return MPARK_DISPATCH(B + 10);
-              case B + 11: return MPARK_DISPATCH(B + 11);
-              case B + 12: return MPARK_DISPATCH(B + 12);
-              case B + 13: return MPARK_DISPATCH(B + 13);
-              case B + 14: return MPARK_DISPATCH(B + 14);
-              case B + 15: return MPARK_DISPATCH(B + 15);
-              case B + 16: return MPARK_DISPATCH(B + 16);
-              case B + 17: return MPARK_DISPATCH(B + 17);
-              case B + 18: return MPARK_DISPATCH(B + 18);
-              case B + 19: return MPARK_DISPATCH(B + 19);
-              case B + 20: return MPARK_DISPATCH(B + 20);
-              case B + 21: return MPARK_DISPATCH(B + 21);
-              case B + 22: return MPARK_DISPATCH(B + 22);
-              case B + 23: return MPARK_DISPATCH(B + 23);
-              case B + 24: return MPARK_DISPATCH(B + 24);
-              case B + 25: return MPARK_DISPATCH(B + 25);
-              case B + 26: return MPARK_DISPATCH(B + 26);
-              case B + 27: return MPARK_DISPATCH(B + 27);
-              case B + 28: return MPARK_DISPATCH(B + 28);
-              case B + 29: return MPARK_DISPATCH(B + 29);
-              case B + 30: return MPARK_DISPATCH(B + 30);
-              case B + 31: return MPARK_DISPATCH(B + 31);
-              default: return MPARK_DEFAULT(B + 32);
-            }
+      switch (v.index()) {
+        case B + 0:
+          return MPARK_DISPATCH(B + 0);
+        case B + 1:
+          return MPARK_DISPATCH(B + 1);
+        case B + 2:
+          return MPARK_DISPATCH(B + 2);
+        case B + 3:
+          return MPARK_DISPATCH(B + 3);
+        case B + 4:
+          return MPARK_DISPATCH(B + 4);
+        case B + 5:
+          return MPARK_DISPATCH(B + 5);
+        case B + 6:
+          return MPARK_DISPATCH(B + 6);
+        case B + 7:
+          return MPARK_DISPATCH(B + 7);
+        case B + 8:
+          return MPARK_DISPATCH(B + 8);
+        case B + 9:
+          return MPARK_DISPATCH(B + 9);
+        case B + 10:
+          return MPARK_DISPATCH(B + 10);
+        case B + 11:
+          return MPARK_DISPATCH(B + 11);
+        case B + 12:
+          return MPARK_DISPATCH(B + 12);
+        case B + 13:
+          return MPARK_DISPATCH(B + 13);
+        case B + 14:
+          return MPARK_DISPATCH(B + 14);
+        case B + 15:
+          return MPARK_DISPATCH(B + 15);
+        case B + 16:
+          return MPARK_DISPATCH(B + 16);
+        case B + 17:
+          return MPARK_DISPATCH(B + 17);
+        case B + 18:
+          return MPARK_DISPATCH(B + 18);
+        case B + 19:
+          return MPARK_DISPATCH(B + 19);
+        case B + 20:
+          return MPARK_DISPATCH(B + 20);
+        case B + 21:
+          return MPARK_DISPATCH(B + 21);
+        case B + 22:
+          return MPARK_DISPATCH(B + 22);
+        case B + 23:
+          return MPARK_DISPATCH(B + 23);
+        case B + 24:
+          return MPARK_DISPATCH(B + 24);
+        case B + 25:
+          return MPARK_DISPATCH(B + 25);
+        case B + 26:
+          return MPARK_DISPATCH(B + 26);
+        case B + 27:
+          return MPARK_DISPATCH(B + 27);
+        case B + 28:
+          return MPARK_DISPATCH(B + 28);
+        case B + 29:
+          return MPARK_DISPATCH(B + 29);
+        case B + 30:
+          return MPARK_DISPATCH(B + 30);
+        case B + 31:
+          return MPARK_DISPATCH(B + 31);
+        default:
+          return MPARK_DEFAULT(B + 32);
+      }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH
-          }
+    }
 
-          template <std::size_t I, typename F, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f,
-                                                               Vs &&... vs) {
-            using Expected = R;
-            using Actual = decltype(
-                lib::invoke(lib::forward<F>(f),
-                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
-            return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-          }
+    template <std::size_t I, typename F, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F&& f, Vs&&... vs) {
+      using Expected = R;
+      using Actual = decltype(lib::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+      return visit_return_type_check<Expected, Actual>::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<I>(lib::forward<Vs>(vs))...);
+    }
 
-          template <std::size_t B, typename F, typename V, typename... Vs>
-          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index,
-                                                             F &&f,
-                                                             V &&v,
-                                                             Vs &&... vs) {
-            static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                    lib::decay_t<Vs>::size())...>::value,
-                          "all of the variants must be the same size.");
+    template <std::size_t B, typename F, typename V, typename... Vs>
+    MPARK_ALWAYS_INLINE static constexpr R dispatch_at(
+        std::size_t index,
+        F&& f,
+        V&& v,
+        Vs&&... vs) {
+      static_assert(
+          lib::all<(
+              lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...>::value,
+          "all of the variants must be the same size.");
 #define MPARK_DISPATCH_AT(I)                                               \
   dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>( \
       lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
@@ -1336,365 +1399,408 @@ namespace c10 {
   dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>( \
       index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
 
-            switch (index) {
-              case B + 0: return MPARK_DISPATCH_AT(B + 0);
-              case B + 1: return MPARK_DISPATCH_AT(B + 1);
-              case B + 2: return MPARK_DISPATCH_AT(B + 2);
-              case B + 3: return MPARK_DISPATCH_AT(B + 3);
-              case B + 4: return MPARK_DISPATCH_AT(B + 4);
-              case B + 5: return MPARK_DISPATCH_AT(B + 5);
-              case B + 6: return MPARK_DISPATCH_AT(B + 6);
-              case B + 7: return MPARK_DISPATCH_AT(B + 7);
-              case B + 8: return MPARK_DISPATCH_AT(B + 8);
-              case B + 9: return MPARK_DISPATCH_AT(B + 9);
-              case B + 10: return MPARK_DISPATCH_AT(B + 10);
-              case B + 11: return MPARK_DISPATCH_AT(B + 11);
-              case B + 12: return MPARK_DISPATCH_AT(B + 12);
-              case B + 13: return MPARK_DISPATCH_AT(B + 13);
-              case B + 14: return MPARK_DISPATCH_AT(B + 14);
-              case B + 15: return MPARK_DISPATCH_AT(B + 15);
-              case B + 16: return MPARK_DISPATCH_AT(B + 16);
-              case B + 17: return MPARK_DISPATCH_AT(B + 17);
-              case B + 18: return MPARK_DISPATCH_AT(B + 18);
-              case B + 19: return MPARK_DISPATCH_AT(B + 19);
-              case B + 20: return MPARK_DISPATCH_AT(B + 20);
-              case B + 21: return MPARK_DISPATCH_AT(B + 21);
-              case B + 22: return MPARK_DISPATCH_AT(B + 22);
-              case B + 23: return MPARK_DISPATCH_AT(B + 23);
-              case B + 24: return MPARK_DISPATCH_AT(B + 24);
-              case B + 25: return MPARK_DISPATCH_AT(B + 25);
-              case B + 26: return MPARK_DISPATCH_AT(B + 26);
-              case B + 27: return MPARK_DISPATCH_AT(B + 27);
-              case B + 28: return MPARK_DISPATCH_AT(B + 28);
-              case B + 29: return MPARK_DISPATCH_AT(B + 29);
-              case B + 30: return MPARK_DISPATCH_AT(B + 30);
-              case B + 31: return MPARK_DISPATCH_AT(B + 31);
-              default: return MPARK_DEFAULT(B + 32);
-            }
+      switch (index) {
+        case B + 0:
+          return MPARK_DISPATCH_AT(B + 0);
+        case B + 1:
+          return MPARK_DISPATCH_AT(B + 1);
+        case B + 2:
+          return MPARK_DISPATCH_AT(B + 2);
+        case B + 3:
+          return MPARK_DISPATCH_AT(B + 3);
+        case B + 4:
+          return MPARK_DISPATCH_AT(B + 4);
+        case B + 5:
+          return MPARK_DISPATCH_AT(B + 5);
+        case B + 6:
+          return MPARK_DISPATCH_AT(B + 6);
+        case B + 7:
+          return MPARK_DISPATCH_AT(B + 7);
+        case B + 8:
+          return MPARK_DISPATCH_AT(B + 8);
+        case B + 9:
+          return MPARK_DISPATCH_AT(B + 9);
+        case B + 10:
+          return MPARK_DISPATCH_AT(B + 10);
+        case B + 11:
+          return MPARK_DISPATCH_AT(B + 11);
+        case B + 12:
+          return MPARK_DISPATCH_AT(B + 12);
+        case B + 13:
+          return MPARK_DISPATCH_AT(B + 13);
+        case B + 14:
+          return MPARK_DISPATCH_AT(B + 14);
+        case B + 15:
+          return MPARK_DISPATCH_AT(B + 15);
+        case B + 16:
+          return MPARK_DISPATCH_AT(B + 16);
+        case B + 17:
+          return MPARK_DISPATCH_AT(B + 17);
+        case B + 18:
+          return MPARK_DISPATCH_AT(B + 18);
+        case B + 19:
+          return MPARK_DISPATCH_AT(B + 19);
+        case B + 20:
+          return MPARK_DISPATCH_AT(B + 20);
+        case B + 21:
+          return MPARK_DISPATCH_AT(B + 21);
+        case B + 22:
+          return MPARK_DISPATCH_AT(B + 22);
+        case B + 23:
+          return MPARK_DISPATCH_AT(B + 23);
+        case B + 24:
+          return MPARK_DISPATCH_AT(B + 24);
+        case B + 25:
+          return MPARK_DISPATCH_AT(B + 25);
+        case B + 26:
+          return MPARK_DISPATCH_AT(B + 26);
+        case B + 27:
+          return MPARK_DISPATCH_AT(B + 27);
+        case B + 28:
+          return MPARK_DISPATCH_AT(B + 28);
+        case B + 29:
+          return MPARK_DISPATCH_AT(B + 29);
+        case B + 30:
+          return MPARK_DISPATCH_AT(B + 30);
+        case B + 31:
+          return MPARK_DISPATCH_AT(B + 31);
+        default:
+          return MPARK_DEFAULT(B + 32);
+      }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH_AT
-          }
-        };
+    }
+  };
 #else
-        template <typename T>
-        inline static constexpr const T &at(const T &elem) noexcept {
-          return elem;
-        }
+  template <typename T>
+  inline static constexpr const T& at(const T& elem) noexcept {
+    return elem;
+  }
 
-        template <typename T, std::size_t N, typename... Is>
-        inline static constexpr const lib::remove_all_extents_t<T> &at(
-            const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept {
-          return at(elems[i], is...);
-        }
+  template <typename T, std::size_t N, typename... Is>
+  inline static constexpr const lib::remove_all_extents_t<T>& at(
+      const lib::array<T, N>& elems,
+      std::size_t i,
+      Is... is) noexcept {
+    return at(elems[i], is...);
+  }
 
-        template <typename F, typename... Fs>
-        inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
-        make_farray(F &&f, Fs &&... fs) {
-          return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
-        }
+  template <typename F, typename... Fs>
+  inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
+  make_farray(F&& f, Fs&&... fs) {
+    return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
+  }
 
-        template <typename F, typename... Vs>
-        struct make_fmatrix_impl {
-
-          template <std::size_t... Is>
-          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
-              F &&f, Vs &&... vs) {
-            using Expected = dispatch_result_t<F, Vs...>;
-            using Actual = decltype(lib::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
-            return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
-          }
+  template <typename F, typename... Vs>
+  struct make_fmatrix_impl {
+    template <std::size_t... Is>
+    inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+        F&& f,
+        Vs&&... vs) {
+      using Expected = dispatch_result_t<F, Vs...>;
+      using Actual = decltype(lib::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
+      return visit_return_type_check<Expected, Actual>::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
+    }
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-          template <std::size_t... Is>
-          inline static constexpr auto impl(lib::index_sequence<Is...>) {
-            return &dispatch<Is...>;
-          }
+    template <std::size_t... Is>
+    inline static constexpr auto impl(lib::index_sequence<Is...>) {
+      return &dispatch<Is...>;
+    }
 
-          template <typename Is, std::size_t... Js, typename... Ls>
-          inline static constexpr auto impl(Is,
-                                            lib::index_sequence<Js...>,
-                                            Ls... ls) {
-            return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...);
-          }
+    template <typename Is, std::size_t... Js, typename... Ls>
+    inline static constexpr auto impl(
+        Is,
+        lib::index_sequence<Js...>,
+        Ls... ls) {
+      return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...);
+    }
 #else
-          template <typename...>
-          struct impl;
+    template <typename...>
+    struct impl;
 
-          template <std::size_t... Is>
-          struct impl<lib::index_sequence<Is...>> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(&dispatch<Is...>)
-          };
+    template <std::size_t... Is>
+    struct impl<lib::index_sequence<Is...>> {
+      inline constexpr AUTO operator()() const AUTO_RETURN(&dispatch<Is...>)
+    };
 
-          template <typename Is, std::size_t... Js, typename... Ls>
-          struct impl<Is, lib::index_sequence<Js...>, Ls...> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(
-                  make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
-          };
+    template <typename Is, std::size_t... Js, typename... Ls>
+    struct impl<Is, lib::index_sequence<Js...>, Ls...> {
+      inline constexpr AUTO operator()() const
+          AUTO_RETURN(make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
+    };
 #endif
-        };
+  };
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename F, typename... Vs>
-        inline static constexpr auto make_fmatrix() {
-          return make_fmatrix_impl<F, Vs...>::impl(
-              lib::index_sequence<>{},
-              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-        }
+  template <typename F, typename... Vs>
+  inline static constexpr auto make_fmatrix() {
+    return make_fmatrix_impl<F, Vs...>::impl(
+        lib::index_sequence<>{},
+        lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
+  }
 #else
-        template <typename F, typename... Vs>
-        inline static constexpr AUTO make_fmatrix()
-          AUTO_RETURN(
-              typename make_fmatrix_impl<F, Vs...>::template impl<
+  template <typename F, typename... Vs>
+  inline static constexpr AUTO make_fmatrix()
+      AUTO_RETURN(typename make_fmatrix_impl<F, Vs...>::template impl<
                   lib::index_sequence<>,
                   lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
 #endif
 
-        template <typename F, typename... Vs>
-        struct make_fdiagonal_impl {
-          template <std::size_t I>
-          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
-              F &&f, Vs &&... vs) {
-            using Expected = dispatch_result_t<F, Vs...>;
-            using Actual = decltype(
-                lib::invoke(lib::forward<F>(f),
-                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
-            return visit_return_type_check<Expected, Actual>::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-          }
+  template <typename F, typename... Vs>
+  struct make_fdiagonal_impl {
+    template <std::size_t I>
+    inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+        F&& f,
+        Vs&&... vs) {
+      using Expected = dispatch_result_t<F, Vs...>;
+      using Actual = decltype(lib::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+      return visit_return_type_check<Expected, Actual>::invoke(
+          lib::forward<F>(f),
+          access::base::get_alt<I>(lib::forward<Vs>(vs))...);
+    }
 
-          template <std::size_t... Is>
-          inline static constexpr AUTO impl(lib::index_sequence<Is...>)
-            AUTO_RETURN(make_farray(&dispatch<Is>...))
-        };
+    template <std::size_t... Is>
+    inline static constexpr AUTO impl(lib::index_sequence<Is...>)
+        AUTO_RETURN(make_farray(&dispatch<Is>...))
+  };
 
-        template <typename F, typename V, typename... Vs>
-        inline static constexpr auto make_fdiagonal()
-            -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
-                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
-          static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                  lib::decay_t<Vs>::size())...>::value,
-                        "all of the variants must be the same size.");
-          return make_fdiagonal_impl<F, V, Vs...>::impl(
-              lib::make_index_sequence<lib::decay_t<V>::size()>{});
-        }
+  template <typename F, typename V, typename... Vs>
+  inline static constexpr auto make_fdiagonal()
+      -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
+          lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
+    static_assert(
+        lib::all<(
+            lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...>::value,
+        "all of the variants must be the same size.");
+    return make_fdiagonal_impl<F, V, Vs...>::impl(
+        lib::make_index_sequence<lib::decay_t<V>::size()>{});
+  }
 #endif
-      };
+};
 
 #if !defined(MPARK_VARIANT_SWITCH_VISIT) && \
     (!defined(_MSC_VER) || _MSC_VER >= 1910)
-      template <typename F, typename... Vs>
-      using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
+template <typename F, typename... Vs>
+using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
 
-      template <typename F, typename... Vs>
-      struct fmatrix {
-        static constexpr fmatrix_t<F, Vs...> value =
-            base::make_fmatrix<F, Vs...>();
-      };
+template <typename F, typename... Vs>
+struct fmatrix {
+  static constexpr fmatrix_t<F, Vs...> value = base::make_fmatrix<F, Vs...>();
+};
 
-      template <typename F, typename... Vs>
-      constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
+template <typename F, typename... Vs>
+constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
 
-      template <typename F, typename... Vs>
-      using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
+template <typename F, typename... Vs>
+using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
 
-      template <typename F, typename... Vs>
-      struct fdiagonal {
-        static constexpr fdiagonal_t<F, Vs...> value =
-            base::make_fdiagonal<F, Vs...>();
-      };
+template <typename F, typename... Vs>
+struct fdiagonal {
+  static constexpr fdiagonal_t<F, Vs...> value =
+      base::make_fdiagonal<F, Vs...>();
+};
 
-      template <typename F, typename... Vs>
-      constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
+template <typename F, typename... Vs>
+constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
 #endif
 
-      struct alt {
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
+struct alt {
+  template <typename Visitor, typename... Vs>
+  inline static constexpr DECLTYPE_AUTO visit_alt(Visitor&& visitor, Vs&&... vs)
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+      DECLTYPE_AUTO_RETURN(base::dispatcher<
+                           true,
+                           base::dispatch_result_t<
+                               Visitor,
+                               decltype(as_base(lib::forward<Vs>(vs)))...>>::
+                               template dispatch<0>(
+                                   lib::forward<Visitor>(visitor),
+                                   as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+      DECLTYPE_AUTO_RETURN(base::at(
+          fmatrix<Visitor&&, decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+          vs.index()...)(
+          lib::forward<Visitor>(visitor),
+          as_base(lib::forward<Vs>(vs))...))
+#else
+      DECLTYPE_AUTO_RETURN(base::at(
+          base::make_fmatrix<
+              Visitor&&,
+              decltype(as_base(lib::forward<Vs>(vs)))...>(),
+          vs.index()...)(
+          lib::forward<Visitor>(visitor),
+          as_base(lib::forward<Vs>(vs))...))
+#endif
+
+          template <typename Visitor, typename... Vs>
+          inline static constexpr DECLTYPE_AUTO
+      visit_alt_at(std::size_t index, Visitor&& visitor, Vs&&... vs)
 #ifdef MPARK_VARIANT_SWITCH_VISIT
           DECLTYPE_AUTO_RETURN(
               base::dispatcher<
                   true,
-                  base::dispatch_result_t<Visitor,
-                                          decltype(as_base(
-                                              lib::forward<Vs>(vs)))...>>::
-                  template dispatch<0>(lib::forward<Visitor>(visitor),
-                                       as_base(lib::forward<Vs>(vs))...))
+                  base::dispatch_result_t<
+                      Visitor,
+                      decltype(as_base(lib::forward<Vs>(vs)))...>>::
+                  template dispatch_at<0>(
+                      index,
+                      lib::forward<Visitor>(visitor),
+                      as_base(lib::forward<Vs>(vs))...))
 #elif !defined(_MSC_VER) || _MSC_VER >= 1910
           DECLTYPE_AUTO_RETURN(base::at(
-              fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
+              fdiagonal<Visitor&&, decltype(as_base(lib::forward<Vs>(vs)))...>::
+                  value,
+              index)(
+              lib::forward<Visitor>(visitor),
+              as_base(lib::forward<Vs>(vs))...))
 #else
           DECLTYPE_AUTO_RETURN(base::at(
-              base::make_fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>(),
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
+              base::make_fdiagonal<
+                  Visitor&&,
+                  decltype(as_base(lib::forward<Vs>(vs)))...>(),
+              index)(
+              lib::forward<Visitor>(visitor),
+              as_base(lib::forward<Vs>(vs))...))
 #endif
+};
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-#ifdef MPARK_VARIANT_SWITCH_VISIT
-          DECLTYPE_AUTO_RETURN(
-              base::dispatcher<
-                  true,
-                  base::dispatch_result_t<Visitor,
-                                          decltype(as_base(
-                                              lib::forward<Vs>(vs)))...>>::
-                  template dispatch_at<0>(index,
-                                          lib::forward<Visitor>(visitor),
-                                          as_base(lib::forward<Vs>(vs))...))
-#elif !defined(_MSC_VER) || _MSC_VER >= 1910
-          DECLTYPE_AUTO_RETURN(base::at(
-              fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-#else
-          DECLTYPE_AUTO_RETURN(base::at(
-              base::make_fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>(),
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-#endif
-      };
+struct variant {
+ private:
+  template <typename Visitor>
+  struct visitor {
+    template <typename... Values>
+    inline static constexpr bool does_not_handle() {
+      return lib::is_invocable<Visitor, Values...>::value;
+    }
+  };
 
-      struct variant {
-        private:
-        template <typename Visitor>
-        struct visitor {
-          template <typename... Values>
-          inline static constexpr bool does_not_handle() {
-            return lib::is_invocable<Visitor, Values...>::value;
-          }
-        };
+  template <typename Visitor, typename... Values>
+  struct visit_exhaustiveness_check {
+    static_assert(
+        visitor<Visitor>::template does_not_handle<Values...>(),
+        "`visit` requires the visitor to be exhaustive.");
 
-        template <typename Visitor, typename... Values>
-        struct visit_exhaustiveness_check {
-          static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
-                        "`visit` requires the visitor to be exhaustive.");
+    inline static constexpr DECLTYPE_AUTO invoke(
+        Visitor&& visitor,
+        Values&&... values)
+        DECLTYPE_AUTO_RETURN(lib::invoke(
+            lib::forward<Visitor>(visitor),
+            lib::forward<Values>(values)...))
+  };
 
-          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                       Values &&... values)
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Values>(values)...))
-        };
+  template <typename Visitor>
+  struct value_visitor {
+    Visitor&& visitor_;
 
-        template <typename Visitor>
-        struct value_visitor {
-          Visitor &&visitor_;
+    template <typename... Alts>
+    inline constexpr DECLTYPE_AUTO operator()(Alts&&... alts) const
+        DECLTYPE_AUTO_RETURN(visit_exhaustiveness_check<
+                             Visitor,
+                             decltype((lib::forward<Alts>(alts).value))...>::
+                                 invoke(
+                                     lib::forward<Visitor>(visitor_),
+                                     lib::forward<Alts>(alts).value...))
+  };
 
-          template <typename... Alts>
-          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
-            DECLTYPE_AUTO_RETURN(
-                visit_exhaustiveness_check<
-                    Visitor,
-                    decltype((lib::forward<Alts>(alts).value))...>::
-                    invoke(lib::forward<Visitor>(visitor_),
-                           lib::forward<Alts>(alts).value...))
-        };
+  template <typename Visitor>
+  inline static constexpr AUTO make_value_visitor(Visitor&& visitor)
+      AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
 
-        template <typename Visitor>
-        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
+          public
+      : template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO
+        visit_alt(Visitor&& visitor, Vs&&... vs)
+            DECLTYPE_AUTO_RETURN(alt::visit_alt(
+                lib::forward<Visitor>(visitor),
+                lib::forward<Vs>(vs).impl_...))
 
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
-                                              lib::forward<Vs>(vs).impl_...))
+                template <typename Visitor, typename... Vs>
+                inline static constexpr DECLTYPE_AUTO
+        visit_alt_at(std::size_t index, Visitor&& visitor, Vs&&... vs)
+            DECLTYPE_AUTO_RETURN(alt::visit_alt_at(
+                index,
+                lib::forward<Visitor>(visitor),
+                lib::forward<Vs>(vs).impl_...))
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              alt::visit_alt_at(index,
-                                lib::forward<Visitor>(visitor),
-                                lib::forward<Vs>(vs).impl_...))
+                template <typename Visitor, typename... Vs>
+                inline static constexpr DECLTYPE_AUTO
+        visit_value(Visitor&& visitor, Vs&&... vs)
+            DECLTYPE_AUTO_RETURN(visit_alt(
+                make_value_visitor(lib::forward<Visitor>(visitor)),
+                lib::forward<Vs>(vs)...))
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
-                                                          Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
-                        lib::forward<Vs>(vs)...))
+                template <typename Visitor, typename... Vs>
+                inline static constexpr DECLTYPE_AUTO
+        visit_value_at(std::size_t index, Visitor&& visitor, Vs&&... vs)
+            DECLTYPE_AUTO_RETURN(visit_alt_at(
+                index,
+                make_value_visitor(lib::forward<Visitor>(visitor)),
+                lib::forward<Vs>(vs)...))
+};
 
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
-                                                             Visitor &&visitor,
-                                                             Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt_at(index,
-                           make_value_visitor(lib::forward<Visitor>(visitor)),
-                           lib::forward<Vs>(vs)...))
-      };
+} // namespace visitation
 
-    }  // namespace visitation
-
-    template <std::size_t Index, typename T>
-    struct alt {
-      using value_type = T;
+template <std::size_t Index, typename T>
+struct alt {
+  using value_type = T;
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-      template <typename... Args>
-      inline explicit constexpr alt(in_place_t, Args &&... args)
-          : value(lib::forward<Args>(args)...) {}
+  template <typename... Args>
+  inline explicit constexpr alt(in_place_t, Args&&... args)
+      : value(lib::forward<Args>(args)...) {}
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-      T value;
-    };
+  T value;
+};
 
-    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
-    union recursive_union;
+template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
+union recursive_union;
 
-    template <Trait DestructibleTrait, std::size_t Index>
-    union recursive_union<DestructibleTrait, Index> {};
+template <Trait DestructibleTrait, std::size_t Index>
+union recursive_union<DestructibleTrait, Index> {};
 
 #define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
   template <std::size_t Index, typename T, typename... Ts>                 \
   union recursive_union<destructible_trait, Index, T, Ts...> {             \
-    public:                                                                \
+   public:                                                                 \
     inline explicit constexpr recursive_union(valueless_t) noexcept        \
         : dummy_{} {}                                                      \
                                                                            \
     template <typename... Args>                                            \
-    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                              Args &&... args)             \
+    inline explicit constexpr recursive_union(                             \
+        in_place_index_t<0>,                                               \
+        Args&&... args)                                                    \
         : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
                                                                            \
     template <std::size_t I, typename... Args>                             \
-    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                              Args &&... args)             \
+    inline explicit constexpr recursive_union(                             \
+        in_place_index_t<I>,                                               \
+        Args&&... args)                                                    \
         : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
                                                                            \
-    recursive_union(const recursive_union &) = default;                    \
-    recursive_union(recursive_union &&) = default;                         \
+    recursive_union(const recursive_union&) = default;                     \
+    recursive_union(recursive_union&&) = default;                          \
                                                                            \
     destructor                                                             \
                                                                            \
-    recursive_union &operator=(const recursive_union &) = default;         \
-    recursive_union &operator=(recursive_union &&) = default;              \
+        recursive_union&                                                   \
+        operator=(const recursive_union&) = default;                       \
+    recursive_union& operator=(recursive_union&&) = default;               \
                                                                            \
-    private:                                                               \
+   private:                                                                \
     char dummy_;                                                           \
     alt<Index, T> head_;                                                   \
     recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
@@ -1702,81 +1808,98 @@ namespace c10 {
     friend struct access::recursive_union;                                 \
   }
 
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                                  ~recursive_union() = default;);
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
-                                  ~recursive_union() {});
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
-                                  ~recursive_union() = delete;);
+MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
+                              ~recursive_union() = default;);
+MPARK_VARIANT_RECURSIVE_UNION(Trait::Available, ~recursive_union(){});
+MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable, ~recursive_union() = delete;);
 
 #undef MPARK_VARIANT_RECURSIVE_UNION
 
-    using index_t = unsigned int;
+using index_t = unsigned int;
 
-    template <Trait DestructibleTrait, typename... Ts>
-    class base {
-      public:
-      inline explicit constexpr base(valueless_t tag) noexcept
-          : data_(tag), index_(static_cast<index_t>(-1)) {}
+template <Trait DestructibleTrait, typename... Ts>
+class base {
+ public:
+  inline explicit constexpr base(valueless_t tag) noexcept
+      : data_(tag), index_(static_cast<index_t>(-1)) {}
 
-      template <std::size_t I, typename... Args>
-      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
-          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-            index_(I) {}
+  template <std::size_t I, typename... Args>
+  inline explicit constexpr base(in_place_index_t<I>, Args&&... args)
+      : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...), index_(I) {}
 
-      inline constexpr bool valueless_by_exception() const noexcept {
-        return index_ == static_cast<index_t>(-1);
-      }
+  inline constexpr bool valueless_by_exception() const noexcept {
+    return index_ == static_cast<index_t>(-1);
+  }
 
-      inline constexpr std::size_t index() const noexcept {
-        return valueless_by_exception() ? variant_npos : index_;
-      }
+  inline constexpr std::size_t index() const noexcept {
+    return valueless_by_exception() ? variant_npos : index_;
+  }
 
-      protected:
-      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
+ protected:
+  using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
 
-      friend inline constexpr base &as_base(base &b) { return b; }
-      friend inline constexpr const base &as_base(const base &b) { return b; }
-      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
-      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
+  friend inline constexpr base& as_base(base& b) {
+    return b;
+  }
+  friend inline constexpr const base& as_base(const base& b) {
+    return b;
+  }
+  friend inline constexpr base&& as_base(base&& b) {
+    return lib::move(b);
+  }
+  friend inline constexpr const base&& as_base(const base&& b) {
+    return lib::move(b);
+  }
 
-      friend inline constexpr data_t &data(base &b) { return b.data_; }
-      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
-      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
-      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
+  friend inline constexpr data_t& data(base& b) {
+    return b.data_;
+  }
+  friend inline constexpr const data_t& data(const base& b) {
+    return b.data_;
+  }
+  friend inline constexpr data_t&& data(base&& b) {
+    return lib::move(b).data_;
+  }
+  friend inline constexpr const data_t&& data(const base&& b) {
+    return lib::move(b).data_;
+  }
 
-      inline static constexpr std::size_t size() { return sizeof...(Ts); }
+  inline static constexpr std::size_t size() {
+    return sizeof...(Ts);
+  }
 
-      data_t data_;
-      index_t index_;
+  data_t data_;
+  index_t index_;
 
-      friend struct access::base;
-      friend struct visitation::base;
-    };
+  friend struct access::base;
+  friend struct visitation::base;
+};
 
-    struct dtor {
+struct dtor {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-      template <typename Alt>
-      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
+  template <typename Alt>
+  inline void operator()(Alt& alt) const noexcept {
+    alt.~Alt();
+  }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-    };
+};
 
 #if !defined(_MSC_VER) || _MSC_VER >= 1910
 #define MPARK_INHERITING_CTOR(type, base) using base::base;
 #else
-#define MPARK_INHERITING_CTOR(type, base)         \
-  template <typename... Args>                     \
-  inline explicit constexpr type(Args &&... args) \
+#define MPARK_INHERITING_CTOR(type, base)        \
+  template <typename... Args>                    \
+  inline explicit constexpr type(Args&&... args) \
       : base(lib::forward<Args>(args)...) {}
 #endif
 
-    template <typename Traits, Trait = Traits::destructible_trait>
-    class destructor;
+template <typename Traits, Trait = Traits::destructible_trait>
+class destructor;
 
 #define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
   template <typename... Ts>                                               \
@@ -1784,94 +1907,89 @@ namespace c10 {
       : public base<destructible_trait, Ts...> {                          \
     using super = base<destructible_trait, Ts...>;                        \
                                                                           \
-    public:                                                               \
+   public:                                                                \
     MPARK_INHERITING_CTOR(destructor, super)                              \
     using super::operator=;                                               \
                                                                           \
-    destructor(const destructor &) = default;                             \
-    destructor(destructor &&) = default;                                  \
-    definition                                                            \
-    destructor &operator=(const destructor &) = default;                  \
-    destructor &operator=(destructor &&) = default;                       \
+    destructor(const destructor&) = default;                              \
+    destructor(destructor&&) = default;                                   \
+    definition destructor& operator=(const destructor&) = default;        \
+    destructor& operator=(destructor&&) = default;                        \
                                                                           \
-    protected:                                                            \
+   protected:                                                             \
     destroy                                                               \
   }
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::TriviallyAvailable,
-        ~destructor() = default;,
-        inline void destroy() noexcept {
-          this->index_ = static_cast<index_t>(-1);
-        });
+MPARK_VARIANT_DESTRUCTOR(
+    Trait::TriviallyAvailable, ~destructor() = default;
+    , inline void destroy() noexcept {
+      this->index_ = static_cast<index_t>(-1);
+    });
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Available,
-        ~destructor() { destroy(); },
-        inline void destroy() noexcept {
-          if (!this->valueless_by_exception()) {
-            visitation::alt::visit_alt(dtor{}, *this);
-          }
-          this->index_ = static_cast<index_t>(-1);
-        });
+MPARK_VARIANT_DESTRUCTOR(
+    Trait::Available,
+    ~destructor() { destroy(); },
+    inline void destroy() noexcept {
+      if (!this->valueless_by_exception()) {
+        visitation::alt::visit_alt(dtor{}, *this);
+      }
+      this->index_ = static_cast<index_t>(-1);
+    });
 
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Unavailable,
-        ~destructor() = delete;,
-        inline void destroy() noexcept = delete;);
+MPARK_VARIANT_DESTRUCTOR(Trait::Unavailable, ~destructor() = delete;
+                         , inline void destroy() noexcept = delete;);
 
 #undef MPARK_VARIANT_DESTRUCTOR
 
-    template <typename Traits>
-    class constructor : public destructor<Traits> {
-      using super = destructor<Traits>;
+template <typename Traits>
+class constructor : public destructor<Traits> {
+  using super = destructor<Traits>;
 
-      public:
-      MPARK_INHERITING_CTOR(constructor, super)
-      using super::operator=;
+ public:
+  MPARK_INHERITING_CTOR(constructor, super)
+  using super::operator=;
 
-      protected:
+ protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-      struct ctor {
-        template <typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
-          constructor::construct_alt(lhs_alt,
-                                     lib::forward<RhsAlt>(rhs_alt).value);
-        }
-      };
+  struct ctor {
+    template <typename LhsAlt, typename RhsAlt>
+    inline void operator()(LhsAlt& lhs_alt, RhsAlt&& rhs_alt) const {
+      constructor::construct_alt(lhs_alt, lib::forward<RhsAlt>(rhs_alt).value);
+    }
+  };
 #endif
 
-      template <std::size_t I, typename T, typename... Args>
-      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
-        auto *result = ::new (static_cast<void *>(lib::addressof(a)))
-            alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
-        return result->value;
-      }
+  template <std::size_t I, typename T, typename... Args>
+  inline static T& construct_alt(alt<I, T>& a, Args&&... args) {
+    auto* result = ::new (static_cast<void*>(lib::addressof(a)))
+        alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
+    return result->value;
+  }
 
-      template <typename Rhs>
-      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
-        lhs.destroy();
-        if (!rhs.valueless_by_exception()) {
-          visitation::alt::visit_alt_at(
-              rhs.index(),
+  template <typename Rhs>
+  inline static void generic_construct(constructor& lhs, Rhs&& rhs) {
+    lhs.destroy();
+    if (!rhs.valueless_by_exception()) {
+      visitation::alt::visit_alt_at(
+          rhs.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-              [](auto &lhs_alt, auto &&rhs_alt) {
-                constructor::construct_alt(
-                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-              }
+          [](auto& lhs_alt, auto&& rhs_alt) {
+            constructor::construct_alt(
+                lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
+          }
 #else
-              ctor{}
+          ctor {}
 #endif
-              ,
-              lhs,
-              lib::forward<Rhs>(rhs));
-          lhs.index_ = rhs.index_;
-        }
-      }
-    };
+          ,
+          lhs,
+          lib::forward<Rhs>(rhs));
+      lhs.index_ = rhs.index_;
+    }
+  }
+};
 
-    template <typename Traits, Trait = Traits::move_constructible_trait>
-    class move_constructor;
+template <typename Traits, Trait = Traits::move_constructible_trait>
+class move_constructor;
 
 #define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
   template <typename... Ts>                                                  \
@@ -1879,37 +1997,35 @@ namespace c10 {
       : public constructor<traits<Ts...>> {                                  \
     using super = constructor<traits<Ts...>>;                                \
                                                                              \
-    public:                                                                  \
+   public:                                                                   \
     MPARK_INHERITING_CTOR(move_constructor, super)                           \
     using super::operator=;                                                  \
                                                                              \
-    move_constructor(const move_constructor &) = default;                    \
-    definition                                                               \
-    ~move_constructor() = default;                                           \
-    move_constructor &operator=(const move_constructor &) = default;         \
-    move_constructor &operator=(move_constructor &&) = default;              \
+    move_constructor(const move_constructor&) = default;                     \
+    definition ~move_constructor() = default;                                \
+    move_constructor& operator=(const move_constructor&) = default;          \
+    move_constructor& operator=(move_constructor&&) = default;               \
   }
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        move_constructor(move_constructor &&that) = default;);
+MPARK_VARIANT_MOVE_CONSTRUCTOR(
+    Trait::TriviallyAvailable,
+    move_constructor(move_constructor&& that) = default;);
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Available,
-        move_constructor(move_constructor &&that) noexcept(
-            lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
-            : move_constructor(valueless_t{}) {
-          this->generic_construct(*this, lib::move(that));
-        });
+MPARK_VARIANT_MOVE_CONSTRUCTOR(
+    Trait::Available,
+    move_constructor(move_constructor&& that) noexcept(
+        lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
+    : move_constructor(valueless_t{}) {
+      this->generic_construct(*this, lib::move(that));
+    });
 
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Unavailable,
-        move_constructor(move_constructor &&) = delete;);
+MPARK_VARIANT_MOVE_CONSTRUCTOR(Trait::Unavailable,
+                               move_constructor(move_constructor&&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_CONSTRUCTOR
 
-    template <typename Traits, Trait = Traits::copy_constructible_trait>
-    class copy_constructor;
+template <typename Traits, Trait = Traits::copy_constructible_trait>
+class copy_constructor;
 
 #define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
   template <typename... Ts>                                                  \
@@ -1917,119 +2033,117 @@ namespace c10 {
       : public move_constructor<traits<Ts...>> {                             \
     using super = move_constructor<traits<Ts...>>;                           \
                                                                              \
-    public:                                                                  \
+   public:                                                                   \
     MPARK_INHERITING_CTOR(copy_constructor, super)                           \
     using super::operator=;                                                  \
                                                                              \
-    definition                                                               \
-    copy_constructor(copy_constructor &&) = default;                         \
+    definition copy_constructor(copy_constructor&&) = default;               \
     ~copy_constructor() = default;                                           \
-    copy_constructor &operator=(const copy_constructor &) = default;         \
-    copy_constructor &operator=(copy_constructor &&) = default;              \
+    copy_constructor& operator=(const copy_constructor&) = default;          \
+    copy_constructor& operator=(copy_constructor&&) = default;               \
   }
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        copy_constructor(const copy_constructor &that) = default;);
+MPARK_VARIANT_COPY_CONSTRUCTOR(
+    Trait::TriviallyAvailable,
+    copy_constructor(const copy_constructor& that) = default;);
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Available,
-        copy_constructor(const copy_constructor &that)
-            : copy_constructor(valueless_t{}) {
-          this->generic_construct(*this, that);
-        });
+MPARK_VARIANT_COPY_CONSTRUCTOR(
+    Trait::Available, copy_constructor(const copy_constructor& that)
+    : copy_constructor(valueless_t{}) {
+      this->generic_construct(*this, that);
+    });
 
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Unavailable,
-        copy_constructor(const copy_constructor &) = delete;);
+MPARK_VARIANT_COPY_CONSTRUCTOR(
+    Trait::Unavailable, copy_constructor(const copy_constructor&) = delete;);
 
 #undef MPARK_VARIANT_COPY_CONSTRUCTOR
 
-    template <typename Traits>
-    class assignment : public copy_constructor<Traits> {
-      using super = copy_constructor<Traits>;
+template <typename Traits>
+class assignment : public copy_constructor<Traits> {
+  using super = copy_constructor<Traits>;
 
-      public:
-      MPARK_INHERITING_CTOR(assignment, super)
-      using super::operator=;
+ public:
+  MPARK_INHERITING_CTOR(assignment, super)
+  using super::operator=;
 
-      template <std::size_t I, typename... Args>
-      inline /* auto & */ auto emplace(Args &&... args)
-          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                          lib::forward<Args>(args)...)) {
-        this->destroy();
-        auto &result = this->construct_alt(access::base::get_alt<I>(*this),
-                                           lib::forward<Args>(args)...);
-        this->index_ = I;
-        return result;
-      }
+  template <std::size_t I, typename... Args>
+  inline /* auto & */ auto emplace(Args&&... args)
+      -> decltype(this->construct_alt(
+          access::base::get_alt<I>(*this),
+          lib::forward<Args>(args)...)) {
+    this->destroy();
+    auto& result = this->construct_alt(
+        access::base::get_alt<I>(*this), lib::forward<Args>(args)...);
+    this->index_ = I;
+    return result;
+  }
 
-      protected:
+ protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-      template <typename That>
-      struct assigner {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
-          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
-        }
-        assignment *self;
-      };
+  template <typename That>
+  struct assigner {
+    template <typename ThisAlt, typename ThatAlt>
+    inline void operator()(ThisAlt& this_alt, ThatAlt&& that_alt) const {
+      self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
+    }
+    assignment* self;
+  };
 #endif
 
-      template <std::size_t I, typename T, typename Arg>
-      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
-        if (this->index() == I) {
+  template <std::size_t I, typename T, typename Arg>
+  inline void assign_alt(alt<I, T>& a, Arg&& arg) {
+    if (this->index() == I) {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-          a.value = lib::forward<Arg>(arg);
+      a.value = lib::forward<Arg>(arg);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-        } else {
-          struct {
-            void operator()(std::true_type) const {
-              this_->emplace<I>(lib::forward<Arg>(arg_));
-            }
-            void operator()(std::false_type) const {
-              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-            }
-            assignment *this_;
-            Arg &&arg_;
-          } impl{this, lib::forward<Arg>(arg)};
-          impl(lib::bool_constant<
-                   std::is_nothrow_constructible<T, Arg>::value ||
-                   !std::is_nothrow_move_constructible<T>::value>{});
+    } else {
+      struct {
+        void operator()(std::true_type) const {
+          this_->emplace<I>(lib::forward<Arg>(arg_));
         }
-      }
+        void operator()(std::false_type) const {
+          this_->emplace<I>(T(lib::forward<Arg>(arg_)));
+        }
+        assignment* this_;
+        Arg&& arg_;
+      } impl{this, lib::forward<Arg>(arg)};
+      impl(
+          lib::bool_constant < std::is_nothrow_constructible<T, Arg>::value ||
+          !std::is_nothrow_move_constructible<T>::value > {});
+    }
+  }
 
-      template <typename That>
-      inline void generic_assign(That &&that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (that.valueless_by_exception()) {
-          this->destroy();
-        } else {
-          visitation::alt::visit_alt_at(
-              that.index(),
+  template <typename That>
+  inline void generic_assign(That&& that) {
+    if (this->valueless_by_exception() && that.valueless_by_exception()) {
+      // do nothing.
+    } else if (that.valueless_by_exception()) {
+      this->destroy();
+    } else {
+      visitation::alt::visit_alt_at(
+          that.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-              [this](auto &this_alt, auto &&that_alt) {
-                this->assign_alt(
-                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
-              }
+          [this](auto& this_alt, auto&& that_alt) {
+            this->assign_alt(
+                this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
+          }
 #else
-              assigner<That>{this}
+          assigner<That> { this }
 #endif
-              ,
-              *this,
-              lib::forward<That>(that));
-        }
-      }
-    };
+          ,
+          *this,
+          lib::forward<That>(that));
+    }
+  }
+};
 
-    template <typename Traits, Trait = Traits::move_assignable_trait>
-    class move_assignment;
+template <typename Traits, Trait = Traits::move_assignable_trait>
+class move_assignment;
 
 #define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
   template <typename... Ts>                                              \
@@ -2037,39 +2151,40 @@ namespace c10 {
       : public assignment<traits<Ts...>> {                               \
     using super = assignment<traits<Ts...>>;                             \
                                                                          \
-    public:                                                              \
+   public:                                                               \
     MPARK_INHERITING_CTOR(move_assignment, super)                        \
     using super::operator=;                                              \
                                                                          \
-    move_assignment(const move_assignment &) = default;                  \
-    move_assignment(move_assignment &&) = default;                       \
+    move_assignment(const move_assignment&) = default;                   \
+    move_assignment(move_assignment&&) = default;                        \
     ~move_assignment() = default;                                        \
-    move_assignment &operator=(const move_assignment &) = default;       \
+    move_assignment& operator=(const move_assignment&) = default;        \
     definition                                                           \
   }
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        move_assignment &operator=(move_assignment &&that) = default;);
+MPARK_VARIANT_MOVE_ASSIGNMENT(
+    Trait::TriviallyAvailable,
+    move_assignment& operator=(move_assignment&& that) = default;);
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Available,
-        move_assignment &
-        operator=(move_assignment &&that) noexcept(
-            lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                      std::is_nothrow_move_assignable<Ts>::value)...>::value) {
-          this->generic_assign(lib::move(that));
-          return *this;
-        });
+MPARK_VARIANT_MOVE_ASSIGNMENT(
+    Trait::Available,
+    move_assignment&
+    operator=(move_assignment&& that) noexcept(
+        lib::all<
+            (std::is_nothrow_move_constructible<Ts>::value &&
+             std::is_nothrow_move_assignable<Ts>::value)...>::value) {
+      this->generic_assign(lib::move(that));
+      return *this;
+    });
 
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Unavailable,
-        move_assignment &operator=(move_assignment &&) = delete;);
+MPARK_VARIANT_MOVE_ASSIGNMENT(
+    Trait::Unavailable,
+    move_assignment& operator=(move_assignment&&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_ASSIGNMENT
 
-    template <typename Traits, Trait = Traits::copy_assignable_trait>
-    class copy_assignment;
+template <typename Traits, Trait = Traits::copy_assignable_trait>
+class copy_assignment;
 
 #define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
   template <typename... Ts>                                              \
@@ -2077,710 +2192,738 @@ namespace c10 {
       : public move_assignment<traits<Ts...>> {                          \
     using super = move_assignment<traits<Ts...>>;                        \
                                                                          \
-    public:                                                              \
+   public:                                                               \
     MPARK_INHERITING_CTOR(copy_assignment, super)                        \
     using super::operator=;                                              \
                                                                          \
-    copy_assignment(const copy_assignment &) = default;                  \
-    copy_assignment(copy_assignment &&) = default;                       \
+    copy_assignment(const copy_assignment&) = default;                   \
+    copy_assignment(copy_assignment&&) = default;                        \
     ~copy_assignment() = default;                                        \
-    definition                                                           \
-    copy_assignment &operator=(copy_assignment &&) = default;            \
+    definition copy_assignment& operator=(copy_assignment&&) = default;  \
   }
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        copy_assignment &operator=(const copy_assignment &that) = default;);
+MPARK_VARIANT_COPY_ASSIGNMENT(
+    Trait::TriviallyAvailable,
+    copy_assignment& operator=(const copy_assignment& that) = default;);
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Available,
-        copy_assignment &operator=(const copy_assignment &that) {
-          this->generic_assign(that);
-          return *this;
-        });
+MPARK_VARIANT_COPY_ASSIGNMENT(
+    Trait::Available,
+    copy_assignment&
+    operator=(const copy_assignment& that) {
+      this->generic_assign(that);
+      return *this;
+    });
 
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Unavailable,
-        copy_assignment &operator=(const copy_assignment &) = delete;);
+MPARK_VARIANT_COPY_ASSIGNMENT(
+    Trait::Unavailable,
+    copy_assignment& operator=(const copy_assignment&) = delete;);
 
 #undef MPARK_VARIANT_COPY_ASSIGNMENT
 
-    template <typename... Ts>
-    class impl : public copy_assignment<traits<Ts...>> {
-      using super = copy_assignment<traits<Ts...>>;
+template <typename... Ts>
+class impl : public copy_assignment<traits<Ts...>> {
+  using super = copy_assignment<traits<Ts...>>;
 
-      public:
-      MPARK_INHERITING_CTOR(impl, super)
-      using super::operator=;
+ public:
+  MPARK_INHERITING_CTOR(impl, super)
+  using super::operator=;
 
-      template <std::size_t I, typename Arg>
-      inline void assign(Arg &&arg) {
-        this->assign_alt(access::base::get_alt<I>(*this),
-                         lib::forward<Arg>(arg));
-      }
+  template <std::size_t I, typename Arg>
+  inline void assign(Arg&& arg) {
+    this->assign_alt(access::base::get_alt<I>(*this), lib::forward<Arg>(arg));
+  }
 
-      inline void swap(impl &that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (this->index() == that.index()) {
-          visitation::alt::visit_alt_at(this->index(),
+  inline void swap(impl& that) {
+    if (this->valueless_by_exception() && that.valueless_by_exception()) {
+      // do nothing.
+    } else if (this->index() == that.index()) {
+      visitation::alt::visit_alt_at(
+          this->index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-                                        [](auto &this_alt, auto &that_alt) {
-                                          using std::swap;
-                                          swap(this_alt.value,
-                                               that_alt.value);
-                                        }
-#else
-                                        swapper{}
-#endif
-                                        ,
-                                        *this,
-                                        that);
-        } else {
-          impl *lhs = this;
-          impl *rhs = lib::addressof(that);
-          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-            std::swap(lhs, rhs);
+          [](auto& this_alt, auto& that_alt) {
+            using std::swap;
+            swap(this_alt.value, that_alt.value);
           }
-          impl tmp(lib::move(*rhs));
+#else
+          swapper {}
+#endif
+          ,
+          *this,
+          that);
+    } else {
+      impl* lhs = this;
+      impl* rhs = lib::addressof(that);
+      if (lhs->move_nothrow() && !rhs->move_nothrow()) {
+        std::swap(lhs, rhs);
+      }
+      impl tmp(lib::move(*rhs));
 #ifdef MPARK_EXCEPTIONS
-          // EXTENSION: When the move construction of `lhs` into `rhs` throws
-          // and `tmp` is nothrow move constructible then we move `tmp` back
-          // into `rhs` and provide the strong exception safety guarantee.
-          try {
-            this->generic_construct(*rhs, lib::move(*lhs));
-          } catch (...) {
-            if (tmp.move_nothrow()) {
-              this->generic_construct(*rhs, lib::move(tmp));
-            }
-            throw;
-          }
+      // EXTENSION: When the move construction of `lhs` into `rhs` throws
+      // and `tmp` is nothrow move constructible then we move `tmp` back
+      // into `rhs` and provide the strong exception safety guarantee.
+      try {
+        this->generic_construct(*rhs, lib::move(*lhs));
+      } catch (...) {
+        if (tmp.move_nothrow()) {
+          this->generic_construct(*rhs, lib::move(tmp));
+        }
+        throw;
+      }
 #else
-          this->generic_construct(*rhs, lib::move(*lhs));
+      this->generic_construct(*rhs, lib::move(*lhs));
 #endif
-          this->generic_construct(*lhs, lib::move(tmp));
-        }
-      }
+      this->generic_construct(*lhs, lib::move(tmp));
+    }
+  }
 
-      private:
+ private:
 #ifndef MPARK_GENERIC_LAMBDAS
-      struct swapper {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
-          using std::swap;
-          swap(this_alt.value, that_alt.value);
-        }
-      };
+  struct swapper {
+    template <typename ThisAlt, typename ThatAlt>
+    inline void operator()(ThisAlt& this_alt, ThatAlt& that_alt) const {
+      using std::swap;
+      swap(this_alt.value, that_alt.value);
+    }
+  };
 #endif
 
-      inline constexpr bool move_nothrow() const {
-        return this->valueless_by_exception() ||
-               lib::array<bool, sizeof...(Ts)>{
-                   {std::is_nothrow_move_constructible<Ts>::value...}
-               }[this->index()];
-      }
-    };
+  inline constexpr bool move_nothrow() const {
+    return this->valueless_by_exception() ||
+        lib::array<bool, sizeof...(Ts)>{
+            {std::is_nothrow_move_constructible<Ts>::value...}}[this->index()];
+  }
+};
 
 #undef MPARK_INHERITING_CTOR
 
-    template <std::size_t I, typename T>
-    struct overload_leaf {
-      using F = lib::size_constant<I> (*)(T);
-      operator F() const { return nullptr; }
-    };
+template <std::size_t I, typename T>
+struct overload_leaf {
+  using F = lib::size_constant<I> (*)(T);
+  operator F() const {
+    return nullptr;
+  }
+};
 
-    template <typename... Ts>
-    struct overload_impl {
-      private:
-      template <typename>
-      struct impl;
+template <typename... Ts>
+struct overload_impl {
+ private:
+  template <typename>
+  struct impl;
 
-      template <std::size_t... Is>
-      struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
+  template <std::size_t... Is>
+  struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
 
-      public:
-      using type = impl<lib::index_sequence_for<Ts...>>;
-    };
+ public:
+  using type = impl<lib::index_sequence_for<Ts...>>;
+};
 
-    template <typename... Ts>
-    using overload = typename overload_impl<Ts...>::type;
+template <typename... Ts>
+using overload = typename overload_impl<Ts...>::type;
 
-    template <typename T, typename... Ts>
-    using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
+template <typename T, typename... Ts>
+using best_match = lib::invoke_result_t<overload<Ts...>, T&&>;
 
-    template <typename T>
-    struct is_in_place_index : std::false_type {};
+template <typename T>
+struct is_in_place_index : std::false_type {};
 
-    template <std::size_t I>
-    struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
+template <std::size_t I>
+struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
 
-    template <typename T>
-    struct is_in_place_type : std::false_type {};
+template <typename T>
+struct is_in_place_type : std::false_type {};
 
-    template <typename T>
-    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
+template <typename T>
+struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
 
-  }  // detail_
+} // namespace detail_
 
-  template <typename... Ts>
-  class variant {
-    static_assert(0 < sizeof...(Ts),
-                  "variant must consist of at least one alternative.");
+template <typename... Ts>
+class variant {
+  static_assert(
+      0 < sizeof...(Ts),
+      "variant must consist of at least one alternative.");
 
-    static_assert(lib::all<!std::is_array<Ts>::value...>::value,
-                  "variant can not have an array type as an alternative.");
+  static_assert(
+      lib::all<!std::is_array<Ts>::value...>::value,
+      "variant can not have an array type as an alternative.");
 
-    static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
-                  "variant can not have a reference type as an alternative.");
+  static_assert(
+      lib::all<!std::is_reference<Ts>::value...>::value,
+      "variant can not have a reference type as an alternative.");
 
-    static_assert(lib::all<!std::is_void<Ts>::value...>::value,
-                  "variant can not have a void type as an alternative.");
+  static_assert(
+      lib::all<!std::is_void<Ts>::value...>::value,
+      "variant can not have a void type as an alternative.");
 
-    public:
-    template <
-        typename Front = lib::type_pack_element_t<0, Ts...>,
-        lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
-    inline constexpr variant() noexcept(
-        std::is_nothrow_default_constructible<Front>::value)
-        : impl_(in_place_index_t<0>{}) {}
+ public:
+  template <
+      typename Front = lib::type_pack_element_t<0, Ts...>,
+      lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
+  inline constexpr variant() noexcept(
+      std::is_nothrow_default_constructible<Front>::value)
+      : impl_(in_place_index_t<0>{}) {}
 
-    variant(const variant &) = default;
-    variant(variant &&) = default;
+  variant(const variant&) = default;
+  variant(variant&&) = default;
 
-    // NOTE [gcc 7.3.1 bug workaround]
-    //
-    // The original line `typename T = lib::type_pack_element_t<I, Ts...>`
-    // throws the following compiler error on gcc 7.3.1:
-    // ```
-    // ../c10/util/variant.h:2250:9: internal compiler error:
-    // unexpected expression ‘I’ of kind template_parm_index
-    //          typename T = lib::type_pack_element_t<I, Ts...>,
-    //          ^~~~~~~~
-    // ```
-    // As a workaround, `I` is changed to `detail_::best_match<Arg, Ts...>::value`,
-    // which is the default value for `I` in this template. Note that this workaround
-    // effectively disallows setting `I` to any other non-default value, and we add a
-    // `static_assert` in the function body to check for this.
-    //
-    // See the following issues for more context:
-    // - https://github.com/mpark/variant/issues/43
-    // - https://github.com/eggs-cpp/variant/issues/31
-    template <
-        typename Arg,
-        typename Decayed = lib::decay_t<Arg>,
-        lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
-        lib::enable_if_t<!detail_::is_in_place_index<Decayed>::value, int> = 0,
-        lib::enable_if_t<!detail_::is_in_place_type<Decayed>::value, int> = 0,
-        std::size_t I = detail_::best_match<Arg, Ts...>::value,
-        typename T = lib::type_pack_element_t<detail_::best_match<Arg, Ts...>::value, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
-    inline constexpr variant(Arg &&arg) noexcept(
-        std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {
-          static_assert(
-            I == detail_::best_match<Arg, Ts...>::value,
-            "Setting template parameter `I` to a custom non-default value is not supported. "
-            "Please file a feature request if you see this.");
-        }
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    ~variant() = default;
-
-    variant &operator=(const variant &) = default;
-    variant &operator=(variant &&) = default;
-
-    // NOTE: See NOTE [gcc 7.3.1 bug workaround] for the changes made to this function.
-    template <typename Arg,
-              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                               int> = 0,
-              std::size_t I = detail_::best_match<Arg, Ts...>::value,
-              typename T = lib::type_pack_element_t<detail_::best_match<Arg, Ts...>::value, Ts...>,
-              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
-                                std::is_constructible<T, Arg>::value),
-                               int> = 0>
-    inline variant &operator=(Arg &&arg) noexcept(
-        (std::is_nothrow_assignable<T &, Arg>::value &&
-         std::is_nothrow_constructible<T, Arg>::value)) {
-      static_assert(
+  // NOTE [gcc 7.3.1 bug workaround]
+  //
+  // The original line `typename T = lib::type_pack_element_t<I, Ts...>`
+  // throws the following compiler error on gcc 7.3.1:
+  // ```
+  // ../c10/util/variant.h:2250:9: internal compiler error:
+  // unexpected expression ‘I’ of kind template_parm_index
+  //          typename T = lib::type_pack_element_t<I, Ts...>,
+  //          ^~~~~~~~
+  // ```
+  // As a workaround, `I` is changed to `detail_::best_match<Arg,
+  // Ts...>::value`, which is the default value for `I` in this template. Note
+  // that this workaround effectively disallows setting `I` to any other
+  // non-default value, and we add a `static_assert` in the function body to
+  // check for this.
+  //
+  // See the following issues for more context:
+  // - https://github.com/mpark/variant/issues/43
+  // - https://github.com/eggs-cpp/variant/issues/31
+  template <
+      typename Arg,
+      typename Decayed = lib::decay_t<Arg>,
+      lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
+      lib::enable_if_t<!detail_::is_in_place_index<Decayed>::value, int> = 0,
+      lib::enable_if_t<!detail_::is_in_place_type<Decayed>::value, int> = 0,
+      std::size_t I = detail_::best_match<Arg, Ts...>::value,
+      typename T = lib::
+          type_pack_element_t<detail_::best_match<Arg, Ts...>::value, Ts...>,
+      lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
+  inline constexpr variant(Arg&& arg) noexcept(
+      std::is_nothrow_constructible<T, Arg>::value)
+      : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {
+    static_assert(
         I == detail_::best_match<Arg, Ts...>::value,
         "Setting template parameter `I` to a custom non-default value is not supported. "
         "Please file a feature request if you see this.");
-      impl_.template assign<I>(lib::forward<Arg>(arg));
-      return *this;
-    }
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    inline constexpr bool valueless_by_exception() const noexcept {
-      return impl_.valueless_by_exception();
-    }
-
-    inline constexpr std::size_t index() const noexcept {
-      return impl_.index();
-    }
-
-    template <bool Dummy = true,
-              lib::enable_if_t<
-                  lib::all<Dummy,
-                           (lib::dependent_type<std::is_move_constructible<Ts>,
-                                                Dummy>::value &&
-                            lib::dependent_type<lib::is_swappable<Ts>,
-                                                Dummy>::value)...>::value,
-                  int> = 0>
-    inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
-      impl_.swap(that.impl_);
-    }
-
-    private:
-    detail_::impl<Ts...> impl_;
-
-    friend struct detail_::access::variant;
-    friend struct detail_::visitation::variant;
-  };
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return v.index() == I;
   }
 
-  template <typename T, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return holds_alternative<detail_::find_index_checked<T, Ts...>::value>(v);
+  template <
+      std::size_t I,
+      typename... Args,
+      typename T = lib::type_pack_element_t<I, Ts...>,
+      lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+  inline explicit constexpr variant(
+      in_place_index_t<I>,
+      Args&&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+      : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+
+  template <
+      std::size_t I,
+      typename Up,
+      typename... Args,
+      typename T = lib::type_pack_element_t<I, Ts...>,
+      lib::enable_if_t<
+          std::is_constructible<T, std::initializer_list<Up>&, Args...>::value,
+          int> = 0>
+  inline explicit constexpr variant(
+      in_place_index_t<I>,
+      std::initializer_list<Up> il,
+      Args&&... args) noexcept(std::
+                                   is_nothrow_constructible<
+                                       T,
+                                       std::initializer_list<Up>&,
+                                       Args...>::value)
+      : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+
+  template <
+      typename T,
+      typename... Args,
+      std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
+      lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+  inline explicit constexpr variant(
+      in_place_type_t<T>,
+      Args&&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+      : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
+
+  template <
+      typename T,
+      typename Up,
+      typename... Args,
+      std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
+      lib::enable_if_t<
+          std::is_constructible<T, std::initializer_list<Up>&, Args...>::value,
+          int> = 0>
+  inline explicit constexpr variant(
+      in_place_type_t<T>,
+      std::initializer_list<Up> il,
+      Args&&... args) noexcept(std::
+                                   is_nothrow_constructible<
+                                       T,
+                                       std::initializer_list<Up>&,
+                                       Args...>::value)
+      : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
+
+  ~variant() = default;
+
+  variant& operator=(const variant&) = default;
+  variant& operator=(variant&&) = default;
+
+  // NOTE: See NOTE [gcc 7.3.1 bug workaround] for the changes made to this
+  // function.
+  template <
+      typename Arg,
+      lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value, int> =
+          0,
+      std::size_t I = detail_::best_match<Arg, Ts...>::value,
+      typename T = lib::
+          type_pack_element_t<detail_::best_match<Arg, Ts...>::value, Ts...>,
+      lib::enable_if_t<
+          (std::is_assignable<T&, Arg>::value &&
+           std::is_constructible<T, Arg>::value),
+          int> = 0>
+  inline variant& operator=(Arg&& arg) noexcept(
+      (std::is_nothrow_assignable<T&, Arg>::value &&
+       std::is_nothrow_constructible<T, Arg>::value)) {
+    static_assert(
+        I == detail_::best_match<Arg, Ts...>::value,
+        "Setting template parameter `I` to a custom non-default value is not supported. "
+        "Please file a feature request if you see this.");
+    impl_.template assign<I>(lib::forward<Arg>(arg));
+    return *this;
   }
 
-  namespace detail_ {
-    template <std::size_t I, typename V>
-    struct generic_get_impl {
-      constexpr generic_get_impl(int) noexcept {}
-
-      constexpr AUTO_REFREF operator()(V &&v) const
-        AUTO_REFREF_RETURN(
-            access::variant::get_alt<I>(lib::forward<V>(v)).value)
-    };
-
-    template <std::size_t I, typename V>
-    inline constexpr AUTO_REFREF generic_get(V &&v)
-      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
-          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
-          lib::forward<V>(v)))
-  }  // namespace detail_
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
-      variant<Ts...> &v) {
-    return detail_::generic_get<I>(v);
+  template <
+      std::size_t I,
+      typename... Args,
+      typename T = lib::type_pack_element_t<I, Ts...>,
+      lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+  inline T& emplace(Args&&... args) {
+    return impl_.template emplace<I>(lib::forward<Args>(args)...);
   }
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
-      variant<Ts...> &&v) {
-    return detail_::generic_get<I>(lib::move(v));
+  template <
+      std::size_t I,
+      typename Up,
+      typename... Args,
+      typename T = lib::type_pack_element_t<I, Ts...>,
+      lib::enable_if_t<
+          std::is_constructible<T, std::initializer_list<Up>&, Args...>::value,
+          int> = 0>
+  inline T& emplace(std::initializer_list<Up> il, Args&&... args) {
+    return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
   }
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
-      const variant<Ts...> &v) {
-    return detail_::generic_get<I>(v);
+  template <
+      typename T,
+      typename... Args,
+      std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
+      lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
+  inline T& emplace(Args&&... args) {
+    return impl_.template emplace<I>(lib::forward<Args>(args)...);
   }
 
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
-      const variant<Ts...> &&v) {
-    return detail_::generic_get<I>(lib::move(v));
+  template <
+      typename T,
+      typename Up,
+      typename... Args,
+      std::size_t I = detail_::find_index_sfinae<T, Ts...>::value,
+      lib::enable_if_t<
+          std::is_constructible<T, std::initializer_list<Up>&, Args...>::value,
+          int> = 0>
+  inline T& emplace(std::initializer_list<Up> il, Args&&... args) {
+    return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
   }
 
-  template <typename T, typename... Ts>
-  inline constexpr T &get(variant<Ts...> &v) {
-    return get<detail_::find_index_checked<T, Ts...>::value>(v);
+  inline constexpr bool valueless_by_exception() const noexcept {
+    return impl_.valueless_by_exception();
   }
 
-  template <typename T, typename... Ts>
-  inline constexpr T &&get(variant<Ts...> &&v) {
-    return get<detail_::find_index_checked<T, Ts...>::value>(lib::move(v));
+  inline constexpr std::size_t index() const noexcept {
+    return impl_.index();
   }
 
-  template <typename T, typename... Ts>
-  inline constexpr const T &get(const variant<Ts...> &v) {
-    return get<detail_::find_index_checked<T, Ts...>::value>(v);
+  template <
+      bool Dummy = true,
+      lib::enable_if_t<
+          lib::all<
+              Dummy,
+              (lib::dependent_type<std::is_move_constructible<Ts>, Dummy>::
+                   value &&
+               lib::dependent_type<lib::is_swappable<Ts>, Dummy>::value)...>::
+              value,
+          int> = 0>
+  inline void swap(variant& that) noexcept(
+      lib::all<
+          (std::is_nothrow_move_constructible<Ts>::value &&
+           lib::is_nothrow_swappable<Ts>::value)...>::value) {
+    impl_.swap(that.impl_);
   }
 
-  template <typename T, typename... Ts>
-  inline constexpr const T &&get(const variant<Ts...> &&v) {
-    return get<detail_::find_index_checked<T, Ts...>::value>(lib::move(v));
+ private:
+  detail_::impl<Ts...> impl_;
+
+  friend struct detail_::access::variant;
+  friend struct detail_::visitation::variant;
+};
+
+template <std::size_t I, typename... Ts>
+inline constexpr bool holds_alternative(const variant<Ts...>& v) noexcept {
+  return v.index() == I;
+}
+
+template <typename T, typename... Ts>
+inline constexpr bool holds_alternative(const variant<Ts...>& v) noexcept {
+  return holds_alternative<detail_::find_index_checked<T, Ts...>::value>(v);
+}
+
+namespace detail_ {
+template <std::size_t I, typename V>
+struct generic_get_impl {
+  constexpr generic_get_impl(int) noexcept {}
+
+  constexpr AUTO_REFREF operator()(V&& v) const
+      AUTO_REFREF_RETURN(access::variant::get_alt<I>(lib::forward<V>(v)).value)
+};
+
+template <std::size_t I, typename V>
+inline constexpr AUTO_REFREF generic_get(V&& v)
+    AUTO_REFREF_RETURN(generic_get_impl<I, V>(
+        holds_alternative<I>(v)
+            ? 0
+            : (throw_bad_variant_access(), 0))(lib::forward<V>(v)))
+} // namespace detail_
+
+template <std::size_t I, typename... Ts>
+inline constexpr variant_alternative_t<I, variant<Ts...>>& get(
+    variant<Ts...>& v) {
+  return detail_::generic_get<I>(v);
+}
+
+template <std::size_t I, typename... Ts>
+inline constexpr variant_alternative_t<I, variant<Ts...>>&& get(
+    variant<Ts...>&& v) {
+  return detail_::generic_get<I>(lib::move(v));
+}
+
+template <std::size_t I, typename... Ts>
+inline constexpr const variant_alternative_t<I, variant<Ts...>>& get(
+    const variant<Ts...>& v) {
+  return detail_::generic_get<I>(v);
+}
+
+template <std::size_t I, typename... Ts>
+inline constexpr const variant_alternative_t<I, variant<Ts...>>&& get(
+    const variant<Ts...>&& v) {
+  return detail_::generic_get<I>(lib::move(v));
+}
+
+template <typename T, typename... Ts>
+inline constexpr T& get(variant<Ts...>& v) {
+  return get<detail_::find_index_checked<T, Ts...>::value>(v);
+}
+
+template <typename T, typename... Ts>
+inline constexpr T&& get(variant<Ts...>&& v) {
+  return get<detail_::find_index_checked<T, Ts...>::value>(lib::move(v));
+}
+
+template <typename T, typename... Ts>
+inline constexpr const T& get(const variant<Ts...>& v) {
+  return get<detail_::find_index_checked<T, Ts...>::value>(v);
+}
+
+template <typename T, typename... Ts>
+inline constexpr const T&& get(const variant<Ts...>&& v) {
+  return get<detail_::find_index_checked<T, Ts...>::value>(lib::move(v));
+}
+
+namespace detail_ {
+
+template <std::size_t I, typename V>
+inline constexpr /* auto * */ AUTO generic_get_if(V* v) noexcept AUTO_RETURN(
+    v&& holds_alternative<I>(*v)
+        ? lib::addressof(access::variant::get_alt<I>(*v).value)
+        : nullptr)
+
+} // namespace detail_
+
+template <std::size_t I, typename... Ts>
+inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
+get_if(variant<Ts...>* v) noexcept {
+  return detail_::generic_get_if<I>(v);
+}
+
+template <std::size_t I, typename... Ts>
+inline constexpr lib::add_pointer_t<
+    const variant_alternative_t<I, variant<Ts...>>>
+get_if(const variant<Ts...>* v) noexcept {
+  return detail_::generic_get_if<I>(v);
+}
+
+template <typename T, typename... Ts>
+inline constexpr lib::add_pointer_t<T> get_if(variant<Ts...>* v) noexcept {
+  return get_if<detail_::find_index_checked<T, Ts...>::value>(v);
+}
+
+template <typename T, typename... Ts>
+inline constexpr lib::add_pointer_t<const T> get_if(
+    const variant<Ts...>* v) noexcept {
+  return get_if<detail_::find_index_checked<T, Ts...>::value>(v);
+}
+
+namespace detail_ {
+template <typename RelOp>
+struct convert_to_bool {
+  template <typename Lhs, typename Rhs>
+  inline constexpr bool operator()(Lhs&& lhs, Rhs&& rhs) const {
+    static_assert(
+        std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>, bool>::value,
+        "relational operators must return a type"
+        " implicitly convertible to bool");
+    return lib::invoke(RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
   }
+};
+} // namespace detail_
 
-  namespace detail_ {
-
-    template <std::size_t I, typename V>
-    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
-      AUTO_RETURN(v && holds_alternative<I>(*v)
-                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                      : nullptr)
-
-  }  // namespace detail_
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-  get_if(variant<Ts...> *v) noexcept {
-    return detail_::generic_get_if<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<
-      const variant_alternative_t<I, variant<Ts...>>>
-  get_if(const variant<Ts...> *v) noexcept {
-    return detail_::generic_get_if<I>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<T>
-  get_if(variant<Ts...> *v) noexcept {
-    return get_if<detail_::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<const T>
-  get_if(const variant<Ts...> *v) noexcept {
-    return get_if<detail_::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  namespace detail_ {
-    template <typename RelOp>
-    struct convert_to_bool {
-      template <typename Lhs, typename Rhs>
-      inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const {
-        static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>,
-                                          bool>::value,
-                      "relational operators must return a type"
-                      " implicitly convertible to bool");
-        return lib::invoke(
-            RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
-      }
-    };
-  }  // namespace detail_
-
-  template <typename... Ts>
-  inline constexpr bool operator==(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using equal_to = detail_::convert_to_bool<lib::equal_to>;
+template <typename... Ts>
+inline constexpr bool operator==(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using equal_to = detail_::convert_to_bool<lib::equal_to>;
 #ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
-#else
-    return lhs.index() == rhs.index() &&
-           (lhs.valueless_by_exception() ||
-            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator!=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using not_equal_to = detail_::convert_to_bool<lib::not_equal_to>;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
-#else
-    return lhs.index() != rhs.index() ||
-           (!lhs.valueless_by_exception() &&
-            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using less = detail_::convert_to_bool<lib::less>;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
-#else
-    return !rhs.valueless_by_exception() &&
-           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using greater = detail_::convert_to_bool<lib::greater>;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return false;
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
-#else
-    return !lhs.valueless_by_exception() &&
-           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using less_equal = detail_::convert_to_bool<lib::less_equal>;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return true;
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
-#else
-    return lhs.valueless_by_exception() ||
-           (!rhs.valueless_by_exception() &&
-            (lhs.index() < rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail_::visitation::variant;
-    using greater_equal = detail_::convert_to_bool<lib::greater_equal>;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
-#else
-    return rhs.valueless_by_exception() ||
-           (!lhs.valueless_by_exception() &&
-            (lhs.index() > rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(
-                  lhs.index(), greater_equal{}, lhs, rhs))));
-#endif
-  }
-
-  struct monostate {};
-
-  inline constexpr bool operator<(monostate, monostate) noexcept {
+  if (lhs.index() != rhs.index())
     return false;
-  }
+  if (lhs.valueless_by_exception())
+    return true;
+  return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
+#else
+  return lhs.index() == rhs.index() &&
+      (lhs.valueless_by_exception() ||
+       variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
+#endif
+}
 
-  inline constexpr bool operator>(monostate, monostate) noexcept {
+template <typename... Ts>
+inline constexpr bool operator!=(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using not_equal_to = detail_::convert_to_bool<lib::not_equal_to>;
+#ifdef MPARK_CPP14_CONSTEXPR
+  if (lhs.index() != rhs.index())
+    return true;
+  if (lhs.valueless_by_exception())
     return false;
-  }
+  return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
+#else
+  return lhs.index() != rhs.index() ||
+      (!lhs.valueless_by_exception() &&
+       variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
+#endif
+}
 
-  inline constexpr bool operator<=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator>=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator==(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator!=(monostate, monostate) noexcept {
+template <typename... Ts>
+inline constexpr bool operator<(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using less = detail_::convert_to_bool<lib::less>;
+#ifdef MPARK_CPP14_CONSTEXPR
+  if (rhs.valueless_by_exception())
     return false;
-  }
+  if (lhs.valueless_by_exception())
+    return true;
+  if (lhs.index() < rhs.index())
+    return true;
+  if (lhs.index() > rhs.index())
+    return false;
+  return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
+#else
+  return !rhs.valueless_by_exception() &&
+      (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
+       (lhs.index() == rhs.index() &&
+        variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
+#endif
+}
+
+template <typename... Ts>
+inline constexpr bool operator>(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using greater = detail_::convert_to_bool<lib::greater>;
+#ifdef MPARK_CPP14_CONSTEXPR
+  if (lhs.valueless_by_exception())
+    return false;
+  if (rhs.valueless_by_exception())
+    return true;
+  if (lhs.index() > rhs.index())
+    return true;
+  if (lhs.index() < rhs.index())
+    return false;
+  return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
+#else
+  return !lhs.valueless_by_exception() &&
+      (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
+       (lhs.index() == rhs.index() &&
+        variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
+#endif
+}
+
+template <typename... Ts>
+inline constexpr bool operator<=(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using less_equal = detail_::convert_to_bool<lib::less_equal>;
+#ifdef MPARK_CPP14_CONSTEXPR
+  if (lhs.valueless_by_exception())
+    return true;
+  if (rhs.valueless_by_exception())
+    return false;
+  if (lhs.index() < rhs.index())
+    return true;
+  if (lhs.index() > rhs.index())
+    return false;
+  return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
+#else
+  return lhs.valueless_by_exception() ||
+      (!rhs.valueless_by_exception() &&
+       (lhs.index() < rhs.index() ||
+        (lhs.index() == rhs.index() &&
+         variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
+#endif
+}
+
+template <typename... Ts>
+inline constexpr bool operator>=(
+    const variant<Ts...>& lhs,
+    const variant<Ts...>& rhs) {
+  using detail_::visitation::variant;
+  using greater_equal = detail_::convert_to_bool<lib::greater_equal>;
+#ifdef MPARK_CPP14_CONSTEXPR
+  if (rhs.valueless_by_exception())
+    return true;
+  if (lhs.valueless_by_exception())
+    return false;
+  if (lhs.index() > rhs.index())
+    return true;
+  if (lhs.index() < rhs.index())
+    return false;
+  return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
+#else
+  return rhs.valueless_by_exception() ||
+      (!lhs.valueless_by_exception() &&
+       (lhs.index() > rhs.index() ||
+        (lhs.index() == rhs.index() &&
+         variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs))));
+#endif
+}
+
+struct monostate {};
+
+inline constexpr bool operator<(monostate, monostate) noexcept {
+  return false;
+}
+
+inline constexpr bool operator>(monostate, monostate) noexcept {
+  return false;
+}
+
+inline constexpr bool operator<=(monostate, monostate) noexcept {
+  return true;
+}
+
+inline constexpr bool operator>=(monostate, monostate) noexcept {
+  return true;
+}
+
+inline constexpr bool operator==(monostate, monostate) noexcept {
+  return true;
+}
+
+inline constexpr bool operator!=(monostate, monostate) noexcept {
+  return false;
+}
 
 #ifdef MPARK_CPP14_CONSTEXPR
-  namespace detail_ {
+namespace detail_ {
 
-    inline constexpr bool any(std::initializer_list<bool> bs) {
-      for (bool b : bs) {
-        if (b) {
-          return true;
-        }
-      }
-      return false;
+inline constexpr bool any(std::initializer_list<bool> bs) {
+  for (bool b : bs) {
+    if (b) {
+      return true;
     }
-
-  }  // namespace detail_
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
-    return (!detail_::any({vs.valueless_by_exception()...})
-                ? (void)0
-                : throw_bad_variant_access()),
-           detail_::visitation::variant::visit_value(
-               lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
   }
+  return false;
+}
+
+} // namespace detail_
+
+template <typename Visitor, typename... Vs>
+inline constexpr decltype(auto) visit(Visitor&& visitor, Vs&&... vs) {
+  return (!detail_::any({vs.valueless_by_exception()...})
+              ? (void)0
+              : throw_bad_variant_access()),
+         detail_::visitation::variant::visit_value(
+             lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
+}
 #else
-  namespace detail_ {
+namespace detail_ {
 
-    template <std::size_t N>
-    inline constexpr bool all_impl(const lib::array<bool, N> &bs,
-                                   std::size_t idx) {
-      return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
-    }
+template <std::size_t N>
+inline constexpr bool all_impl(const lib::array<bool, N>& bs, std::size_t idx) {
+  return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
+}
 
-    template <std::size_t N>
-    inline constexpr bool all(const lib::array<bool, N> &bs) {
-      return all_impl(bs, 0);
-    }
+template <std::size_t N>
+inline constexpr bool all(const lib::array<bool, N>& bs) {
+  return all_impl(bs, 0);
+}
 
-  }  // namespace detail_
+} // namespace detail_
 
-  template <typename Visitor, typename... Vs>
-  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
+template <typename Visitor, typename... Vs>
+inline constexpr DECLTYPE_AUTO visit(Visitor&& visitor, Vs&&... vs)
     DECLTYPE_AUTO_RETURN(
-        (detail_::all(
-             lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
+        (detail_::all(lib::array<bool, sizeof...(Vs)>{
+             {!vs.valueless_by_exception()...}})
              ? (void)0
              : throw_bad_variant_access()),
-        detail_::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                                 lib::forward<Vs>(vs)...))
+        detail_::visitation::variant::visit_value(
+            lib::forward<Visitor>(visitor),
+            lib::forward<Vs>(vs)...))
 #endif
 
-  template <typename... Ts>
-  inline auto swap(variant<Ts...> &lhs,
-                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-      -> decltype(lhs.swap(rhs)) {
-    lhs.swap(rhs);
-  }
+template <typename... Ts>
+inline auto swap(variant<Ts...>& lhs, variant<Ts...>& rhs) noexcept(
+    noexcept(lhs.swap(rhs))) -> decltype(lhs.swap(rhs)) {
+  lhs.swap(rhs);
+}
 
-  namespace detail_ {
+namespace detail_ {
 
-    template <typename T, typename...>
-    using enabled_type = T;
+template <typename T, typename...>
+using enabled_type = T;
 
-    namespace hash {
+namespace hash {
 
-      template <typename H, typename K>
-      constexpr bool meets_requirements() noexcept {
-        return std::is_copy_constructible<H>::value &&
-               std::is_move_constructible<H>::value &&
-               lib::is_invocable_r<std::size_t, H, const K &>::value;
-      }
+template <typename H, typename K>
+constexpr bool meets_requirements() noexcept {
+  return std::is_copy_constructible<H>::value &&
+      std::is_move_constructible<H>::value &&
+      lib::is_invocable_r<std::size_t, H, const K&>::value;
+}
 
-      template <typename K>
-      constexpr bool is_enabled() noexcept {
-        using H = std::hash<K>;
-        return meets_requirements<H, K>() &&
-               std::is_default_constructible<H>::value &&
-               std::is_copy_assignable<H>::value &&
-               std::is_move_assignable<H>::value;
-      }
+template <typename K>
+constexpr bool is_enabled() noexcept {
+  using H = std::hash<K>;
+  return meets_requirements<H, K>() &&
+      std::is_default_constructible<H>::value &&
+      std::is_copy_assignable<H>::value && std::is_move_assignable<H>::value;
+}
 
-    }  // namespace hash
+} // namespace hash
 
-  }  // namespace detail_
+} // namespace detail_
 
 #undef AUTO
 #undef AUTO_RETURN
@@ -2791,67 +2934,66 @@ namespace c10 {
 #undef DECLTYPE_AUTO
 #undef DECLTYPE_AUTO_RETURN
 
-}  // namespace c10
+} // namespace c10
 
 namespace std {
 
-  template <typename... Ts>
-  struct hash<c10::detail_::enabled_type<
-      c10::variant<Ts...>,
-      c10::lib::enable_if_t<c10::lib::all<c10::detail_::hash::is_enabled<
-          c10::lib::remove_const_t<Ts>>()...>::value>>> {
-    using argument_type = c10::variant<Ts...>;
-    using result_type = std::size_t;
+template <typename... Ts>
+struct hash<c10::detail_::enabled_type<
+    c10::variant<Ts...>,
+    c10::lib::enable_if_t<c10::lib::all<c10::detail_::hash::is_enabled<
+        c10::lib::remove_const_t<Ts>>()...>::value>>> {
+  using argument_type = c10::variant<Ts...>;
+  using result_type = std::size_t;
 
-    inline result_type operator()(const argument_type &v) const {
-      using c10::detail_::visitation::variant;
-      std::size_t result =
-          v.valueless_by_exception()
-              ? 299792458  // Random value chosen by the universe upon creation
-              : variant::visit_alt(
+  inline result_type operator()(const argument_type& v) const {
+    using c10::detail_::visitation::variant;
+    std::size_t result = v.valueless_by_exception()
+        ? 299792458 // Random value chosen by the universe upon creation
+        : variant::visit_alt(
 #ifdef MPARK_GENERIC_LAMBDAS
-                    [](const auto &alt) {
-                      using alt_type = c10::lib::decay_t<decltype(alt)>;
-                      using value_type = c10::lib::remove_const_t<
-                          typename alt_type::value_type>;
-                      return hash<value_type>{}(alt.value);
-                    }
+              [](const auto& alt) {
+                using alt_type = c10::lib::decay_t<decltype(alt)>;
+                using value_type =
+                    c10::lib::remove_const_t<typename alt_type::value_type>;
+                return hash<value_type>{}(alt.value);
+              }
 #else
-                    hasher{}
+              hasher {}
 #endif
-                    ,
-                    v);
-      return hash_combine(result, hash<std::size_t>{}(v.index()));
-    }
+              ,
+              v);
+    return hash_combine(result, hash<std::size_t>{}(v.index()));
+  }
 
-    private:
+ private:
 #ifndef MPARK_GENERIC_LAMBDAS
-    struct hasher {
-      template <typename Alt>
-      inline std::size_t operator()(const Alt &alt) const {
-        using alt_type = c10::lib::decay_t<Alt>;
-        using value_type =
-            c10::lib::remove_const_t<typename alt_type::value_type>;
-        return hash<value_type>{}(alt.value);
-      }
-    };
+  struct hasher {
+    template <typename Alt>
+    inline std::size_t operator()(const Alt& alt) const {
+      using alt_type = c10::lib::decay_t<Alt>;
+      using value_type =
+          c10::lib::remove_const_t<typename alt_type::value_type>;
+      return hash<value_type>{}(alt.value);
+    }
+  };
 #endif
 
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
-      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
-    }
-  };
+  static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
+    return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
+  }
+};
 
-  template <>
-  struct hash<c10::monostate> {
-    using argument_type = c10::monostate;
-    using result_type = std::size_t;
+template <>
+struct hash<c10::monostate> {
+  using argument_type = c10::monostate;
+  using result_type = std::size_t;
 
-    inline result_type operator()(const argument_type &) const noexcept {
-      return 66740831;  // return a fundamentally attractive random value.
-    }
-  };
+  inline result_type operator()(const argument_type&) const noexcept {
+    return 66740831; // return a fundamentally attractive random value.
+  }
+};
 
-}  // namespace std
+} // namespace std
 
-#endif  // C10_UTIL_VARIANT_H_
+#endif // C10_UTIL_VARIANT_H_
diff --git a/c10/util/win32-headers.h b/c10/util/win32-headers.h
index ef79c9f372b..6a3e8bc2caf 100644
--- a/c10/util/win32-headers.h
+++ b/c10/util/win32-headers.h
@@ -34,8 +34,11 @@
 #define NOCLIPBOARD
 #endif
 
+// dbghelp seems to require windows.h.
+// clang-format off
 #include <windows.h>
 #include <dbghelp.h>
+// clang-format on
 
 #undef VOID
 #undef DELETE
diff --git a/tools/clang_format_all.py b/tools/clang_format_all.py
index 77ca68d92b0..e09659333d8 100755
--- a/tools/clang_format_all.py
+++ b/tools/clang_format_all.py
@@ -17,7 +17,12 @@ from clang_format_utils import get_and_check_clang_format, CLANG_FORMAT_PATH
 # Allowlist of directories to check. All files that in that directory
 # (recursively) will be checked.
 # If you edit this, please edit the allowlist in clang_format_ci.sh as well.
-CLANG_FORMAT_ALLOWLIST = ["torch/csrc/jit/", "test/cpp/jit/", "test/cpp/tensorexpr/"]
+CLANG_FORMAT_ALLOWLIST = [
+    "c10/",
+    "torch/csrc/jit/",
+    "test/cpp/jit/",
+    "test/cpp/tensorexpr/"
+]
 
 # Only files with names matching this regex will be formatted.
 CPP_FILE_REGEX = re.compile(".*\\.(h|cpp|cc|c|hpp)$")
diff --git a/tools/clang_format_ci.sh b/tools/clang_format_ci.sh
index c31afbe218a..05400dad265 100755
--- a/tools/clang_format_ci.sh
+++ b/tools/clang_format_ci.sh
@@ -6,6 +6,7 @@ set -eux
 
 # If you edit this allowlist, please edit the one in clang_format_all.py as well
 find . -type f \
+  -path './c10/*' -or \
   -path './torch/csrc/jit/*' -or \
   -path './test/cpp/jit/*' -or \
   -path './test/cpp/tensorexpr/*' \